diff --git a/CHANGELOG.md b/CHANGELOG.md index db37ec8..6aa47db 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,10 @@ SLC can now also raise your cruise speed automatically when the speed limit incr IQ.Pilot now detects upcoming speed cameras, red light cameras, and ALPR/surveillance cameras (including Flock Safety cameras) sourced from OpenStreetMap's and alerts you before you reach them. Each camera type has its own toggle so you can pick what you want to be warned about. Speed cameras can also trigger a speed reduction to the limit when detected if enabled. Camera data is sourced from OSM and is updated periodically. +**Direct Flock / ALPR Camera Detection (Bluetooth & WiFi)** + +Beyond map data, IQ.Pilot can now spot Flock Safety and similar ALPR cameras directly over the air by their Bluetooth and WiFi signatures as you approach them. Because it's sensing the actual hardware rather than relying on a map, this works anywhere, including fully offline and even for cameras that haven't been mapped yet, so you get a heads-up the moment one is nearby. When IQ.Pilot picks up a camera directly, that live detection takes priority over map data, so you see a single clear "Flock Camera Detected" alert instead of a duplicate. It shares the same Flock camera alert toggle, runs quietly in the background only when that's enabled, and is built to stay out of the way of your Bluetooth (phone link, game controllers) and WiFi connections. + **IQ.Dynamic and Driving Behavior** In IQ.Dynamic blended mode, when IQ.Pilot sees a stop light ahead, and the model agrees you need to stop, and there's no lead car to track, it will now commit (force) to stopping on its own, no lead car required. Gas pedal overrides it instantly. The stop prediction horizon is adjustable in IQ.Dynamic settings. Behavior for curves, low-speed driving, stopped leads, speed-limit fallbacks, and vision-based stops is now configurable. On-device IQ.Dynamic tuning is accessible by double-tapping IQ.Dynamic in longitudinal mode selection. diff --git a/artifacts/iqpilot_alc_private/manifest.json b/artifacts/iqpilot_alc_private/manifest.json index 7130c64..fb42059 100644 --- a/artifacts/iqpilot_alc_private/manifest.json +++ b/artifacts/iqpilot_alc_private/manifest.json @@ -16,13 +16,13 @@ }, "python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so": { "mode": 493, - "sha256": "77a601a12a498f09f01c4b1618e164638d5d9702913b6d5bb30a3c729a1c7d54", + "sha256": "16990383c7ba1d2f3d33e5e4c1746019101bc79bed867721b51de853a68002ed", "size": 401688 }, "python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so": { "mode": 493, - "sha256": "ca91f99d94c8bb7842332a69896d4b3a31c109c027426d1d7386876f11710d80", - "size": 69696 + "sha256": "bd060a8527d21501ce866f24d055f1c8bb03209b2730eb745b786780aace0aae", + "size": 69688 }, "runtime": { "entries": { @@ -37,7 +37,7 @@ } }, "signatures": { - "python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so": "4KY001fMJhdkiQNoUXbvtOKQ2nWocmg9ZL0umWnDjAztueIstXBoc1iqW83plm2Xq0jR9NLk1Jd4yl3AydWFBA==", - "python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so": "JqSaxsDJT9q0UYgVJUo9Pqm0J0Aqwy5gIa2C8n9/ioOg/fV6PLn2KiVGn6470U4F5oNaaOgAmm+AM9jwYrZXAA==" + "python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so": "IVz01J4HpdUHDrjPP9yB+9ksGFberB9MeFiCNLcv8hMzXCLIjIATl3JXTwpBqU8Kad/q683nkhgL5IJ3tCKdCw==", + "python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so": "/aW/StEMRpge+zzihQDK7VPLmKhgwCucX8JielvPnPTud/mk0pmCy5pE8fB+TbwtWZCBfVhEd1bidRgsBqZfBA==" } } diff --git a/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so b/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so index e27935a..ffc6160 100755 Binary files a/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so and b/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so differ diff --git a/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so b/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so index f0abb2a..c86c5cd 100755 Binary files a/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so and b/artifacts/iqpilot_alc_private/python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so differ diff --git a/cereal/custom.capnp b/cereal/custom.capnp index 4b65a94..110dc8e 100644 --- a/cereal/custom.capnp +++ b/cereal/custom.capnp @@ -315,6 +315,9 @@ struct IQOnroadEvent @0xf4621d3ee9233bc9 { # construction zone assist constructionZoneDetected @30; + + # model management + modelUpdating @31; } } diff --git a/cereal/log.capnp b/cereal/log.capnp index 39e9f50..590c92a 100644 --- a/cereal/log.capnp +++ b/cereal/log.capnp @@ -70,12 +70,12 @@ struct OnroadEvent @0xc4fa6047f024e718 { longitudinalManeuver @30; steerTempUnavailableSilent @31; resumeRequired @32; - driverDistracted1 @33; - driverDistracted2 @34; - driverDistracted3 @35; - driverUnresponsive1 @36; - driverUnresponsive2 @37; - driverUnresponsive3 @38; + preDriverDistracted @33; + promptDriverDistracted @34; + driverDistracted @35; + preDriverUnresponsive @36; + promptDriverUnresponsive @37; + driverUnresponsive @38; belowSteerSpeed @39; lowBattery @40; accFaulted @41; @@ -2183,7 +2183,6 @@ struct DriverStateV2 { rightBlinkProb @8 :Float32; sunglassesProb @9 :Float32; phoneProb @13 :Float32; - sleepProb @14 :Float32; notReadyProbDEPRECATED @12 :List(Float32); occludedProbDEPRECATED @10 :Float32; readyProbDEPRECATED @11 :List(Float32); @@ -2225,7 +2224,7 @@ struct DriverStateDEPRECATED @0xb83c6cc593ed0a00 { stdDEPRECATED @2 :Float32; } -struct DriverMonitoringStateDEPRECATED @0xb83cda094a1da284 { +struct DriverMonitoringState @0xb83cda094a1da284 { events @18 :List(OnroadEvent); faceDetected @1 :Bool; isDistracted @2 :Bool; @@ -2251,81 +2250,6 @@ struct DriverMonitoringStateDEPRECATED @0xb83cda094a1da284 { eventsDEPRECATED @0 :List(Car.OnroadEventDEPRECATED); } -struct DriverMonitoringState { - lockout @0 :Bool; - lockoutCount @15 :Int8; - lockoutMinutesRemaining @11 :Int8; - alert3Count @12 :Int8; - noResponseCount @13 :Int8; - noResponseForceDecel @14 :Bool; - - alwaysOn @3 :Bool; - alwaysOnLockout @4 :Bool; - - alertLevel @5 :AlertLevel; - activePolicy @6 :MonitoringPolicy; - isRHD @7 :Bool; - rhdCalibration @8 :CalibrationState; - - visionPolicyState @9 :VisionPolicyState; - wheeltouchPolicyState @10 :WheeltouchPolicyState; - - enum AlertLevel { - none @0; - one @1; - two @2; - three @3; - } - - enum MonitoringPolicy { - wheeltouch @0; - vision @1; - } - - struct VisionPolicyState { - awarenessPercent @0 :Int8; - awarenessStep @1 :Float32; - isDistracted @2 :Bool; - distractedTypes @3 :DistractedTypes; - - faceDetected @4 :Bool; - pose @5 :Pose; - wheeltouchFallbackPercent @6 :Int8; - uncertainOffroadAlertPercent @7 :Int8; - - struct DistractedTypes { - pose @0: Bool; - eye @1: Bool; - phone @2: Bool; - } - - struct Pose { - pitch @0 :Float32; - yaw @1 :Float32; - pitchCalib @2 :CalibrationState; - yawCalib @3 :CalibrationState; - calibrated @4 :Bool; - uncertainty @5 :Float32; - } - } - - struct WheeltouchPolicyState { - awarenessPercent @0 :Int8; - awarenessStep @1 :Float32; - driverInteracting @2 :Bool; - } - - struct CalibrationState { - calibratedPercent @0 :Int8; - offset @1 :Float32; - } - - deprecated :group { - alertCountLockoutPercent @1 :Int8; - alertTimeLockoutPercent @2 :Int8; - } -} - struct Boot { wallTimeNanos @0 :UInt64; pstore @4 :Map(Text, Data); @@ -2646,7 +2570,7 @@ struct Event { thumbnail @66: Thumbnail; onroadEvents @134: List(OnroadEvent); carParams @69: Car.CarParams; - driverMonitoringState @165: DriverMonitoringState; + driverMonitoringState @71: DriverMonitoringState; livePose @129 :LivePose; modelV2 @75 :ModelDataV2; drivingModelData @128 :DrivingModelData; @@ -2769,7 +2693,6 @@ struct Event { wifiScanDEPRECATED @29 :List(Legacy.WifiScan); uiNavigationEventDEPRECATED @50 :Legacy.UiNavigationEvent; liveMapDataDEPRECATED @62 :LiveMapDataDEPRECATED; - driverMonitoringStateDEPRECATED @71 :DriverMonitoringStateDEPRECATED; gpsPlannerPointsDEPRECATED @40 :Legacy.GPSPlannerPoints; gpsPlannerPlanDEPRECATED @41 :Legacy.GPSPlannerPlan; applanixRawDEPRECATED @42 :Data; diff --git a/common/params_keys.h b/common/params_keys.h index de2194c..1a6bfc9 100644 --- a/common/params_keys.h +++ b/common/params_keys.h @@ -41,7 +41,6 @@ inline static std::unordered_map keys = { {"DoShutdown", {CLEAR_ON_MANAGER_START, BOOL}}, {"DoUninstall", {CLEAR_ON_MANAGER_START, BOOL}}, {"DriverTooDistracted", {CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON, BOOL}}, - {"DriverLockoutCount", {CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON, INT, "0"}}, {"AlphaLongitudinalEnabled", {PERSISTENT, BOOL}}, {"ExperimentalMode", {PERSISTENT, BOOL}}, {"ExperimentalModeConfirmed", {PERSISTENT, BOOL}}, @@ -132,7 +131,7 @@ inline static std::unordered_map keys = { {"SnoozeUpdate", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL}}, {"SshEnabled", {PERSISTENT, BOOL}}, {"TermsVersion", {PERSISTENT, STRING}}, - {"TorqueBar", {PERSISTENT, BOOL, "0"}}, + {"IQSteerEffortArc", {PERSISTENT, BOOL, "0"}}, {"TrainingVersion", {PERSISTENT, STRING}}, {"UbloxAvailable", {PERSISTENT, BOOL}}, {"UsbStorageEnabled", {PERSISTENT, BOOL}}, @@ -167,7 +166,7 @@ inline static std::unordered_map keys = { {"CarPlatformBundle", {PERSISTENT, JSON}}, {"Konn3ktVwOdometers", {PERSISTENT, JSON}}, {"Konn3ktVehicleOdometers", {PERSISTENT, JSON}}, - {"ChevronInfo", {PERSISTENT, INT, "4"}}, + {"IQLeadReadouts", {PERSISTENT, INT, "4"}}, {"DeviceBootMode", {PERSISTENT, INT, "0"}}, {"IQDevUIInfo", {PERSISTENT, INT, "0"}}, {"EnableEsimProvisioning", {PERSISTENT, BOOL, "1"}}, @@ -201,9 +200,8 @@ inline static std::unordered_map keys = { {"OfflineTilesBaseUrl", {PERSISTENT, STRING}}, {"OnroadUploads", {PERSISTENT, BOOL, "1"}}, {"IQAlertSilence", {PERSISTENT, BOOL, "0"}}, - {"RainbowMode", {PERSISTENT, BOOL, "0"}}, - {"RocketFuel", {PERSISTENT, BOOL, "0"}}, - {"ShowTurnSignals", {PERSISTENT, BOOL, "0"}}, + {"IQAccelMeter", {PERSISTENT, BOOL, "0"}}, + {"IQBlinkerIndicators", {PERSISTENT, BOOL, "0"}}, {"StandstillTimer", {PERSISTENT, BOOL, "0"}}, // AOL (Always On Lateral) params {"AolEnabled", {PERSISTENT, BOOL, "1"}}, @@ -215,7 +213,7 @@ inline static std::unordered_map keys = { {"ModelManager_ActiveBundle", {PERSISTENT, JSON}}, {"ModelManager_ClearCache", {CLEAR_ON_MANAGER_START, BOOL}}, {"ModelManager_DownloadIndex", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, INT, "-1"}}, - {"ModelManager_Favs", {PERSISTENT, STRING}}, + {"IQModelFavorites", {PERSISTENT, STRING}}, {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}}, {"ModelManager_ModelsCache", {PERSISTENT, JSON}}, @@ -227,7 +225,7 @@ inline static std::unordered_map keys = { {"BackupManager_RestoreVersion", {PERSISTENT, STRING}}, // iqpilot car specific params - {"HyundaiLongitudinalTuning", {PERSISTENT, INT, "0"}}, + {"IQHyundaiLongTune", {PERSISTENT, INT, "0"}}, {"AutoCruiseControl", {PERSISTENT, INT, "0"}}, {"AutoEngage", {PERSISTENT, INT, "0"}}, {"CanfdDebug", {PERSISTENT, INT, "0"}}, @@ -254,10 +252,10 @@ inline static std::unordered_map keys = { {"LongitudinalPersonalityMax", {PERSISTENT, INT, "3"}}, {"MaxAngleFrames", {PERSISTENT, INT, "89"}}, {"SpeedFromPCM", {PERSISTENT, INT, "2"}}, - {"SubaruStopAndGo", {PERSISTENT, BOOL, "0"}}, - {"SubaruStopAndGoManualParkingBrake", {PERSISTENT, BOOL, "0"}}, - {"TeslaCoopSteering", {PERSISTENT, BOOL, "0"}}, - {"ToyotaEnforceStockLongitudinal", {PERSISTENT, BOOL, "0"}}, + {"IQSubaruCreepAssist", {PERSISTENT, BOOL, "0"}}, + {"IQSubaruCreepAssistManualBrake", {PERSISTENT, BOOL, "0"}}, + {"IQTeslaTorqueBlend", {PERSISTENT, BOOL, "0"}}, + {"IQToyotaFactoryLong", {PERSISTENT, BOOL, "0"}}, {"VwPqEpsPatched", {PERSISTENT, BOOL}}, {"ToyotaSnGHack", {PERSISTENT, BOOL, "0"}}, {"pqhca5or7Toggle", {PERSISTENT, BOOL}}, @@ -278,7 +276,7 @@ inline static std::unordered_map keys = { {"IQDynamicMinimumForceStopLength", {PERSISTENT, FLOAT, "0.0"}}, {"IQForceStops", {PERSISTENT, BOOL, "1"}}, {"IQCustomStopDistance", {PERSISTENT, INT, "0"}}, // meters, -2..2; negative = stop closer, positive = stop further back; independent of IQForceStops - {"BlindSpot", {PERSISTENT, BOOL, "0"}}, + {"IQBlindSpotAlerts", {PERSISTENT, BOOL, "0"}}, {"IQExpandedStatus", {PERSISTENT, BOOL, "0"}}, {"HomePanelWidget", {PERSISTENT, STRING, "changelog"}}, @@ -342,7 +340,7 @@ inline static std::unordered_map keys = { {"OsmStateNames", {PERSISTENT, JSON}}, {"OsmWayTest", {PERSISTENT, STRING}}, {"RoadName", {CLEAR_ON_ONROAD_TRANSITION, STRING}}, - {"RoadNameToggle", {PERSISTENT, BOOL, "0"}}, + {"IQRoadNameOverlay", {PERSISTENT, BOOL, "0"}}, {"IQSpeedAssistMode", {PERSISTENT, INT, "1"}}, {"IQSpeedAssistOffsetType", {PERSISTENT, INT, "0"}}, {"IQSpeedAssistPolicy", {PERSISTENT, INT, "3"}}, diff --git a/iqdbc_repo/iqdbc/car/subaru/carcontroller.py b/iqdbc_repo/iqdbc/car/subaru/carcontroller.py index 18ba9e5..3a1cab6 100644 --- a/iqdbc_repo/iqdbc/car/subaru/carcontroller.py +++ b/iqdbc_repo/iqdbc/car/subaru/carcontroller.py @@ -6,7 +6,7 @@ from iqdbc.car.interfaces import CarControllerBase from iqdbc.car.subaru import subarucan from iqdbc.car.subaru.values import DBC, GLOBAL_ES_ADDR, CanBus, CarControllerParams, SubaruFlags -from iqdbc.lvbs.car.subaru.stop_and_go import IQStopAndGoController +from iqdbc.lvbs.car.subaru.creep_assist import IQStopAndGoController # FIXME: These limits aren't exact. The real limit is more than likely over a larger time period and # involves the total steering angle change rather than rate, but these limits work well for now @@ -139,7 +139,7 @@ class CarController(CarControllerBase, IQStopAndGoController): if self.frame % 2 == 0: can_sends.append(subarucan.create_es_static_2(self.packer)) - can_sends.extend(IQStopAndGoController.create_stop_and_go(self, self.packer, CC, CS, self.frame)) + can_sends.extend(IQStopAndGoController.create_creep_assist(self, self.packer, CC, CS, self.frame)) new_actuators = actuators.as_builder() new_actuators.torque = self.apply_torque_last / self.p.STEER_MAX diff --git a/iqdbc_repo/iqdbc/car/subaru/carstate.py b/iqdbc_repo/iqdbc/car/subaru/carstate.py index 5fbfc87..5276c4d 100644 --- a/iqdbc_repo/iqdbc/car/subaru/carstate.py +++ b/iqdbc_repo/iqdbc/car/subaru/carstate.py @@ -7,7 +7,7 @@ from iqdbc.car.subaru.values import DBC, CanBus, SubaruFlags from iqdbc.car import CanSignalRateCalculator from iqdbc.lvbs.car.subaru.aol import AolCarState -from iqdbc.lvbs.car.subaru.stop_and_go import IQStopAndGoState +from iqdbc.lvbs.car.subaru.creep_assist import IQStopAndGoState class CarState(CarStateBase, AolCarState, IQStopAndGoState): diff --git a/iqdbc_repo/iqdbc/car/tesla/carcontroller.py b/iqdbc_repo/iqdbc/car/tesla/carcontroller.py index 860938c..beb4425 100644 --- a/iqdbc_repo/iqdbc/car/tesla/carcontroller.py +++ b/iqdbc_repo/iqdbc/car/tesla/carcontroller.py @@ -7,7 +7,7 @@ from iqdbc.car.tesla.teslacan import TeslaCAN from iqdbc.car.tesla.values import CarControllerParams from iqdbc.car.vehicle_model import VehicleModel from openpilot.iqpilot.selfdrive.car.enhanced_stock_longitudinal_control import get_set_speed_kph_from_params -from iqdbc.lvbs.car.tesla.coop_steering import CoopSteeringCarController +from iqdbc.lvbs.car.tesla.torque_blend import TorqueBlendController def get_safety_CP(): @@ -20,7 +20,7 @@ def get_safety_CP(): class CarController(CarControllerBase): def __init__(self, dbc_names, CP, CP_IQ): CarControllerBase.__init__(self, dbc_names, CP, CP_IQ) - self.coop_steer = CoopSteeringCarController() + self.coop_steer = TorqueBlendController() self.apply_angle_last = 0 self.packer = CANPacker(dbc_names[Bus.party]) self.tesla_can = TeslaCAN(CP, self.packer) @@ -66,7 +66,7 @@ class CarController(CarControllerBase): # TODO: HUD control new_actuators = actuators.as_builder() new_actuators.steeringAngleDeg = self.apply_angle_last - new_actuators.accel = self.coop_steer.coop_apply_angle_last_sat # debug + new_actuators.accel = self.coop_steer.blend_apply_angle_last_sat # debug new_actuators.curvature = float(self.coop_steer.debug_angle_desired_limited) # debug new_actuators.torque = float(self.coop_steer.override_angle_accu) # debug diff --git a/iqdbc_repo/iqdbc/lvbs/car/platform_list.py b/iqdbc_repo/iqdbc/lvbs/car/car_catalog.py similarity index 92% rename from iqdbc_repo/iqdbc/lvbs/car/platform_list.py rename to iqdbc_repo/iqdbc/lvbs/car/car_catalog.py index 63c215c..b3eee24 100644 --- a/iqdbc_repo/iqdbc/lvbs/car/platform_list.py +++ b/iqdbc_repo/iqdbc/lvbs/car/car_catalog.py @@ -10,7 +10,7 @@ from iqdbc.car.values import PLATFORMS CAR_LIST_JSON_OUT = os.path.join(BASEDIR, "../", "iqpilot", "car", "car_list.json") -def get_car_list() -> dict[str, dict[str, list[str] | str]]: +def build_car_catalog() -> dict[str, dict[str, list[str] | str]]: collected_footnote = get_all_footnotes() sorted_list: dict[str, dict[str, list[str] | str]] = collect_car_docs(PLATFORMS, collected_footnote) return sorted_list @@ -62,8 +62,8 @@ def collect_car_docs(platforms, footnotes) -> dict[str, dict[str, list[str] | st if __name__ == "__main__": - platform_list = get_car_list() + catalog = build_car_catalog() with open(CAR_LIST_JSON_OUT, "w") as json_file: - json.dump(platform_list, json_file, indent=2, ensure_ascii=False) + json.dump(catalog, json_file, indent=2, ensure_ascii=False) print(f"Generated and written to {CAR_LIST_JSON_OUT}") diff --git a/iqdbc_repo/iqdbc/lvbs/car/interfaces.py b/iqdbc_repo/iqdbc/lvbs/car/interfaces.py index 5737906..893d72e 100644 --- a/iqdbc_repo/iqdbc/lvbs/car/interfaces.py +++ b/iqdbc_repo/iqdbc/lvbs/car/interfaces.py @@ -79,14 +79,14 @@ def apply_iq_car_config(CI, CP: structs.CarParams, CP_IQ: structs.IQCarParams, params_dict = {k: v for param in params_list for k, v in param.items()} - _initialize_custom_longitudinal_tuning(CI, CP, CP_IQ, params_dict) - _initialize_coop_steering(CP, CP_IQ, params_dict) + _apply_long_tuning(CI, CP, CP_IQ, params_dict) + _apply_torque_blend(CP, CP_IQ, params_dict) _initialize_radar_tracks(CP, CP_IQ, can_recv, can_send) - _initialize_stop_and_go(CP, CP_IQ, params_dict) - _initialize_toyota(CP, CP_IQ, params_dict) + _apply_creep_assist(CP, CP_IQ, params_dict) + _apply_toyota_options(CP, CP_IQ, params_dict) -def _initialize_custom_longitudinal_tuning(CI, CP: structs.CarParams, CP_IQ: structs.IQCarParams, +def _apply_long_tuning(CI, CP: structs.CarParams, CP_IQ: structs.IQCarParams, params_dict: dict[str, str]) -> None: # Hyundai Custom Longitudinal Tuning @@ -100,11 +100,11 @@ def _initialize_custom_longitudinal_tuning(CI, CP: structs.CarParams, CP_IQ: str _ = CI.get_longitudinal_tuning_iq(CP, CP_IQ) -def _initialize_coop_steering(CP: structs.CarParams, CP_IQ: structs.IQCarParams, +def _apply_torque_blend(CP: structs.CarParams, CP_IQ: structs.IQCarParams, params_dict: dict[str, str]) -> None: if CP.brand == 'tesla': - coop_steering = int(params_dict.get("TeslaCoopSteering", 0)) == 1 - if coop_steering: + torque_blend = int(params_dict.get("IQTeslaTorqueBlend", 0)) == 1 + if torque_blend: CP_IQ.flags |= TeslaFlagsIQ.COOP_STEERING.value @@ -116,10 +116,10 @@ def _initialize_radar_tracks(CP: structs.CarParams, CP_IQ: structs.IQCarParams, CP.radarUnavailable = not tracks_enabled -def _initialize_stop_and_go(CP: structs.CarParams, CP_IQ: structs.IQCarParams, params_dict: dict[str, str]) -> None: +def _apply_creep_assist(CP: structs.CarParams, CP_IQ: structs.IQCarParams, params_dict: dict[str, str]) -> None: if CP.brand == 'subaru' and not CP.flags & (SubaruFlags.GLOBAL_GEN2 | SubaruFlags.HYBRID): - stop_and_go = int(params_dict.get("SubaruStopAndGo", 0)) == 1 - stop_and_go_manual_parking_brake = int(params_dict.get("SubaruStopAndGoManualParkingBrake", 0)) == 1 + stop_and_go = int(params_dict.get("IQSubaruCreepAssist", 0)) == 1 + stop_and_go_manual_parking_brake = int(params_dict.get("IQSubaruCreepAssistManualBrake", 0)) == 1 if stop_and_go: CP_IQ.flags |= SubaruFlagsIQ.STOP_AND_GO.value @@ -129,9 +129,9 @@ def _initialize_stop_and_go(CP: structs.CarParams, CP_IQ: structs.IQCarParams, p CP_IQ.safetyParam |= SubaruSafetyFlagsIQ.STOP_AND_GO -def _initialize_toyota(CP: structs.CarParams, CP_IQ: structs.IQCarParams, params_dict: dict[str, str]) -> None: +def _apply_toyota_options(CP: structs.CarParams, CP_IQ: structs.IQCarParams, params_dict: dict[str, str]) -> None: if CP.brand == 'toyota': - toyota_stock_long = int(params_dict.get("ToyotaEnforceStockLongitudinal", 0)) == 1 + toyota_stock_long = int(params_dict.get("IQToyotaFactoryLong", 0)) == 1 toyota_sng_hack = int(params_dict.get("ToyotaSnGHack", 0)) == 1 if toyota_stock_long: diff --git a/iqdbc_repo/iqdbc/lvbs/car/subaru/stop_and_go.py b/iqdbc_repo/iqdbc/lvbs/car/subaru/creep_assist.py similarity index 97% rename from iqdbc_repo/iqdbc/lvbs/car/subaru/stop_and_go.py rename to iqdbc_repo/iqdbc/lvbs/car/subaru/creep_assist.py index c55b1d2..8b7b735 100644 --- a/iqdbc_repo/iqdbc/lvbs/car/subaru/stop_and_go.py +++ b/iqdbc_repo/iqdbc/lvbs/car/subaru/creep_assist.py @@ -88,7 +88,7 @@ class IQStopAndGoController: return send_resume - def create_stop_and_go(self, packer, CC: structs.CarControl, CS: CarStateBase, frame: int) -> list[CanData]: + def create_creep_assist(self, packer, CC: structs.CarControl, CS: CarStateBase, frame: int) -> list[CanData]: can_sends = [] if not self.enabled: diff --git a/iqdbc_repo/iqdbc/lvbs/car/tesla/coop_steering.py b/iqdbc_repo/iqdbc/lvbs/car/tesla/torque_blend.py similarity index 93% rename from iqdbc_repo/iqdbc/lvbs/car/tesla/coop_steering.py rename to iqdbc_repo/iqdbc/lvbs/car/tesla/torque_blend.py index e67d443..c8c4092 100644 --- a/iqdbc_repo/iqdbc/lvbs/car/tesla/coop_steering.py +++ b/iqdbc_repo/iqdbc/lvbs/car/tesla/torque_blend.py @@ -15,7 +15,7 @@ from iqdbc.lvbs.car.tesla.values import TeslaFlagsIQ DT_LAT_CTRL = DT_CTRL * CarControllerParams.STEER_STEP -class CoopSteeringCarControllerParams(CarControllerParams): +class TorqueBlendParams(CarControllerParams): ANGLE_LIMITS = replace(CarControllerParams.ANGLE_LIMITS, MAX_ANGLE_RATE=5) STEERING_DEG_PHASE_LEAD_COEFF = 8.0 @@ -28,7 +28,7 @@ STEER_OVERRIDE_LAT_ACCEL_GAIN_LIMIT = 10 # deg/Nm stability and smoothness for a # angle ramping STEER_OVERRIDE_MAX_LAT_JERK = 2.0 # m/s^3 - determines angle ramping rate - speed dependent -STEER_OVERRIDE_MAX_LAT_JERK_CENTERING = CoopSteeringCarControllerParams.ANGLE_LIMITS.MAX_LATERAL_JERK # m/s^3 - for low speed angle ramp down +STEER_OVERRIDE_MAX_LAT_JERK_CENTERING = TorqueBlendParams.ANGLE_LIMITS.MAX_LATERAL_JERK # m/s^3 - for low speed angle ramp down # stability and smoothness for angle ramp control - at very low speeds this takes precedence over jerk settings STEER_OVERRIDE_LAT_JERK_GAIN_LIMIT = 100 # deg/s/Nm - should be less than CarControllerParams.ANGLE_LIMITS.MAX_ANGLE_RATE / DT_CTRL / STEER_OVERRIDE_TORQUE_RANGE STEER_OVERRIDE_TORQUE_RANGE = STEER_OVERRIDE_MAX_TORQUE - STEER_OVERRIDE_MIN_TORQUE @@ -42,7 +42,7 @@ STEER_DESIRED_LIMITER_OVERRIDE_ACTIVE_COUNTER = 0.7 # second STEER_RESUME_RATE_LIMIT_RAMP_RATE = 500 # deg/s^2 - controls rate of rise of angle rate limit, not angle directly -CoopSteeringDataIQ = namedtuple("CoopSteeringDataIQ", +TorqueBlendDataIQ = namedtuple("TorqueBlendDataIQ", ["steeringAngleDeg", "lat_active", "control_type"]) def get_steer_from_lat_accel(lat_accel, v_ego: float, VM: VehicleModel): @@ -84,7 +84,7 @@ def calc_override_angle_delta_limited(torque: float, vEgo: float, VM: VehicleMod """ # prevents windup in carcontroller rate limiter - lat_jerk = min(lat_jerk, CoopSteeringCarControllerParams.ANGLE_LIMITS.MAX_LATERAL_JERK) + lat_jerk = min(lat_jerk, TorqueBlendParams.ANGLE_LIMITS.MAX_LATERAL_JERK) # lateral accel is linear in respect to angle so it's fine to interpolate it with torque torque_to_angle = get_steer_from_lat_accel(lat_jerk, vEgo, VM) / STEER_OVERRIDE_TORQUE_RANGE @@ -93,7 +93,7 @@ def calc_override_angle_delta_limited(torque: float, vEgo: float, VM: VehicleMod override_angle_rate = torque * min(torque_to_angle, gain_limit) # prevent windup in angle rate limiter - return apply_bounds(override_angle_rate * DT_LAT_CTRL, CoopSteeringCarControllerParams.ANGLE_LIMITS.MAX_ANGLE_RATE) + return apply_bounds(override_angle_rate * DT_LAT_CTRL, TorqueBlendParams.ANGLE_LIMITS.MAX_ANGLE_RATE) class SteerRateLimiter: @@ -160,10 +160,10 @@ class SteerAccelLimiter: return angle_out -class CoopSteeringCarController: +class TorqueBlendController: def __init__(self): self.coop_apply_angle_last = 0 - self.coop_apply_angle_last_sat = 0 + self.blend_apply_angle_last_sat = 0 self.override_angle_accu = 0 self.override_active_counter = 0 # Counter for how many cycles torque is below threshold self.resume_rate_limiter_delta = SteerRateLimiter() @@ -201,7 +201,7 @@ class CoopSteeringCarController: return 0 # unwind accumulator toward zero if the previous loop saturated (apply_steer_angle_limits_vm) - unwind = (self.coop_apply_angle_last - self.coop_apply_angle_last_sat) * unwind_weight + unwind = (self.coop_apply_angle_last - self.blend_apply_angle_last_sat) * unwind_weight if self.override_angle_accu * unwind > 0: unwind = apply_bounds(unwind, abs(self.override_angle_accu)) self.override_angle_accu -= unwind @@ -289,7 +289,7 @@ class CoopSteeringCarController: apply_angle_lim = self.resume_rate_limiter.update(apply_angle, angle_rate_delta_lim) return apply_angle_lim - def update(self, apply_angle, lat_active, CP_IQ: structs.IQCarParams, CS: structs.CarState, VM: VehicleModel) -> CoopSteeringDataIQ: + def update(self, apply_angle, lat_active, CP_IQ: structs.IQCarParams, CS: structs.CarState, VM: VehicleModel) -> TorqueBlendDataIQ: # estimate real steering angle by adding rate to the tesla filtered angle steeringAngleDegPhaseLead = CS.out.steeringAngleDeg + CS.out.steeringRateDeg / STEERING_DEG_PHASE_LEAD_COEFF @@ -306,7 +306,7 @@ class CoopSteeringCarController: # final rate limit - matching panda safety self.coop_apply_angle_last = apply_angle - self.coop_apply_angle_last_sat = apply_steer_angle_limits_vm(apply_angle, self.coop_apply_angle_last_sat, CS.out.vEgoRaw, - CS.out.steeringAngleDeg, lat_active, CoopSteeringCarControllerParams, VM) + self.blend_apply_angle_last_sat = apply_steer_angle_limits_vm(apply_angle, self.blend_apply_angle_last_sat, CS.out.vEgoRaw, + CS.out.steeringAngleDeg, lat_active, TorqueBlendParams, VM) - return CoopSteeringDataIQ(self.coop_apply_angle_last_sat, lat_active, 1) # 1 = angle control + return TorqueBlendDataIQ(self.blend_apply_angle_last_sat, lat_active, 1) # 1 = angle control diff --git a/iqdbc_repo/iqdbc/lvbs/car/tests/test_car_catalog.py b/iqdbc_repo/iqdbc/lvbs/car/tests/test_car_catalog.py new file mode 100644 index 0000000..40e4482 --- /dev/null +++ b/iqdbc_repo/iqdbc/lvbs/car/tests/test_car_catalog.py @@ -0,0 +1,12 @@ +import json + +from iqdbc.lvbs.car.car_catalog import build_car_catalog, CAR_LIST_JSON_OUT + + +class TestCarList: + def test_generator(self): + generated_car_list = json.dumps(build_car_catalog(), indent=2, ensure_ascii=False) + with open(CAR_LIST_JSON_OUT) as f: + current_car_list = f.read() + + assert generated_car_list == current_car_list, "Run iqdbc/lvbs/car/car_catalog.py to update the car list" diff --git a/iqdbc_repo/iqdbc/lvbs/car/tests/test_car_list.py b/iqdbc_repo/iqdbc/lvbs/car/tests/test_car_list.py deleted file mode 100644 index 19c4952..0000000 --- a/iqdbc_repo/iqdbc/lvbs/car/tests/test_car_list.py +++ /dev/null @@ -1,12 +0,0 @@ -import json - -from iqdbc.lvbs.car.platform_list import get_car_list, CAR_LIST_JSON_OUT - - -class TestCarList: - def test_generator(self): - generated_car_list = json.dumps(get_car_list(), indent=2, ensure_ascii=False) - with open(CAR_LIST_JSON_OUT) as f: - current_car_list = f.read() - - assert generated_car_list == current_car_list, "Run iqdbc/iqpilot/car/platform_list.py to update the car list" diff --git a/iqpilot/common/atlas_alerts.py b/iqpilot/common/atlas_alerts.py index 8060fda..5339155 100644 --- a/iqpilot/common/atlas_alerts.py +++ b/iqpilot/common/atlas_alerts.py @@ -214,10 +214,9 @@ class NoEntryCard(AlertCard): def __init__(self, alert_text_2: str, alert_text_1: str = "openpilot Unavailable", - visual_alert: car.CarControl.HUDControl.VisualAlert = VisualAlert.none, - priority: Tier = Tier.LOW): + visual_alert: car.CarControl.HUDControl.VisualAlert = VisualAlert.none): primary, secondary, size = _mici_reframe(alert_text_1, alert_text_2) - super().__init__(primary, secondary, AlertStatus.normal, size, priority, visual_alert, AudibleAlert.refuse, 3.0) + super().__init__(primary, secondary, AlertStatus.normal, size, Tier.LOW, visual_alert, AudibleAlert.refuse, 3.0) class GentleDisableCard(AlertCard): diff --git a/iqpilot/selfdrive/car/interfaces.py b/iqpilot/selfdrive/car/interfaces.py index bff71f9..7243529 100644 --- a/iqpilot/selfdrive/car/interfaces.py +++ b/iqpilot/selfdrive/car/interfaces.py @@ -12,11 +12,11 @@ _ANGLE = _dbc.CarParams.SteerControlType.angle # Port tunables surfaced to the fingerprint step, flat so the read is one pass. _TUNABLES = ( - "HyundaiLongitudinalTuning", - "SubaruStopAndGo", - "SubaruStopAndGoManualParkingBrake", - "TeslaCoopSteering", - "ToyotaEnforceStockLongitudinal", + "IQHyundaiLongTune", + "IQSubaruCreepAssist", + "IQSubaruCreepAssistManualBrake", + "IQTeslaTorqueBlend", + "IQToyotaFactoryLong", "ToyotaSnGHack", ) diff --git a/iqpilot/selfdrive/car/vehicle_catalog.py b/iqpilot/selfdrive/car/vehicle_catalog.py index 42d6e5d..dedd794 100644 --- a/iqpilot/selfdrive/car/vehicle_catalog.py +++ b/iqpilot/selfdrive/car/vehicle_catalog.py @@ -81,5 +81,5 @@ def _write(vehicles: dict[str, dict], basedir: str = BASEDIR) -> str: if __name__ == "__main__": - from iqdbc.lvbs.car.platform_list import get_car_list - print("wrote", _write(get_car_list())) + from iqdbc.lvbs.car.car_catalog import build_car_catalog + print("wrote", _write(build_car_catalog())) diff --git a/iqpilot/selfdrive/iqmodeld/models/manager.py b/iqpilot/selfdrive/iqmodeld/models/manager.py index 623eed1..1596d2e 100644 --- a/iqpilot/selfdrive/iqmodeld/models/manager.py +++ b/iqpilot/selfdrive/iqmodeld/models/manager.py @@ -43,6 +43,7 @@ from openpilot.iqpilot.selfdrive.iqmodeld.models.helpers import ( bundle_files_ready, get_active_bundle, get_runtime_bundle_upgrade, + is_default_bundle, persist_active_bundle, ) @@ -56,6 +57,7 @@ class IQModelManager(_BaseIQModelManager): def __init__(self): super().__init__() self._validated_active_key: tuple[tuple[str, str], ...] | None = None + self._manifest_refresh_key: tuple[tuple[str, str], ...] | None = None @staticmethod def _bundle_index(bundle) -> int | None: @@ -190,6 +192,58 @@ class IQModelManager(_BaseIQModelManager): if bundle_index is not None and self._download_index() is None: self.params.put(_DOWNLOAD_INDEX_KEY, bundle_index) + def _find_manifest_counterpart(self, target): + # never match by index: indexes shift between manifest generations, and a + # positional match could redownload a different model than the user selected + for attr in ("ref", "internalName", "displayName"): + value = getattr(target, attr, None) + if not value: + continue + for bundle in self.available_models: + if getattr(bundle, attr, None) == value: + return bundle + return None + + def _queue_active_manifest_refresh(self) -> None: + active = self.active_bundle + if active is None or is_default_bundle(active): + return + if self._download_index() is not None: + return + + counterpart = self._find_manifest_counterpart(active) + if counterpart is None: + return + counterpart_index = self._bundle_index(counterpart) + if counterpart_index is None: + return + + active_files = dict(self._bundle_files(active)) + stale = False + for filename, sha in self._bundle_files(counterpart): + if not sha: + continue + active_sha = active_files.get(filename) + # an empty recorded hash can't prove a mismatch, so it never triggers a redownload + if active_sha is None or (active_sha and active_sha.lower() != sha.lower()): + stale = True + break + if not stale: + self._manifest_refresh_key = None + return + + # the manifest may be an expired offline cache, so keep the active bundle and its + # files in place: the download flow replaces artifacts atomically and only persists + # the counterpart as active once everything landed. One attempt per bundle per run + # so a dead network doesn't turn the 1Hz loop into a download-retry storm. + key = self._bundle_validation_key(active) + if key == self._manifest_refresh_key: + return + self._manifest_refresh_key = key + + cloudlog.warning(f"Active model {_display_bundle_name(active)} artifacts are stale vs current manifest; queueing redownload") + self.params.put(_DOWNLOAD_INDEX_KEY, counterpart_index) + async def _download_file(self, url: str, path: str, model) -> None: temp_path = f"{path}.download" self._download_start_times[model.fileName] = time.monotonic() @@ -302,6 +356,7 @@ class IQModelManager(_BaseIQModelManager): self.active_bundle = get_active_bundle(self.params) self._queue_active_redownload_if_invalid() self._queue_tinygrad_upgrade() + self._queue_active_manifest_refresh() if (index_to_download := self._download_index()) is not None: if model_to_download := next((model for model in self.available_models if model.index == index_to_download), None): diff --git a/iqpilot/selfdrive/iqmodeld/tests/test_manager_manifest_refresh.py b/iqpilot/selfdrive/iqmodeld/tests/test_manager_manifest_refresh.py new file mode 100644 index 0000000..19e20af --- /dev/null +++ b/iqpilot/selfdrive/iqmodeld/tests/test_manager_manifest_refresh.py @@ -0,0 +1,150 @@ +""" +Copyright (c) IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos +""" +from dataclasses import dataclass, field + +from openpilot.iqpilot.selfdrive.iqmodeld.models.manager import IQModelManager, _DOWNLOAD_INDEX_KEY + + +@dataclass +class _DownloadUri: + sha256: str = "" + uri: str = "" + + +@dataclass +class _Artifact: + fileName: str = "" + downloadUri: _DownloadUri = field(default_factory=_DownloadUri) + + +@dataclass +class _Model: + artifact: _Artifact = field(default_factory=_Artifact) + metadata: _Artifact | None = None + + +@dataclass +class _Bundle: + index: int = 0 + ref: str = "" + internalName: str = "" + displayName: str = "" + models: list = field(default_factory=list) + + +class _FakeParams: + def __init__(self): + self.store = {} + + def get(self, key): + return self.store.get(key) + + def put(self, key, value): + self.store[key] = value + + def remove(self, key): + self.store.pop(key, None) + + +def _bundle(index, name, sha, filename="driving_vision_test_tinygrad.pkl"): + return _Bundle( + index=index, + ref=f"ref-{name}", + internalName=name, + displayName=f"{name} display", + models=[_Model(artifact=_Artifact(fileName=filename, downloadUri=_DownloadUri(sha256=sha)))], + ) + + +def _manager(active, available): + mgr = IQModelManager.__new__(IQModelManager) + mgr.params = _FakeParams() + mgr.active_bundle = active + mgr.available_models = available + mgr._validated_active_key = None + mgr._manifest_refresh_key = None + return mgr + + +def test_stale_active_bundle_queues_redownload_at_current_index(): + active = _bundle(55, "WMIV12", "a" * 64) + counterpart = _bundle(12, "WMIV12", "b" * 64) + mgr = _manager(active, [counterpart]) + + mgr._queue_active_manifest_refresh() + + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) == 12 + assert mgr.active_bundle is active + + +def test_matching_shas_do_not_queue(): + active = _bundle(55, "WMIV12", "a" * 64) + counterpart = _bundle(12, "WMIV12", "A" * 64) + mgr = _manager(active, [counterpart]) + + mgr._queue_active_manifest_refresh() + + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) is None + + +def test_retired_bundle_is_left_alone(): + active = _bundle(55, "WMIV12", "a" * 64) + mgr = _manager(active, [_bundle(12, "OtherModel", "b" * 64)]) + + mgr._queue_active_manifest_refresh() + + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) is None + assert mgr.active_bundle is active + + +def test_default_bundle_is_never_refreshed(): + active = _bundle(0, "Default", "a" * 64) + active.ref = "default" + mgr = _manager(active, [_bundle(0, "Default", "b" * 64)]) + + mgr._queue_active_manifest_refresh() + + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) is None + + +def test_pending_download_blocks_refresh(): + active = _bundle(55, "WMIV12", "a" * 64) + mgr = _manager(active, [_bundle(12, "WMIV12", "b" * 64)]) + mgr.params.put(_DOWNLOAD_INDEX_KEY, 3) + + mgr._queue_active_manifest_refresh() + + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) == 3 + + +def test_empty_manifest_hash_never_triggers(): + active = _bundle(55, "WMIV12", "a" * 64) + mgr = _manager(active, [_bundle(12, "WMIV12", "")]) + + mgr._queue_active_manifest_refresh() + + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) is None + + +def test_refresh_queued_once_per_run(): + active = _bundle(55, "WMIV12", "a" * 64) + mgr = _manager(active, [_bundle(12, "WMIV12", "b" * 64)]) + + mgr._queue_active_manifest_refresh() + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) == 12 + + mgr.params.remove(_DOWNLOAD_INDEX_KEY) + mgr._queue_active_manifest_refresh() + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) is None + + +def test_counterpart_matched_by_name_not_index(): + active = _bundle(55, "WMIV12", "a" * 64) + imposter = _bundle(55, "OtherModel", "c" * 64) + counterpart = _bundle(12, "WMIV12", "b" * 64) + mgr = _manager(active, [imposter, counterpart]) + + mgr._queue_active_manifest_refresh() + + assert mgr.params.get(_DOWNLOAD_INDEX_KEY) == 12 diff --git a/iqpilot/selfdrive/selfdrived/events.py b/iqpilot/selfdrive/selfdrived/events.py index 76d81ae..674e551 100644 --- a/iqpilot/selfdrive/selfdrived/events.py +++ b/iqpilot/selfdrive/selfdrived/events.py @@ -337,6 +337,13 @@ _NOTICE_EVENTS: EVENTS_IQ_TYPE = { Priority.MID, VisualAlert.none, AudibleAlert.prompt, 3.), }, + # outranks the generic processNotRunning alert so the driver sees why engagement is blocked + EventNameIQ.modelUpdating: { + ET.NO_ENTRY: NoEntryAlert("Update finishes while parked with internet", + alert_text_1="Driving Model Updating", + priority=Priority.MID), + }, + } EVENTS_IQ: EVENTS_IQ_TYPE = {**_GUIDANCE_EVENTS, **_ENGAGE_EVENTS, **_CABIN_BLOCK_EVENTS, **_NOTICE_EVENTS} diff --git a/iqpilot/ui/layouts/settings/trips.py b/iqpilot/ui/layouts/settings/drive_history.py similarity index 100% rename from iqpilot/ui/layouts/settings/trips.py rename to iqpilot/ui/layouts/settings/drive_history.py diff --git a/iqpilot/ui/layouts/settings/iq_panels.py b/iqpilot/ui/layouts/settings/iq_panels.py index 0f023af..529efd8 100644 --- a/iqpilot/ui/layouts/settings/iq_panels.py +++ b/iqpilot/ui/layouts/settings/iq_panels.py @@ -194,7 +194,7 @@ CHEVRON_INFO_DESCRIPTION = { # param key -> (title fn, description fn) _HUD_TOGGLES = { - "BlindSpot": ( + "IQBlindSpotAlerts": ( lambda: tr("Blind Spot Alerts"), lambda: tr("Flashes a side warning whenever the car reports something sitting in your blind spot (BSM-equipped cars only)."), ), @@ -202,20 +202,20 @@ _HUD_TOGGLES = { lambda: tr("Expanded Status Bar"), lambda: tr("Bring back the classic UI's wide offroad status strip: temperature, vehicle, and Konn3kt state at a glance."), ), - "TorqueBar": ( + "IQSteerEffortArc": ( lambda: tr("Steering Effort Arc"), lambda: tr("Trace an arc over the road view showing how much steering IQ.Pilot is applying while lateral control runs."), ), - "RoadNameToggle": ( + "IQRoadNameOverlay": ( lambda: tr("Road Name Overlay"), lambda: tr("Show the current road's name over the driving view." "
Requires offline map data for your region to be installed."), ), - "ShowTurnSignals": ( + "IQBlinkerIndicators": ( lambda: tr("Blinker Indicators"), lambda: tr("Mirror the car's blinkers as arrows on the driving screen."), ), - "RocketFuel": ( + "IQAccelMeter": ( lambda: tr("Acceleration Meter"), lambda: tr("Draw a bar along the left edge tracking measured acceleration and braking — what the car is actually " "doing right now, not the planner's request."), @@ -243,7 +243,7 @@ class VisualsLayout(Widget): title=lambda: tr("Lead Vehicle Readouts"), description="", buttons=[lambda: tr("Off"), lambda: tr("Distance"), lambda: tr("Speed"), lambda: tr("Time"), lambda: tr("All")], - param="ChevronInfo", + param="IQLeadReadouts", inline=False, ) self._dev_ui_info = toggle_item( @@ -270,12 +270,12 @@ class VisualsLayout(Widget): def _sync_chevron_row(self): if ui_state.has_longitudinal_control: self._chevron_info.set_description(tr(CHEVRON_INFO_DESCRIPTION["enabled"])) - self._chevron_info.action_item.set_selected_button(ui_state.params.get("ChevronInfo", return_default=True)) + self._chevron_info.action_item.set_selected_button(ui_state.params.get("IQLeadReadouts", return_default=True)) self._chevron_info.action_item.set_enabled(True) else: self._chevron_info.set_description(tr(CHEVRON_INFO_DESCRIPTION["disabled"])) self._chevron_info.action_item.set_enabled(False) - ui_state.params.put("ChevronInfo", 0) + ui_state.params.put("IQLeadReadouts", 0) def _update_state(self): super()._update_state() @@ -1388,7 +1388,7 @@ class IQDeviceLayout(DeviceLayout): DeviceLayout._initialize_items(self) # Using dual button with no right button for better alignment - self._always_offroad_btn = self._left_button(lambda: tr("Force Offroad Mode"), self._handle_always_offroad) + self._always_offroad_btn = self._left_button(lambda: tr("Keep Device Offroad"), self._handle_always_offroad) self._force_onroad_btn = self._left_button(lambda: tr("Force On-Road (10 min)"), self._handle_force_onroad) self._max_time_offroad = option_item( @@ -1592,7 +1592,7 @@ class IQDeviceLayout(DeviceLayout): force_onroad_active = force_onroad_until > now # Text & Color - offroad_mode_btn_text = tr("Exit Offroad Mode") if always_offroad else tr("Force Offroad Mode") + offroad_mode_btn_text = tr("Exit Offroad Mode") if always_offroad else tr("Keep Device Offroad") offroad_mode_btn_style = ButtonStyle.PRIMARY if always_offroad else ButtonStyle.DANGER self._always_offroad_btn.action_item.left_button.set_text(offroad_mode_btn_text) self._always_offroad_btn.action_item.left_button.set_button_style(offroad_mode_btn_style) @@ -1957,12 +1957,12 @@ class ModelsLayout(Widget): return folders_list def _handle_current_model_clicked(self): - favs = ui_state.params.get("ModelManager_Favs") + favs = ui_state.params.get("IQModelFavorites") favorites = set(favs.split(';')) if favs else set() folders_list = self._get_folders(favorites) active_ref = self.model_manager.activeBundle.ref if self._has_active_bundle_param() and self.model_manager.activeBundle else "Default" - self.model_dialog = PickerDialog(tr("Choose a Model"), folders_list, active_ref, "ModelManager_Favs", + self.model_dialog = PickerDialog(tr("Choose a Model"), folders_list, active_ref, "IQModelFavorites", get_folders_fn=self._get_folders, on_exit=self._on_model_selected) gui_app.set_modal_overlay(self.model_dialog, callback=self._on_model_selected) @@ -2191,8 +2191,8 @@ class HyundaiSettings(BrandPanel): self.longitudinal_tuning_item = multiple_button_item( tr("Longitudinal Tune Profile"), "", [tr("Off"), tr("Dynamic"), tr("Predictive")], - button_width=300, param="HyundaiLongitudinalTuning", inline=False, - callback=lambda index: ui_state.params.put("HyundaiLongitudinalTuning", index)) + button_width=300, param="IQHyundaiLongTune", inline=False, + callback=lambda index: ui_state.params.put("IQHyundaiLongTune", index)) self.items = [self.longitudinal_tuning_item] def _alpha_long_supported(self) -> bool: @@ -2204,7 +2204,7 @@ class HyundaiSettings(BrandPanel): def update_settings(self): self.alpha_long_available = self._alpha_long_supported() - selected = int(ui_state.params.get("HyundaiLongitudinalTuning") or "0") + selected = int(ui_state.params.get("IQHyundaiLongTune") or "0") if not ui_state.is_offroad(): desc, usable = tr("Unavailable while the car is onroad."), False @@ -2231,11 +2231,11 @@ class SubaruSettings(BrandPanel): def __init__(self): super().__init__() self._supported = False - self.stop_and_go_toggle = toggle_item(tr("Creep from Standstill (Beta)"), "", param="SubaruStopAndGo", + self.stop_and_go_toggle = toggle_item(tr("Creep from Standstill (Beta)"), "", param="IQSubaruCreepAssist", callback=lambda _: self.update_settings()) self.stop_and_go_manual_parking_brake_toggle = toggle_item( tr("Creep from Standstill — Manual Handbrake (Beta)"), "", - param="SubaruStopAndGoManualParkingBrake", callback=lambda _: self.update_settings()) + param="IQSubaruCreepAssistManualBrake", callback=lambda _: self.update_settings()) self.items = [self.stop_and_go_toggle, self.stop_and_go_manual_parking_brake_toggle] def _platform_flags(self) -> int: @@ -2286,8 +2286,8 @@ def _speed_text(kmh: int) -> str: class TeslaSettings(BrandPanel): def __init__(self): super().__init__() - self.coop_steering_toggle = toggle_item(tr("VTB (Virtual Torque Blending)"), "", param="TeslaCoopSteering") - self.items = [self.coop_steering_toggle] + self.torque_blend_toggle = toggle_item(tr("VTB (Virtual Torque Blending)"), "", param="IQTeslaTorqueBlend") + self.items = [self.torque_blend_toggle] def update_settings(self): caution = tr("Warning: steering may oscillate in turns below {}; turn this off if you feel it.").format( @@ -2300,8 +2300,8 @@ class TeslaSettings(BrandPanel): blocker = tr("Flip on Always Offroad from the Device panel, or power the car down, to change this.") body = f"{blocker}

{body}" - self.coop_steering_toggle.set_description(body) - self.coop_steering_toggle.action_item.set_enabled(ui_state.is_offroad()) + self.torque_blend_toggle.set_description(body) + self.torque_blend_toggle.action_item.set_enabled(ui_state.is_offroad()) # ===== vehicle_brands_toyota ===== @@ -2312,7 +2312,7 @@ class ToyotaSettings(BrandPanel): self.enforce_stock_longitudinal = toggle_item( lambda: tr("Keep Factory Gas and Brake"), description=lambda: tr("Keeps gas and brakes with the factory Toyota system; IQ.Pilot steers only."), - initial_state=ui_state.params.get_bool("ToyotaEnforceStockLongitudinal"), + initial_state=ui_state.params.get_bool("IQToyotaFactoryLong"), callback=self._on_toggled, enabled=lambda: not ui_state.engaged, ) @@ -2320,7 +2320,7 @@ class ToyotaSettings(BrandPanel): @staticmethod def _apply(enabled: bool): - ui_state.params.put_bool("ToyotaEnforceStockLongitudinal", enabled) + ui_state.params.put_bool("IQToyotaFactoryLong", enabled) if enabled and ui_state.params.get_bool("AlphaLongitudinalEnabled"): ui_state.params.put_bool("AlphaLongitudinalEnabled", False) ui_state.params.put_bool("OnroadCycleRequested", True) diff --git a/iqpilot/ui/mici/onroad/road_name.py b/iqpilot/ui/mici/onroad/road_label.py similarity index 100% rename from iqpilot/ui/mici/onroad/road_name.py rename to iqpilot/ui/mici/onroad/road_label.py diff --git a/iqpilot/ui/onroad/model_renderer.py b/iqpilot/ui/onroad/model_renderer.py deleted file mode 100644 index e5e57ac..0000000 --- a/iqpilot/ui/onroad/model_renderer.py +++ /dev/null @@ -1,10 +0,0 @@ -""" -Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos -""" -from openpilot.iqpilot.ui.onroad.hud_overlays import ChevronMetrics -from openpilot.iqpilot.ui.onroad.rainbow_path import RainbowPath - - -class IQModelRenderer: - def __init__(self): - self.rainbow_path = RainbowPath() diff --git a/iqpilot/ui/onroad/rainbow_path.py b/iqpilot/ui/onroad/rainbow_path.py deleted file mode 100644 index bd6bf6e..0000000 --- a/iqpilot/ui/onroad/rainbow_path.py +++ /dev/null @@ -1,41 +0,0 @@ -""" -Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos -""" -import colorsys -import time - -import pyray as rl -from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient - -# Scrolling spectrum along the driving path: a fixed set of stops from the -# bottom (1.0) to the top (0.0) of the path, each a full-saturation swatch whose -# hue advances with time and whose opacity thins toward the horizon. -_SEGMENTS = 8 -_SCROLL_DEG_PER_S = 50.0 -_SATURATION = 0.9 -_LIGHTNESS = 0.6 -_ALPHA_NEAR = 0.8 # opacity at the bottom of the path -_ALPHA_HORIZON_FRACTION = 0.3 # how much of that opacity is shed by the top - -# Stop offsets are constant, so resolve them once. -_STOP_OFFSETS = tuple(i / (_SEGMENTS - 1) for i in range(_SEGMENTS)) - - -def _swatch(hue_turns: float, alpha: float) -> rl.Color: - r, g, b = colorsys.hls_to_rgb(hue_turns, _LIGHTNESS, _SATURATION) - return rl.Color(int(r * 255), int(g * 255), int(b * 255), int(alpha * 255)) - - -def _spectrum_gradient() -> Gradient: - scroll_deg = (time.monotonic() * _SCROLL_DEG_PER_S) % 360.0 - colors = [] - for offset in _STOP_OFFSETS: - hue_deg = (scroll_deg + offset * 360.0) % 360.0 - alpha = _ALPHA_NEAR * (1.0 - offset * _ALPHA_HORIZON_FRACTION) - colors.append(_swatch(hue_deg / 360.0, alpha)) - return Gradient(start=(0.0, 1.0), end=(0.0, 0.0), colors=colors, stops=list(_STOP_OFFSETS)) - - -class RainbowPath: - def draw_rainbow_path(self, rect, path): - draw_polygon(rect, path.projected_points, gradient=_spectrum_gradient()) diff --git a/selfdrive/assets/sounds/pre_alert.wav b/selfdrive/assets/sounds/pre_alert.wav deleted file mode 100644 index f83b710..0000000 Binary files a/selfdrive/assets/sounds/pre_alert.wav and /dev/null differ diff --git a/selfdrive/assets/sounds/prompt_distracted.wav b/selfdrive/assets/sounds/prompt_distracted.wav index 6cad556..c3d4475 100644 Binary files a/selfdrive/assets/sounds/prompt_distracted.wav and b/selfdrive/assets/sounds/prompt_distracted.wav differ diff --git a/selfdrive/assets/sounds/warning_immediate.wav b/selfdrive/assets/sounds/warning_immediate.wav index 99b4b03..b1815a9 100644 Binary files a/selfdrive/assets/sounds/warning_immediate.wav and b/selfdrive/assets/sounds/warning_immediate.wav differ diff --git a/selfdrive/controls/controlsd.py b/selfdrive/controls/controlsd.py index 3def978..1bd7b31 100755 --- a/selfdrive/controls/controlsd.py +++ b/selfdrive/controls/controlsd.py @@ -260,7 +260,7 @@ class Controls(IQControlsLayer): hudControl.leadFollowTime = 1.45 hudControl.visualAlert = self.sm['selfdriveState'].alertHudVisual hudControl.audibleAlert = self.sm['selfdriveState'].alertSound - hudControl.driverUnresponsive = self.sm['driverMonitoringState'].noResponseForceDecel + hudControl.driverUnresponsive = self.sm['selfdriveState'].alertType.split('/', 1)[0] == 'driverUnresponsive' hudControl.rightLaneVisible = True hudControl.leftLaneVisible = True @@ -292,7 +292,7 @@ class Controls(IQControlsLayer): 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'].noResponseForceDecel or + cs.forceDecel = bool((self.sm['driverMonitoringState'].awarenessStatus < 0.) or (self.sm['selfdriveState'].state == State.softDisabling)) lat_tuning = self.CP.lateralTuning.which() diff --git a/selfdrive/debug/cycle_alerts.py b/selfdrive/debug/cycle_alerts.py index c1f30bc..5b25d8c 100755 --- a/selfdrive/debug/cycle_alerts.py +++ b/selfdrive/debug/cycle_alerts.py @@ -30,9 +30,9 @@ def cycle_alerts(duration=200, is_metric=False): (EventName.accFaulted, ET.IMMEDIATE_DISABLE), # DM sequence - (EventName.driverDistracted1, ET.WARNING), - (EventName.driverDistracted2, ET.WARNING), - (EventName.driverDistracted3, ET.WARNING), + (EventName.preDriverDistracted, ET.WARNING), + (EventName.promptDriverDistracted, ET.WARNING), + (EventName.driverDistracted, ET.WARNING), ] # debug alerts diff --git a/selfdrive/modeld/SConscript b/selfdrive/modeld/SConscript index 71989c8..40e7401 100644 --- a/selfdrive/modeld/SConscript +++ b/selfdrive/modeld/SConscript @@ -60,7 +60,7 @@ def host_tinygrad_flags(*, float16=False): return f"{base} FLOAT16=1" if float16 else base # Compile small models -for model_name in ['dmonitoring_model', 'dmonitoring_model_mici']: +for model_name in ['dmonitoring_model']: # The optimization flags are mandatory on QCOM: without FLOAT16/NOLOCALS/JIT_BATCH_SIZE/OPENPILOT_HACKS these # models compile to unoptimized QCOM kernels and run ~20x slower (dmonitoring_model: ~300ms -> ~14ms), # which starves the driving model on the shared Adreno. IMAGE=2 (not upstream's IMAGE=1) because the diff --git a/selfdrive/modeld/dmonitoringmodeld.py b/selfdrive/modeld/dmonitoringmodeld.py index 422a4a9..0e50932 100755 --- a/selfdrive/modeld/dmonitoringmodeld.py +++ b/selfdrive/modeld/dmonitoringmodeld.py @@ -20,25 +20,19 @@ from openpilot.selfdrive.locationd.calibration_helpers import get_calibrated_rpy from openpilot.selfdrive.modeld.models.commonmodel_pyx import CLContext, MonitoringModelFrame from openpilot.selfdrive.modeld.parse_model_outputs import sigmoid, safe_exp from openpilot.selfdrive.modeld.runners.tinygrad_helpers import qcom_tensor_from_opencl_address -from openpilot.system.hardware import HARDWARE PROCESS_NAME = "selfdrive.modeld.dmonitoringmodeld" SEND_RAW_PRED = os.getenv('SEND_RAW_PRED') -MODELS_PATH = Path(__file__).parent / 'models' - - -def get_model_paths(device_type: str) -> tuple[Path, Path]: - model_name = 'dmonitoring_model_mici' if device_type == 'mici' else 'dmonitoring_model' - return MODELS_PATH / f'{model_name}_tinygrad.pkl', MODELS_PATH / f'{model_name}_metadata.pkl' +MODEL_PKL_PATH = Path(__file__).parent / 'models/dmonitoring_model_tinygrad.pkl' +METADATA_PATH = Path(__file__).parent / 'models/dmonitoring_model_metadata.pkl' class ModelState: inputs: dict[str, np.ndarray] output: np.ndarray - def __init__(self, cl_ctx, device_type=None): - model_path, metadata_path = get_model_paths(device_type or HARDWARE.get_device_type()) - with open(metadata_path, 'rb') as f: + def __init__(self, cl_ctx): + with open(METADATA_PATH, 'rb') as f: model_metadata = pickle.load(f) self.input_shapes = model_metadata['input_shapes'] self.output_slices = model_metadata['output_slices'] @@ -49,7 +43,7 @@ class ModelState: } self.tensor_inputs = {k: Tensor(v, device='NPY').realize() for k,v in self.numpy_inputs.items()} - with open(model_path, "rb") as f: + with open(MODEL_PKL_PATH, "rb") as f: self.model_run = pickle.load(f) def run(self, buf: VisionBuf, calib: np.ndarray, transform: np.ndarray) -> tuple[np.ndarray, float]: @@ -81,10 +75,8 @@ def parse_model_output(model_output): face_descs = model_output[f'face_descs_{ds_suffix}'] parsed[f'face_descs_{ds_suffix}'] = face_descs[:, :-6] parsed[f'face_descs_{ds_suffix}_std'] = safe_exp(face_descs[:, -6:]) - for key in ['face_prob', 'left_eye_prob', 'right_eye_prob','left_blink_prob', 'right_blink_prob', 'sunglasses_prob', 'using_phone_prob', 'sleep_prob']: - output_key = f'{key}_{ds_suffix}' - if output_key in model_output: - parsed[output_key] = sigmoid(model_output[output_key]) + for key in ['face_prob', 'left_eye_prob', 'right_eye_prob','left_blink_prob', 'right_blink_prob', 'sunglasses_prob', 'using_phone_prob']: + parsed[f'{key}_{ds_suffix}'] = sigmoid(model_output[f'{key}_{ds_suffix}']) return parsed def fill_driver_data(msg, model_output, ds_suffix): @@ -99,8 +91,6 @@ def fill_driver_data(msg, model_output, ds_suffix): msg.rightBlinkProb = model_output[f'right_blink_prob_{ds_suffix}'][0, 0].item() msg.sunglassesProb = model_output[f'sunglasses_prob_{ds_suffix}'][0, 0].item() msg.phoneProb = model_output[f'using_phone_prob_{ds_suffix}'][0, 0].item() - sleep_prob = model_output.get(f'sleep_prob_{ds_suffix}') - msg.sleepProb = sleep_prob[0, 0].item() if sleep_prob is not None else 0. def get_driverstate_packet(model_output, frame_id: int, location_ts: int, exec_time: float, gpu_exec_time: float): msg = messaging.new_message('driverStateV2', valid=True) diff --git a/selfdrive/modeld/models/dmonitoring_model.onnx b/selfdrive/modeld/models/dmonitoring_model.onnx index 873c74b..51d1849 100644 Binary files a/selfdrive/modeld/models/dmonitoring_model.onnx and b/selfdrive/modeld/models/dmonitoring_model.onnx differ diff --git a/selfdrive/modeld/models/dmonitoring_model_metadata.pkl b/selfdrive/modeld/models/dmonitoring_model_metadata.pkl index 9aad8d4..7869f9d 100644 Binary files a/selfdrive/modeld/models/dmonitoring_model_metadata.pkl and b/selfdrive/modeld/models/dmonitoring_model_metadata.pkl differ diff --git a/selfdrive/modeld/models/dmonitoring_model_mici.onnx b/selfdrive/modeld/models/dmonitoring_model_mici.onnx deleted file mode 100644 index 51d1849..0000000 Binary files a/selfdrive/modeld/models/dmonitoring_model_mici.onnx and /dev/null differ diff --git a/selfdrive/modeld/models/dmonitoring_model_mici_metadata.pkl b/selfdrive/modeld/models/dmonitoring_model_mici_metadata.pkl deleted file mode 100644 index 7869f9d..0000000 Binary files a/selfdrive/modeld/models/dmonitoring_model_mici_metadata.pkl and /dev/null differ diff --git a/selfdrive/modeld/models/dmonitoring_model_mici_tinygrad.pkl b/selfdrive/modeld/models/dmonitoring_model_mici_tinygrad.pkl deleted file mode 100644 index a89f4f1..0000000 Binary files a/selfdrive/modeld/models/dmonitoring_model_mici_tinygrad.pkl and /dev/null differ diff --git a/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl b/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl index 8f33bbb..a89f4f1 100644 Binary files a/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl and b/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl differ diff --git a/selfdrive/modeld/models/prebuilt_check.json b/selfdrive/modeld/models/prebuilt_check.json index 1014aa4..6d0839d 100644 --- a/selfdrive/modeld/models/prebuilt_check.json +++ b/selfdrive/modeld/models/prebuilt_check.json @@ -1,15 +1,8 @@ { "dmonitoring_model": { "outputs": { - "dmonitoring_model_metadata.pkl": "5999c262b1c25c62e485fb4ced5806d20a8ca59e3ae94e0ff499c0fe3497fedc", - "dmonitoring_model_tinygrad.pkl": "5aca89a35b42376d56f67ccd28a1080806706d546dd8c63f6e1b4c681f8e2c01" - }, - "signature": "2364ebd4bb95c4b4e539c9b1ba68324b713cbb56617396b73262accf9cdcfbfc" - }, - "dmonitoring_model_mici": { - "outputs": { - "dmonitoring_model_mici_metadata.pkl": "31a86ab7a92dc0af088b15787a440dd3b210aa662e445a15145900e559a1b5c3", - "dmonitoring_model_mici_tinygrad.pkl": "806c0ea75df6bf6dfeb81b832314c68e31df5865a52d0359e6eeb76d93ad2b52" + "dmonitoring_model_metadata.pkl": "31a86ab7a92dc0af088b15787a440dd3b210aa662e445a15145900e559a1b5c3", + "dmonitoring_model_tinygrad.pkl": "806c0ea75df6bf6dfeb81b832314c68e31df5865a52d0359e6eeb76d93ad2b52" }, "signature": "e1eeb5ce45774a816c8da2394e6ee35ebf700b71dff345e0141dbab8ff592349" } diff --git a/selfdrive/modeld/prebuilt_models.py b/selfdrive/modeld/prebuilt_models.py index 384939f..73a16de 100644 --- a/selfdrive/modeld/prebuilt_models.py +++ b/selfdrive/modeld/prebuilt_models.py @@ -11,7 +11,7 @@ BASEDIR = MODELD_DIR.parents[1] TINYGRAD_DIR = BASEDIR / 'tinygrad_repo' METADATA_SCRIPT = MODELD_DIR / 'get_model_metadata.py' -MODEL_NAMES = ['dmonitoring_model', 'dmonitoring_model_mici'] +MODEL_NAMES = ['dmonitoring_model'] def _hash_file(h, path: Path) -> None: diff --git a/selfdrive/modeld/test_dmonitoringmodeld.py b/selfdrive/modeld/test_dmonitoringmodeld.py deleted file mode 100644 index daf7be6..0000000 --- a/selfdrive/modeld/test_dmonitoringmodeld.py +++ /dev/null @@ -1,37 +0,0 @@ -import pickle - -import numpy as np -import pytest - -from openpilot.selfdrive.modeld.dmonitoringmodeld import get_driverstate_packet, get_model_paths, parse_model_output, slice_outputs - - -@pytest.mark.parametrize("device_type, model_name", [ - ("mici", "dmonitoring_model_mici"), - ("tici", "dmonitoring_model"), - ("tizi", "dmonitoring_model"), -]) -def test_model_paths(device_type, model_name): - model_path, metadata_path = get_model_paths(device_type) - - assert model_path.name == f"{model_name}_tinygrad.pkl" - assert metadata_path.name == f"{model_name}_metadata.pkl" - - -@pytest.mark.parametrize("device_type, expected_sleep_prob", [ - ("mici", 0.), - ("tici", 0.5), - ("tizi", 0.5), -]) -def test_sleep_probability_output(device_type, expected_sleep_prob): - _, metadata_path = get_model_paths(device_type) - with open(metadata_path, 'rb') as f: - metadata = pickle.load(f) - - output = np.zeros(metadata['output_shapes']['outputs'][1], dtype=np.float32) - parsed = parse_model_output(slice_outputs(output, metadata['output_slices'])) - parsed['raw_pred'] = b'' - msg = get_driverstate_packet(parsed, 1, 0, 0., 0.) - - assert msg.driverStateV2.leftDriverData.sleepProb == expected_sleep_prob - assert msg.driverStateV2.rightDriverData.sleepProb == expected_sleep_prob diff --git a/selfdrive/modeld/test_prebuilt_models.py b/selfdrive/modeld/test_prebuilt_models.py index 1b05e51..a994982 100644 --- a/selfdrive/modeld/test_prebuilt_models.py +++ b/selfdrive/modeld/test_prebuilt_models.py @@ -1,52 +1,51 @@ import hashlib import json -import pytest - from openpilot.selfdrive.modeld import prebuilt_models -def write_outputs(models_dir, check_path, model_names): - checks = {} - for model_name in model_names: - outputs = {} - for suffix, contents in { - 'tinygrad.pkl': b'tinygrad', - 'metadata.pkl': b'metadata', - }.items(): - name = f'{model_name}_{suffix}' - (models_dir / name).write_bytes(contents) - outputs[name] = hashlib.sha256(contents).hexdigest() - checks[model_name] = {'outputs': outputs} - check_path.write_text(json.dumps(checks)) +def write_outputs(models_dir, check_path): + outputs = {} + for name, contents in { + 'dmonitoring_model_tinygrad.pkl': b'tinygrad', + 'dmonitoring_model_metadata.pkl': b'metadata', + }.items(): + (models_dir / name).write_bytes(contents) + outputs[name] = hashlib.sha256(contents).hexdigest() + check_path.write_text(json.dumps({'dmonitoring_model': {'outputs': outputs}})) -@pytest.fixture -def packaged_models(tmp_path, monkeypatch): +def test_packaged_prebuilt_without_onnx(tmp_path, monkeypatch): models_dir = tmp_path / 'models' models_dir.mkdir() check_path = models_dir / 'prebuilt_check.json' - write_outputs(models_dir, check_path, prebuilt_models.MODEL_NAMES) + write_outputs(models_dir, check_path) monkeypatch.setattr(prebuilt_models, 'MODELS_DIR', models_dir) monkeypatch.setattr(prebuilt_models, 'CHECK_PATH', check_path) - return models_dir + + assert prebuilt_models.packaged_prebuilt_matches('dmonitoring_model') + assert not prebuilt_models.verify_prebuilt('dmonitoring_model', 'flags') -@pytest.mark.parametrize("model_name", prebuilt_models.MODEL_NAMES) -def test_packaged_prebuilt_without_onnx(packaged_models, model_name): - assert prebuilt_models.packaged_prebuilt_matches(model_name) - assert not prebuilt_models.verify_prebuilt(model_name, 'flags') +def test_packaged_prebuilt_rejects_corrupt_output(tmp_path, monkeypatch): + models_dir = tmp_path / 'models' + models_dir.mkdir() + check_path = models_dir / 'prebuilt_check.json' + write_outputs(models_dir, check_path) + (models_dir / 'dmonitoring_model_tinygrad.pkl').write_bytes(b'corrupt') + monkeypatch.setattr(prebuilt_models, 'MODELS_DIR', models_dir) + monkeypatch.setattr(prebuilt_models, 'CHECK_PATH', check_path) + + assert not prebuilt_models.packaged_prebuilt_matches('dmonitoring_model') -@pytest.mark.parametrize("model_name", prebuilt_models.MODEL_NAMES) -def test_packaged_prebuilt_rejects_corrupt_output(packaged_models, model_name): - (packaged_models / f'{model_name}_tinygrad.pkl').write_bytes(b'corrupt') +def test_source_checkout_is_not_packaged_prebuilt(tmp_path, monkeypatch): + models_dir = tmp_path / 'models' + models_dir.mkdir() + check_path = models_dir / 'prebuilt_check.json' + write_outputs(models_dir, check_path) + (models_dir / 'dmonitoring_model.onnx').write_bytes(b'onnx') + monkeypatch.setattr(prebuilt_models, 'MODELS_DIR', models_dir) + monkeypatch.setattr(prebuilt_models, 'CHECK_PATH', check_path) - assert not prebuilt_models.packaged_prebuilt_matches(model_name) - - -@pytest.mark.parametrize("model_name", prebuilt_models.MODEL_NAMES) -def test_source_checkout_is_not_packaged_prebuilt(packaged_models, model_name): - (packaged_models / f'{model_name}.onnx').write_bytes(b'onnx') - - assert not prebuilt_models.packaged_prebuilt_matches(model_name) + assert not prebuilt_models.packaged_prebuilt_matches('dmonitoring_model') diff --git a/selfdrive/monitoring/README.md b/selfdrive/monitoring/README.md new file mode 100644 index 0000000..2a29ea0 --- /dev/null +++ b/selfdrive/monitoring/README.md @@ -0,0 +1,15 @@ +# driver monitoring (DM) + +Uploading driver-facing camera footage is opt-in, but it is encouraged to opt-in to improve the DM model. You can always change your preference using the "Record and Upload Driver Camera" toggle. + +## Troubleshooting + +Before creating a bug report, go through these troubleshooting steps. + +* Ensure the driver-facing camera has a good view of the driver in normal driving positions. + * This can be checked in Settings -> Device -> Preview Driver Camera (when car is off). +* If the camera can't see the driver, the device should be re-mounted. + +## Bug report + +In order for us to look into DM bug reports, we'll need the driver-facing camera footage. If you don't normally have this enabled, simply enable the toggle for a single drive. Also ensure the "Upload Raw Logs" toggle is enabled before going for a drive. diff --git a/selfdrive/monitoring/dmonitoringd.py b/selfdrive/monitoring/dmonitoringd.py index 552b8fb..022415a 100755 --- a/selfdrive/monitoring/dmonitoringd.py +++ b/selfdrive/monitoring/dmonitoringd.py @@ -1,33 +1,8 @@ #!/usr/bin/env python3 -from types import SimpleNamespace - import cereal.messaging as messaging from openpilot.common.params import Params from openpilot.common.realtime import config_realtime_process -from openpilot.selfdrive.monitoring.legacy_policy import DRIVER_MONITOR_SETTINGS as LegacySettings -from openpilot.selfdrive.monitoring.legacy_policy import DriverMonitoring as LegacyDriverMonitoring -from openpilot.selfdrive.monitoring.policy import DriverMonitoring as UpstreamDriverMonitoring -from openpilot.system.hardware import HARDWARE - - -def use_legacy_dm(device_type: str) -> bool: - return device_type == 'mici' - - -def create_driver_monitoring(device_type: str, rhd_saved: bool, always_on: bool): - if use_legacy_dm(device_type): - return LegacyDriverMonitoring(rhd_saved=rhd_saved, settings=LegacySettings(device_type), always_on=always_on) - return UpstreamDriverMonitoring(rhd_saved=rhd_saved, always_on=always_on) - - -def get_dm_inputs(sm): - return { - 'driverStateV2': sm['driverStateV2'], - 'liveCalibration': sm['liveCalibration'], - 'carState': sm['carState'], - 'selfdriveState': SimpleNamespace(enabled=sm['selfdriveState'].enabled or sm['carControl'].latActive), - 'modelV2': sm['modelV2'], - } +from openpilot.selfdrive.monitoring.helpers import DriverMonitoring def dmonitoringd_thread(): @@ -38,9 +13,7 @@ def dmonitoringd_thread(): sm = messaging.SubMaster(['driverStateV2', 'liveCalibration', 'carState', 'selfdriveState', 'modelV2', 'carControl'], poll='driverStateV2') - device_type = HARDWARE.get_device_type() - legacy_dm = use_legacy_dm(device_type) - DM = create_driver_monitoring(device_type, params.get_bool("IsRhdDetected"), params.get_bool("AlwaysOnDM")) + DM = DriverMonitoring(rhd_saved=params.get_bool("IsRhdDetected"), always_on=params.get_bool("AlwaysOnDM")) demo_mode=False # 20Hz <- dmonitoringmodeld @@ -52,9 +25,9 @@ def dmonitoringd_thread(): valid = sm.all_checks() if demo_mode and sm.valid['driverStateV2']: - DM.run_step(sm if legacy_dm else get_dm_inputs(sm), demo=True) + DM.run_step(sm, demo=demo_mode) elif valid: - DM.run_step(sm if legacy_dm else get_dm_inputs(sm), demo=demo_mode) + DM.run_step(sm, demo=demo_mode) # publish dat = DM.get_state_packet(valid=valid) @@ -66,11 +39,10 @@ def dmonitoringd_thread(): demo_mode = params.get_bool("IsDriverViewEnabled") # save rhd virtual toggle every 5 mins - wheelpos_offsetter = DM.wheelpos.prob_offseter if legacy_dm else DM.wheelpos_offsetter if (sm['driverStateV2'].frameId % 6000 == 0 and not demo_mode and - wheelpos_offsetter.filtered_stat.n > DM.settings._WHEELPOS_FILTER_MIN_COUNT and - DM.wheel_on_right == (wheelpos_offsetter.filtered_stat.M > DM.settings._WHEELPOS_THRESHOLD)): - params.put_bool("IsRhdDetected", DM.wheel_on_right) + DM.wheelpos.prob_offseter.filtered_stat.n > DM.settings._WHEELPOS_FILTER_MIN_COUNT and + DM.wheel_on_right == (DM.wheelpos.prob_offseter.filtered_stat.M > DM.settings._WHEELPOS_THRESHOLD)): + params.put_bool_nonblocking("IsRhdDetected", DM.wheel_on_right) def main(): dmonitoringd_thread() diff --git a/selfdrive/monitoring/legacy_policy.py b/selfdrive/monitoring/helpers.py similarity index 86% rename from selfdrive/monitoring/legacy_policy.py rename to selfdrive/monitoring/helpers.py index c450fd7..6f8752d 100644 --- a/selfdrive/monitoring/legacy_policy.py +++ b/selfdrive/monitoring/helpers.py @@ -13,12 +13,6 @@ from openpilot.selfdrive.locationd.calibration_helpers import get_calibrated_rpy from openpilot.system.hardware import HARDWARE EventName = log.OnroadEvent.EventName -AlertLevel = log.DriverMonitoringState.AlertLevel -MonitoringPolicy = log.DriverMonitoringState.MonitoringPolicy - - -def to_percent(v): - return int(min(max(v * 100., 0.), 100.)) # ****************************************************************************************** # NOTE: To fork maintainers. @@ -397,61 +391,44 @@ class DriverMonitoring: alert = None if self.awareness <= 0.: # terminal red alert: disengagement required - alert = EventName.driverDistracted3 if self.active_monitoring_mode else EventName.driverUnresponsive3 + alert = EventName.driverDistracted if self.active_monitoring_mode else EventName.driverUnresponsive self.terminal_time += 1 if awareness_prev > 0.: self.terminal_alert_cnt += 1 elif self.awareness <= self.threshold_prompt: # prompt orange alert - alert = EventName.driverDistracted2 if self.active_monitoring_mode else EventName.driverUnresponsive2 + alert = EventName.promptDriverDistracted if self.active_monitoring_mode else EventName.promptDriverUnresponsive elif self.awareness <= self.threshold_pre and not always_on_lowspeed_exemption: # pre green alert - alert = EventName.driverDistracted1 if self.active_monitoring_mode else EventName.driverUnresponsive1 + alert = EventName.preDriverDistracted if self.active_monitoring_mode else EventName.preDriverUnresponsive if alert is not None: self.current_events.add(alert) def get_state_packet(self, valid=True): + # build driverMonitoringState packet dat = messaging.new_message('driverMonitoringState', valid=valid) - dm = dat.driverMonitoringState - - dm.lockout = self.too_distracted - dm.alert3Count = self.terminal_alert_cnt - dm.noResponseCount = int(self.terminal_time >= self.settings._MAX_TERMINAL_DURATION) - dm.noResponseForceDecel = self.awareness <= 0. - dm.alwaysOn = self.always_on - dm.alwaysOnLockout = self.always_on and self.awareness <= self.threshold_prompt - if self.awareness <= 0.: - dm.alertLevel = AlertLevel.three - elif self.awareness <= self.threshold_prompt: - dm.alertLevel = AlertLevel.two - elif self.awareness <= self.threshold_pre: - dm.alertLevel = AlertLevel.one - dm.activePolicy = MonitoringPolicy.vision if self.active_monitoring_mode else MonitoringPolicy.wheeltouch - dm.isRHD = self.wheel_on_right - dm.rhdCalibration.calibratedPercent = to_percent(self.wheelpos.prob_offseter.filtered_stat.n / self.settings._WHEELPOS_FILTER_MIN_COUNT) - dm.rhdCalibration.offset = self.wheelpos.prob_offseter.filtered_stat.M - - dm.visionPolicyState.awarenessPercent = to_percent(self.awareness if self.active_monitoring_mode else self.awareness_active) - dm.visionPolicyState.awarenessStep = self.step_change if self.active_monitoring_mode else 0. - dm.visionPolicyState.isDistracted = self.driver_distracted - dm.visionPolicyState.distractedTypes.pose = DistractedType.DISTRACTED_POSE in self.distracted_types - dm.visionPolicyState.distractedTypes.eye = DistractedType.DISTRACTED_BLINK in self.distracted_types - dm.visionPolicyState.distractedTypes.phone = DistractedType.DISTRACTED_PHONE in self.distracted_types - dm.visionPolicyState.faceDetected = self.face_detected - dm.visionPolicyState.pose.pitch = self.pose.pitch - dm.visionPolicyState.pose.yaw = self.pose.yaw - dm.visionPolicyState.pose.calibrated = self.pose.calibrated - dm.visionPolicyState.pose.pitchCalib.calibratedPercent = to_percent(self.pose.pitch_offseter.filtered_stat.n / self.settings._POSE_OFFSET_MIN_COUNT) - dm.visionPolicyState.pose.pitchCalib.offset = self.pose.pitch_offseter.filtered_stat.M - dm.visionPolicyState.pose.yawCalib.calibratedPercent = to_percent(self.pose.yaw_offseter.filtered_stat.n / self.settings._POSE_OFFSET_MIN_COUNT) - dm.visionPolicyState.pose.yawCalib.offset = self.pose.yaw_offseter.filtered_stat.M - dm.visionPolicyState.pose.uncertainty = max(self.pose.pitch_std, self.pose.yaw_std) - dm.visionPolicyState.wheeltouchFallbackPercent = to_percent(self.hi_stds / self.settings._HI_STD_FALLBACK_TIME) - dm.visionPolicyState.uncertainOffroadAlertPercent = to_percent(self.dcam_uncertain_cnt / int(60 / self.settings._DT_DMON)) - - dm.wheeltouchPolicyState.awarenessPercent = to_percent(self.awareness if not self.active_monitoring_mode else self.awareness_passive) - dm.wheeltouchPolicyState.awarenessStep = self.step_change if not self.active_monitoring_mode else 0. + dat.driverMonitoringState = { + "events": self.current_events.to_msg(), + "faceDetected": self.face_detected, + "isDistracted": self.driver_distracted, + "distractedType": sum(self.distracted_types), + "awarenessStatus": self.awareness, + "posePitchOffset": self.pose.pitch_offseter.filtered_stat.mean(), + "posePitchValidCount": self.pose.pitch_offseter.filtered_stat.n, + "poseYawOffset": self.pose.yaw_offseter.filtered_stat.mean(), + "poseYawValidCount": self.pose.yaw_offseter.filtered_stat.n, + "phoneProbOffset": self.phone.prob_offseter.filtered_stat.mean(), + "phoneProbValidCount": self.phone.prob_offseter.filtered_stat.n, + "stepChange": self.step_change, + "awarenessActive": self.awareness_active, + "awarenessPassive": self.awareness_passive, + "isLowStd": self.pose.low_std, + "hiStdCount": self.hi_stds, + "isActiveMode": self.active_monitoring_mode, + "isRHD": self.wheel_on_right, + "uncertainCount": self.dcam_uncertain_cnt, + } return dat def run_step(self, sm, demo=False): diff --git a/selfdrive/monitoring/policy.py b/selfdrive/monitoring/policy.py deleted file mode 100644 index 1c55b4d..0000000 --- a/selfdrive/monitoring/policy.py +++ /dev/null @@ -1,467 +0,0 @@ -from collections import defaultdict -from math import atan2, radians -import numpy as np - -from cereal import car, log -import cereal.messaging as messaging -from openpilot.common.realtime import DT_DMON -from openpilot.common.filter_simple import FirstOrderFilter -from openpilot.common.params import Params -from openpilot.common.stat_live import RunningStatFilter -from openpilot.common.transformations.camera import DEVICE_CAMERAS - -AlertLevel = log.DriverMonitoringState.AlertLevel -MonitoringPolicy = log.DriverMonitoringState.MonitoringPolicy - -def to_percent(v): - return int(min(max(v * 100., 0.), 100.)) - -# ****************************************************************************************** -# NOTE: To fork maintainers. -# Disabling or nerfing safety features will get you and your users banned from our servers. -# We recommend that you do not change these numbers from the defaults. -# ****************************************************************************************** - -class DRIVER_MONITOR_SETTINGS: - def __init__(self): - # 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_TIMES = [int(60 * n_min / DT_DMON) for n_min in [1, 5, 15, 30]] - - self._TIMEOUT_RECOVERY_FACTOR_MAX = 5. - self._TIMEOUT_RECOVERY_FACTOR_MIN = 1.25 - - self._FACE_THRESHOLD = 0.7 - self._EYE_THRESHOLD = 0.65 - self._SG_THRESHOLD = 0.9 - self._BLINK_THRESHOLD = 0.865 - self._PHONE_THRESH = 0.5 - self._POSE_PITCH_THRESHOLD = 0.3133 - self._POSE_PITCH_THRESHOLD_SLACK = 0.3237 - self._POSE_PITCH_THRESHOLD_STRICT = self._POSE_PITCH_THRESHOLD - self._POSE_YAW_THRESHOLD = 0.4020 - self._POSE_YAW_THRESHOLD_SLACK = 0.5042 - self._POSE_YAW_THRESHOLD_STRICT = self._POSE_YAW_THRESHOLD - self._POSE_YAW_MIN_STEER_DEG = 30 - self._POSE_YAW_STEER_FACTOR = 0.15 - self._POSE_YAW_STEER_MAX_OFFSET = 0.3927 - self._PITCH_NATURAL_OFFSET = 0.011 # initial value before offset is learned - self._PITCH_NATURAL_THRESHOLD = 0.449 - self._YAW_NATURAL_OFFSET = 0.075 # initial value before offset is learned - self._PITCH_NATURAL_VAR = 3*0.01 - self._YAW_NATURAL_VAR = 3*0.05 - self._PITCH_MAX_OFFSET = 0.124 - self._PITCH_MIN_OFFSET = -0.0881 - self._YAW_MAX_OFFSET = 0.289 - self._YAW_MIN_OFFSET = -0.0246 - - self._DCAM_UNCERTAIN_ALERT_THRESHOLD = 0.1 - self._DCAM_UNCERTAIN_ALERT_COUNT = int(60 / DT_DMON) - self._DCAM_UNCERTAIN_RESET_COUNT = int(2 / DT_DMON) - self._HI_STD_THRESHOLD = 0.3 - self._HI_STD_FALLBACK_TIME = int(10 / DT_DMON) # fall back to wheel touch if model is uncertain for 10s - self._DISTRACTED_FILTER_TS = 0.25 # 0.6Hz - - self._POSE_CALIB_MIN_SPEED = 13 # 30 mph - self._POSE_OFFSET_MIN_COUNT = int(60 / DT_DMON) # valid data counts before calibration completes, 1min cumulative - self._POSE_OFFSET_MAX_COUNT = int(360 / DT_DMON) # stop deweighting new data after 6 min, aka "short term memory" - self._WHEELPOS_CALIB_MIN_SPEED = 11 - self._WHEELPOS_THRESHOLD = 0.5 - self._WHEELPOS_FILTER_MIN_COUNT = int(15 / DT_DMON) # allow 15 seconds to converge wheel side - self._WHEELPOS_DATA_AVG = 0.03 - self._WHEELPOS_DATA_VAR = 3*5.5e-5 - self._WHEELPOS_MAX_COUNT = -1 - -class DriverPose: - def __init__(self, settings): - pitch_filter_raw_priors = (settings._PITCH_NATURAL_OFFSET, settings._PITCH_NATURAL_VAR, 2) - yaw_filter_raw_priors = (settings._YAW_NATURAL_OFFSET, settings._YAW_NATURAL_VAR, 2) - self.yaw = 0. - self.pitch = 0. - self.pitch_offsetter = RunningStatFilter(raw_priors=pitch_filter_raw_priors, max_trackable=settings._POSE_OFFSET_MAX_COUNT) - self.yaw_offsetter = RunningStatFilter(raw_priors=yaw_filter_raw_priors, max_trackable=settings._POSE_OFFSET_MAX_COUNT) - self.calibrated = False - self.low_std = True - self.cfactor_pitch = 1. - self.cfactor_yaw = 1. - self.steer_yaw_offset = 0. - -class DriverBlink: - def __init__(self): - self.left = 0. - self.right = 0. - -# model output refers to center of undistorted+leveled image -ref_undistorted_cam = DEVICE_CAMERAS[("tici", "ar0231")].dcam -dcam_undistorted_FL = 598.0 -dcam_undistorted_W, dcam_undistorted_H = (ref_undistorted_cam.width, ref_undistorted_cam.height) - -def face_orientation_from_model(orient_model, pos_model, rpy_calib): - pitch_model = orient_model[0] - yaw_model = orient_model[1] - - face_pixel_position = ((pos_model[0]+0.5)*dcam_undistorted_W, (pos_model[1]+0.5)*dcam_undistorted_H) - yaw_focal_angle = atan2(face_pixel_position[0] - dcam_undistorted_W//2, dcam_undistorted_FL) - pitch_focal_angle = atan2(face_pixel_position[1] - dcam_undistorted_H//2, dcam_undistorted_FL) - - pitch = pitch_model + pitch_focal_angle - yaw = -yaw_model + yaw_focal_angle - - pitch -= rpy_calib[1] - yaw -= rpy_calib[2] - return pitch, yaw - - -class DriverMonitoring: - def __init__(self, rhd_saved=False, settings=None, always_on=False): - # init policy settings - self.settings = settings if settings is not None else DRIVER_MONITOR_SETTINGS() - - # init driver status - wheelpos_filter_raw_priors = (self.settings._WHEELPOS_DATA_AVG, self.settings._WHEELPOS_DATA_VAR, 2) - self.wheelpos_offsetter = RunningStatFilter(raw_priors=wheelpos_filter_raw_priors, max_trackable=self.settings._WHEELPOS_MAX_COUNT) - self.pose = DriverPose(settings=self.settings) - self.blink = DriverBlink() - self.phone_prob = 0. - - self.alert_level = AlertLevel.none - self.always_on = always_on - self.distracted_types = defaultdict(bool) - self.driver_distracted = False - self.driver_distraction_filter = FirstOrderFilter(0., self.settings._DISTRACTED_FILTER_TS, DT_DMON) - self.wheel_on_right = False - self.wheel_on_right_last = None - self.wheel_on_right_default = rhd_saved - self.face_detected = False - 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_active = Params().get_bool("DriverTooDistracted") - self.lockout_count = Params().get("DriverLockoutCount") or 0 - self.lockout_duration = self.settings._LOCKOUT_TIMES[min(max(self.lockout_count - 1, 0), len(self.settings._LOCKOUT_TIMES) - 1)] - self.lockout_time_elapsed = 0 - self.step_change = 0. - self.active_policy = MonitoringPolicy.vision - self.driver_interacting = False - self.is_model_uncertain = False - self.hi_stds = 0 - self.model_std_max = 0. - self.threshold_alert_1 = 0. - self.threshold_alert_2 = 0. - self.dcam_uncertain_cnt = 0 - self.dcam_reset_cnt = 0 - - self._reset_awareness() - self._set_policy(MonitoringPolicy.vision) - - def _reset_awareness(self): - self.awareness = 1. - self.last_vision_awareness = 1. - self.last_wheeltouch_awareness = 1. - - def _set_policy(self, target_policy): - if self.active_policy == MonitoringPolicy.vision and self.awareness <= self.threshold_alert_2: - if target_policy == MonitoringPolicy.vision: - self.step_change = DT_DMON / self.settings._VISION_POLICY_ALERT_3_TIMEOUT - else: - self.step_change = 0. - return # no exploit after orange alert - elif self.awareness <= 0.: - return - - if target_policy == MonitoringPolicy.vision: - # when falling back from passive mode to active mode, reset awareness to avoid false alert - if self.active_policy != MonitoringPolicy.vision: - self.last_wheeltouch_awareness = self.awareness - self.awareness = self.last_vision_awareness - - self.threshold_alert_1 = 1. - self.settings._VISION_POLICY_ALERT_1_TIMEOUT / self.settings._VISION_POLICY_ALERT_3_TIMEOUT - self.threshold_alert_2 = 1. - self.settings._VISION_POLICY_ALERT_2_TIMEOUT / self.settings._VISION_POLICY_ALERT_3_TIMEOUT - self.step_change = DT_DMON / self.settings._VISION_POLICY_ALERT_3_TIMEOUT - self.active_policy = MonitoringPolicy.vision - else: - if self.active_policy == MonitoringPolicy.vision: - self.last_vision_awareness = self.awareness - self.awareness = self.last_wheeltouch_awareness - - self.threshold_alert_1 = 1. - self.settings._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT / self.settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT - self.threshold_alert_2 = 1. - self.settings._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT / self.settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT - self.step_change = DT_DMON / self.settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT - self.active_policy = MonitoringPolicy.wheeltouch - - def _set_pose_strictness(self, brake_disengage_prob, car_speed): - bp = brake_disengage_prob - k1 = max(-0.00156*((car_speed-16)**2)+0.6, 0.2) - bp_normal = max(min(bp / k1, 0.5),0) - self.pose.cfactor_pitch = np.interp(bp_normal, [0, 0.5], - [self.settings._POSE_PITCH_THRESHOLD_SLACK, - self.settings._POSE_PITCH_THRESHOLD_STRICT]) / self.settings._POSE_PITCH_THRESHOLD - self.pose.cfactor_yaw = np.interp(bp_normal, [0, 0.5], - [self.settings._POSE_YAW_THRESHOLD_SLACK, - self.settings._POSE_YAW_THRESHOLD_STRICT]) / self.settings._POSE_YAW_THRESHOLD - - def _get_distracted_types(self): - self.distracted_types = defaultdict(bool) - - if not self.pose.calibrated: - pitch_error = self.pose.pitch - self.settings._PITCH_NATURAL_OFFSET - yaw_error = self.pose.yaw - self.settings._YAW_NATURAL_OFFSET - else: - pitch_error = self.pose.pitch - min(max(self.pose.pitch_offsetter.filtered_stat.mean(), - self.settings._PITCH_MIN_OFFSET), self.settings._PITCH_MAX_OFFSET) - yaw_error = self.pose.yaw - min(max(self.pose.yaw_offsetter.filtered_stat.mean(), - self.settings._YAW_MIN_OFFSET), self.settings._YAW_MAX_OFFSET) - pitch_error = 0 if pitch_error > 0 else abs(pitch_error) # no positive pitch limit - - if yaw_error * self.pose.steer_yaw_offset > 0: # unidirectional - yaw_error = max(abs(yaw_error) - min(abs(self.pose.steer_yaw_offset), self.settings._POSE_YAW_STEER_MAX_OFFSET), 0.) - else: - yaw_error = abs(yaw_error) - - pitch_threshold = self.settings._POSE_PITCH_THRESHOLD * self.pose.cfactor_pitch if self.pose.calibrated else self.settings._PITCH_NATURAL_THRESHOLD - yaw_threshold = self.settings._POSE_YAW_THRESHOLD * self.pose.cfactor_yaw - - self.distracted_types['pose'] = bool((pitch_error > pitch_threshold) or (yaw_error > yaw_threshold)) - 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, 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 - driver_state.rightDriverData.faceProb > self.settings._FACE_THRESHOLD): - self.wheelpos_offsetter.push_and_update(rhd_pred) - - wheelpos_calibrated = self.wheelpos_offsetter.filtered_stat.n >= self.settings._WHEELPOS_FILTER_MIN_COUNT - - if wheelpos_calibrated or demo_mode: - self.wheel_on_right = self.wheelpos_offsetter.filtered_stat.M > self.settings._WHEELPOS_THRESHOLD - else: - self.wheel_on_right = self.wheel_on_right_default # use default/saved if calibration is unfinished - # make sure no switching when engaged - if op_engaged and self.wheel_on_right_last is not None and self.wheel_on_right_last != self.wheel_on_right and not demo_mode: - self.wheel_on_right = self.wheel_on_right_last - driver_data = driver_state.rightDriverData if self.wheel_on_right else driver_state.leftDriverData - if not all(len(x) > 0 for x in (driver_data.faceOrientation, driver_data.facePosition, - driver_data.faceOrientationStd, driver_data.facePositionStd)): - return - - self.face_detected = driver_data.faceProb > self.settings._FACE_THRESHOLD - self.pose.pitch, self.pose.yaw = face_orientation_from_model(driver_data.faceOrientation, driver_data.facePosition, cal_rpy) - steer_d = max(abs(steering_angle_deg) - self.settings._POSE_YAW_MIN_STEER_DEG, 0.) - self.pose.steer_yaw_offset = radians(steer_d) * -np.sign(steering_angle_deg) * self.settings._POSE_YAW_STEER_FACTOR - if self.wheel_on_right: - self.pose.yaw *= -1 - self.pose.steer_yaw_offset *= -1 - self.wheel_on_right_last = self.wheel_on_right - self.model_std_max = max(driver_data.faceOrientationStd[0], driver_data.faceOrientationStd[1]) - self.pose.low_std = self.model_std_max < self.settings._HI_STD_THRESHOLD - self.blink.left = driver_data.leftBlinkProb * (driver_data.leftEyeProb > self.settings._EYE_THRESHOLD) \ - * (driver_data.sunglassesProb < self.settings._SG_THRESHOLD) - self.blink.right = driver_data.rightBlinkProb * (driver_data.rightEyeProb > self.settings._EYE_THRESHOLD) \ - * (driver_data.sunglassesProb < self.settings._SG_THRESHOLD) - self.phone_prob = driver_data.phoneProb - - self._get_distracted_types() - self.driver_distracted = any(self.distracted_types.values()) and driver_data.faceProb > self.settings._FACE_THRESHOLD and self.pose.low_std - self.driver_distraction_filter.update(self.driver_distracted) - - # only update offsetter when driver is actively driving the car above a certain speed - if self.face_detected and car_speed > self.settings._POSE_CALIB_MIN_SPEED and self.pose.low_std and (not op_engaged or not self.driver_distracted): - self.pose.pitch_offsetter.push_and_update(self.pose.pitch) - self.pose.yaw_offsetter.push_and_update(self.pose.yaw) - - self.pose.calibrated = self.pose.pitch_offsetter.filtered_stat.n >= self.settings._POSE_OFFSET_MIN_COUNT and \ - self.pose.yaw_offsetter.filtered_stat.n >= self.settings._POSE_OFFSET_MIN_COUNT - - 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 lowspeed: - self.dcam_uncertain_cnt += 1 - self.dcam_reset_cnt = 0 - else: - self.dcam_reset_cnt += 1 - if self.dcam_reset_cnt > self.settings._DCAM_UNCERTAIN_RESET_COUNT: - self.dcam_uncertain_cnt = 0 - - self.is_model_uncertain = self.hi_stds >= self.settings._HI_STD_FALLBACK_TIME - self._set_policy(MonitoringPolicy.vision if self.face_detected and not self.is_model_uncertain else MonitoringPolicy.wheeltouch) - if self.face_detected and not self.pose.low_std and not self.driver_distracted: - self.hi_stds += 1 - elif self.face_detected and self.pose.low_std: - self.hi_stds = 0 - - def _update_events(self, driver_engaged, op_engaged, lowspeed, wrong_gear): - self.alert_level = AlertLevel.none - self.driver_interacting = driver_engaged - - if self.alert_3_cnt >= self.settings._MAX_ALERT_3 or self.no_response_cnt >= self.settings._MAX_NO_RESPONSE: - if not self.lockout_active: - self.lockout_count += 1 - self.lockout_duration = self.settings._LOCKOUT_TIMES[min(self.lockout_count - 1, len(self.settings._LOCKOUT_TIMES) - 1)] - Params().put("DriverLockoutCount", self.lockout_count) - self.lockout_active = True - - if self.lockout_active: - self.lockout_time_elapsed += 1 - if self.lockout_time_elapsed > self.lockout_duration: - self.lockout_active = False - self.alert_3_cnt = 0 - self.cnt_since_alert_3 = 0 - self.no_response_cnt = 0 - self.lockout_time_elapsed = 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 \ - (always_on_valid and not op_engaged and self.awareness <= 0): - # always reset on disengage with normal mode; disengage resets only on red if always on - self._reset_awareness() - return - - 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 - 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 lowspeed_exemption): - if self.driver_interacting: - self._reset_awareness() - return - # only restore awareness when paying attention and alert is not red - self.awareness = min(self.awareness + ((self.settings._TIMEOUT_RECOVERY_FACTOR_MAX-self.settings._TIMEOUT_RECOVERY_FACTOR_MIN)* - (1.-self.awareness)+self.settings._TIMEOUT_RECOVERY_FACTOR_MIN)*self.step_change, 1.) - if self.awareness == 1.: - self.last_wheeltouch_awareness = min(self.last_wheeltouch_awareness + self.step_change, 1.) - # don't display alert banner when awareness is recovering and has cleared orange - if self.awareness > self.threshold_alert_2: - return - - certainly_distracted = self.driver_distraction_filter.x > 0.63 and self.driver_distracted and self.face_detected - 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 low speed and reaching green - # also will not be reaching 0 if DM is active when not engaged - 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 - if awareness_prev > 0.: - 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 - dat = messaging.new_message('driverMonitoringState', valid=valid) - dm = dat.driverMonitoringState - - dm.lockout = self.lockout_active - dm.lockoutCount = self.lockout_count - if self.lockout_active: - dm.lockoutMinutesRemaining = max(1, round((self.lockout_duration - self.lockout_time_elapsed) * DT_DMON / 60.)) - 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 - dm.activePolicy = self.active_policy - dm.isRHD = self.wheel_on_right - dm.rhdCalibration.calibratedPercent = to_percent(self.wheelpos_offsetter.filtered_stat.n / self.settings._WHEELPOS_FILTER_MIN_COUNT) - dm.rhdCalibration.offset = self.wheelpos_offsetter.filtered_stat.M - - dm.visionPolicyState.awarenessPercent = to_percent(self.last_vision_awareness if self.active_policy != MonitoringPolicy.vision else self.awareness) - dm.visionPolicyState.awarenessStep = self.step_change if self.active_policy == MonitoringPolicy.vision else 0. - dm.visionPolicyState.isDistracted = self.driver_distracted - dm.visionPolicyState.distractedTypes.pose = self.distracted_types['pose'] - dm.visionPolicyState.distractedTypes.eye = self.distracted_types['eye'] - dm.visionPolicyState.distractedTypes.phone = self.distracted_types['phone'] - dm.visionPolicyState.faceDetected = self.face_detected - dm.visionPolicyState.pose.pitch = self.pose.pitch - dm.visionPolicyState.pose.yaw = self.pose.yaw - dm.visionPolicyState.pose.calibrated = self.pose.calibrated - dm.visionPolicyState.pose.pitchCalib.calibratedPercent = to_percent(self.pose.pitch_offsetter.filtered_stat.n / self.settings._POSE_OFFSET_MIN_COUNT) - dm.visionPolicyState.pose.pitchCalib.offset = self.pose.pitch_offsetter.filtered_stat.M - dm.visionPolicyState.pose.yawCalib.calibratedPercent = to_percent(self.pose.yaw_offsetter.filtered_stat.n / self.settings._POSE_OFFSET_MIN_COUNT) - dm.visionPolicyState.pose.yawCalib.offset = self.pose.yaw_offsetter.filtered_stat.M - dm.visionPolicyState.pose.uncertainty = self.model_std_max - dm.visionPolicyState.wheeltouchFallbackPercent = to_percent(self.hi_stds / self.settings._HI_STD_FALLBACK_TIME) - dm.visionPolicyState.uncertainOffroadAlertPercent = to_percent(self.dcam_uncertain_cnt / self.settings._DCAM_UNCERTAIN_ALERT_COUNT) - - dm.wheeltouchPolicyState.awarenessPercent = to_percent(self.last_wheeltouch_awareness if self.active_policy == MonitoringPolicy.vision else self.awareness) - dm.wheeltouchPolicyState.awarenessStep = 0. if self.active_policy == MonitoringPolicy.vision else self.step_change - dm.wheeltouchPolicyState.driverInteracting = self.driver_interacting - return dat - - def run_step(self, sm, demo=False): - if demo: - car_speed = 30 - enabled = True - wrong_gear = False - lowspeed = False - driver_engaged = False - brake_disengage_prob = 1.0 - steering_angle_deg = 0.0 - rpyCalib = [0., 0., 0.] - else: - car_speed = sm['carState'].vEgo - enabled = sm['selfdriveState'].enabled - wrong_gear = sm['carState'].gearShifter not in (car.CarState.GearShifter.drive, car.CarState.GearShifter.low) - 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 - rpyCalib = sm['liveCalibration'].rpyCalib - - self._set_pose_strictness( - brake_disengage_prob=brake_disengage_prob, - car_speed=car_speed, - ) - - # Parse data from dmonitoringmodeld - self._update_states( - driver_state=sm['driverStateV2'], - cal_rpy=rpyCalib, - car_speed=car_speed, - op_engaged=enabled, - lowspeed=lowspeed, - demo_mode=demo, - steering_angle_deg=steering_angle_deg, - ) - - # Update distraction events - self._update_events( - driver_engaged=driver_engaged, - op_engaged=enabled, - lowspeed=lowspeed, - wrong_gear=wrong_gear, - ) diff --git a/selfdrive/monitoring/test_dmonitoringd.py b/selfdrive/monitoring/test_dmonitoringd.py deleted file mode 100644 index 750489d..0000000 --- a/selfdrive/monitoring/test_dmonitoringd.py +++ /dev/null @@ -1,61 +0,0 @@ -from types import SimpleNamespace - -import pytest - -from cereal import log -from openpilot.selfdrive.monitoring.dmonitoringd import create_driver_monitoring, get_dm_inputs, use_legacy_dm -from openpilot.selfdrive.monitoring.legacy_policy import DriverMonitoring as LegacyDriverMonitoring -from openpilot.selfdrive.monitoring.policy import DriverMonitoring as UpstreamDriverMonitoring - - -@pytest.mark.parametrize("device_type, expected_type", [ - ("mici", LegacyDriverMonitoring), - ("tici", UpstreamDriverMonitoring), - ("tizi", UpstreamDriverMonitoring), -]) -def test_policy_selection(device_type, expected_type): - assert use_legacy_dm(device_type) == (device_type == "mici") - assert isinstance(create_driver_monitoring(device_type, False, False), expected_type) - - -def test_mici_uses_legacy_thresholds(): - dm = create_driver_monitoring("mici", False, False) - - assert dm.settings._DISTRACTED_TIME == 11. - assert dm.settings._AWARENESS_TIME == 30. - assert dm.settings._PHONE_THRESH == 0.75 - - -@pytest.mark.parametrize("enabled, lat_active, expected", [ - (False, False, False), - (True, False, True), - (False, True, True), - (True, True, True), -]) -def test_iq_enabled_adapter(enabled, lat_active, expected): - sm = { - 'driverStateV2': object(), - 'liveCalibration': object(), - 'carState': object(), - 'selfdriveState': SimpleNamespace(enabled=enabled), - 'modelV2': object(), - 'carControl': SimpleNamespace(latActive=lat_active), - } - - assert get_dm_inputs(sm)['selfdriveState'].enabled == expected - - -def test_legacy_policy_packet_uses_shared_schema(): - dm = create_driver_monitoring("mici", False, False) - dm.awareness = 0. - dm.terminal_alert_cnt = 2 - dm.terminal_time = dm.settings._MAX_TERMINAL_DURATION - dm.too_distracted = True - - state = dm.get_state_packet().driverMonitoringState - - assert state.lockout - assert state.alert3Count == 2 - assert state.noResponseCount == 1 - assert state.noResponseForceDecel - assert state.alertLevel == log.DriverMonitoringState.AlertLevel.three diff --git a/selfdrive/monitoring/test_monitoring.py b/selfdrive/monitoring/test_monitoring.py index 37606fe..fef6a7e 100644 --- a/selfdrive/monitoring/test_monitoring.py +++ b/selfdrive/monitoring/test_monitoring.py @@ -1,15 +1,19 @@ -from cereal import log +import numpy as np +import pytest + +from cereal import log, car from openpilot.common.realtime import DT_DMON -from openpilot.selfdrive.monitoring.policy import DriverMonitoring, DRIVER_MONITOR_SETTINGS +from openpilot.selfdrive.monitoring.helpers import DriverMonitoring, DRIVER_MONITOR_SETTINGS +from openpilot.system.hardware import HARDWARE EventName = log.OnroadEvent.EventName -dm_settings = DRIVER_MONITOR_SETTINGS() +dm_settings = DRIVER_MONITOR_SETTINGS(device_type=HARDWARE.get_device_type()) TEST_TIMESPAN = 120 # seconds -DISTRACTED_SECONDS_TO_ORANGE = dm_settings._VISION_POLICY_ALERT_2_TIMEOUT + 1 -DISTRACTED_SECONDS_TO_RED = dm_settings._VISION_POLICY_ALERT_3_TIMEOUT + 1 -INVISIBLE_SECONDS_TO_ORANGE = dm_settings._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT + 1 -INVISIBLE_SECONDS_TO_RED = dm_settings._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT + 1 +DISTRACTED_SECONDS_TO_ORANGE = dm_settings._DISTRACTED_TIME - dm_settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL + 1 +DISTRACTED_SECONDS_TO_RED = dm_settings._DISTRACTED_TIME + 1 +INVISIBLE_SECONDS_TO_ORANGE = dm_settings._AWARENESS_TIME - dm_settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL + 1 +INVISIBLE_SECONDS_TO_RED = dm_settings._AWARENESS_TIME + 1 def make_msg(face_detected, distracted=False, model_uncertain=False): ds = log.DriverStateV2.new_message() @@ -33,7 +37,7 @@ msg_ATTENTIVE = make_msg(True) msg_DISTRACTED = make_msg(True, distracted=True) msg_ATTENTIVE_UNCERTAIN = make_msg(True, model_uncertain=True) msg_DISTRACTED_UNCERTAIN = make_msg(True, distracted=True, model_uncertain=True) -msg_DISTRACTED_BUT_SOMEHOW_UNCERTAIN = make_msg(True, distracted=True, model_uncertain=dm_settings._HI_STD_THRESHOLD*1.5) +msg_DISTRACTED_BUT_SOMEHOW_UNCERTAIN = make_msg(True, distracted=True, model_uncertain=dm_settings._POSESTD_THRESHOLD*1.5) # driver interaction with car car_interaction_DETECTED = True @@ -47,66 +51,51 @@ 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, lowspeed): + def _run_seq(self, msgs, interaction, engaged, standstill): DM = DriverMonitoring() - alert_lvls = [] + events = [] for idx in range(len(msgs)): - DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx], lowspeed[idx]) + DM._update_states(msgs[idx], [0, 0, 0], 0, engaged[idx], standstill[idx]) # cal_rpy and car_speed don't matter here # evaluate events at 10Hz for tests - 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 + DM._update_events(interaction[idx], engaged[idx], standstill[idx], 0, 0) + events.append(DM.current_events) + assert len(events) == len(msgs), f"got {len(events)} for {len(msgs)} driverState input msgs" + return events, DM + def _assert_no_events(self, events): + assert all(not len(e) for e in events) # engaged, driver is attentive all the time def test_fully_aware_driver(self): - alert_lvls, d_status = self._run_seq(always_attentive, always_false, always_true, always_false) - assert all(a == 0 for a in alert_lvls) - assert d_status.active_policy == log.DriverMonitoringState.MonitoringPolicy.vision + events, _ = self._run_seq(always_attentive, always_false, always_true, always_false) + self._assert_no_events(events) # engaged, driver is distracted and does nothing def test_fully_distracted_driver(self): - alert_lvls, d_status = self._run_seq(always_distracted, always_false, always_true, always_false) - s = d_status.settings - assert alert_lvls[int(s._VISION_POLICY_ALERT_1_TIMEOUT / 2 / DT_DMON)] == 0 - assert alert_lvls[int((s._VISION_POLICY_ALERT_1_TIMEOUT + \ - (s._VISION_POLICY_ALERT_2_TIMEOUT - s._VISION_POLICY_ALERT_1_TIMEOUT) / 2) / DT_DMON)] == 1 - assert alert_lvls[int((s._VISION_POLICY_ALERT_2_TIMEOUT + \ - (s._VISION_POLICY_ALERT_3_TIMEOUT - s._VISION_POLICY_ALERT_2_TIMEOUT) / 2) / DT_DMON)] == 2 - assert alert_lvls[int((s._VISION_POLICY_ALERT_3_TIMEOUT + \ - (TEST_TIMESPAN - 10 - s._VISION_POLICY_ALERT_3_TIMEOUT) / 2) / DT_DMON)] == 3 + events, d_status = self._run_seq(always_distracted, always_false, always_true, always_false) + assert len(events[int((d_status.settings._DISTRACTED_TIME-d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL)/2/DT_DMON)]) == 0 + assert events[int((d_status.settings._DISTRACTED_TIME-d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL + \ + ((d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL-d_status.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == \ + EventName.preDriverDistracted + assert events[int((d_status.settings._DISTRACTED_TIME-d_status.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL + \ + ((d_status.settings._DISTRACTED_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == EventName.promptDriverDistracted + assert events[int((d_status.settings._DISTRACTED_TIME + \ + ((TEST_TIMESPAN-10-d_status.settings._DISTRACTED_TIME)/2))/DT_DMON)].names[0] == EventName.driverDistracted 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) - assert alert_lvls[int(DISTRACTED_SECONDS_TO_RED / DT_DMON)] == 3 - assert d_status.lockout_active - assert d_status.lockout_time_elapsed > 0 - assert d_status.lockout_count >= 1 - - # 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) - assert d_status.active_policy == log.DriverMonitoringState.MonitoringPolicy.wheeltouch - assert d_status.lockout_active - assert d_status.lockout_count >= 1 - # 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) - s = d_status.settings - assert alert_lvls[int(s._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT / 2 / DT_DMON)] == 0 - assert alert_lvls[int((s._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT + \ - (s._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT - s._WHEELTOUCH_POLICY_ALERT_1_TIMEOUT) / 2) / DT_DMON)] == 1 - assert alert_lvls[int((s._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT + \ - (s._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT - s._WHEELTOUCH_POLICY_ALERT_2_TIMEOUT) / 2) / DT_DMON)] == 2 - assert alert_lvls[int((s._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT + \ - (TEST_TIMESPAN - 10 - s._WHEELTOUCH_POLICY_ALERT_3_TIMEOUT) / 2) / DT_DMON)] == 3 - assert d_status.active_policy == log.DriverMonitoringState.MonitoringPolicy.wheeltouch + events, d_status = self._run_seq(always_no_face, always_false, always_true, always_false) + assert len(events[int((d_status.settings._AWARENESS_TIME-d_status.settings._AWARENESS_PRE_TIME_TILL_TERMINAL)/2/DT_DMON)]) == 0 + assert events[int((d_status.settings._AWARENESS_TIME-d_status.settings._AWARENESS_PRE_TIME_TILL_TERMINAL + \ + ((d_status.settings._AWARENESS_PRE_TIME_TILL_TERMINAL-d_status.settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == \ + EventName.preDriverUnresponsive + assert events[int((d_status.settings._AWARENESS_TIME-d_status.settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL + \ + ((d_status.settings._AWARENESS_PROMPT_TIME_TILL_TERMINAL)/2))/DT_DMON)].names[0] == EventName.promptDriverUnresponsive + assert events[int((d_status.settings._AWARENESS_TIME + \ + ((TEST_TIMESPAN-10-d_status.settings._AWARENESS_TIME)/2))/DT_DMON)].names[0] == EventName.driverUnresponsive # engaged, down to orange, driver pays attention, back to normal; then down to orange, driver touches wheel # - should have short orange recovery time and no green afterwards; wheel touch only recovers when paying attention @@ -117,13 +106,13 @@ class TestMonitoring: [msg_ATTENTIVE] * (int(TEST_TIMESPAN/DT_DMON)-int((DISTRACTED_SECONDS_TO_ORANGE*3+2)/DT_DMON)) interaction_vector = [car_interaction_NOT_DETECTED] * int(DISTRACTED_SECONDS_TO_ORANGE*3/DT_DMON) + \ [car_interaction_DETECTED] * (int(TEST_TIMESPAN/DT_DMON)-int(DISTRACTED_SECONDS_TO_ORANGE*3/DT_DMON)) - alert_lvls, _ = self._run_seq(ds_vector, interaction_vector, always_true, always_false) - assert alert_lvls[int(DISTRACTED_SECONDS_TO_ORANGE*0.5/DT_DMON)] == 0 - assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE-0.1)/DT_DMON)] == 2 - assert alert_lvls[int(DISTRACTED_SECONDS_TO_ORANGE*1.5/DT_DMON)] == 0 - assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE*3-0.1)/DT_DMON)] == 2 - assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE*3+0.1)/DT_DMON)] == 2 - assert alert_lvls[int((DISTRACTED_SECONDS_TO_ORANGE*3+2.5)/DT_DMON)] == 0 + events, _ = self._run_seq(ds_vector, interaction_vector, always_true, always_false) + assert len(events[int(DISTRACTED_SECONDS_TO_ORANGE*0.5/DT_DMON)]) == 0 + assert events[int((DISTRACTED_SECONDS_TO_ORANGE-0.1)/DT_DMON)].names[0] == EventName.promptDriverDistracted + assert len(events[int(DISTRACTED_SECONDS_TO_ORANGE*1.5/DT_DMON)]) == 0 + assert events[int((DISTRACTED_SECONDS_TO_ORANGE*3-0.1)/DT_DMON)].names[0] == EventName.promptDriverDistracted + assert events[int((DISTRACTED_SECONDS_TO_ORANGE*3+0.1)/DT_DMON)].names[0] == EventName.promptDriverDistracted + assert len(events[int((DISTRACTED_SECONDS_TO_ORANGE*3+2.5)/DT_DMON)]) == 0 # engaged, down to orange, driver dodges camera, then comes back still distracted, down to red, \ # driver dodges, and then touches wheel to no avail, disengages and reengages @@ -141,31 +130,31 @@ class TestMonitoring: = [True] * int(1/DT_DMON) op_vector[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+2.5)/DT_DMON):int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+3)/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((DISTRACTED_SECONDS_TO_ORANGE+0.5*_invisible_time)/DT_DMON)] == 2 - assert alert_lvls[int((DISTRACTED_SECONDS_TO_RED+1.5*_invisible_time)/DT_DMON)] == 3 - assert alert_lvls[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+1.5)/DT_DMON)] == 3 - assert alert_lvls[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+3.5)/DT_DMON)] == 0 + events, _ = self._run_seq(ds_vector, interaction_vector, op_vector, always_false) + assert events[int((DISTRACTED_SECONDS_TO_ORANGE+0.5*_invisible_time)/DT_DMON)].names[0] == EventName.promptDriverDistracted + assert events[int((DISTRACTED_SECONDS_TO_RED+1.5*_invisible_time)/DT_DMON)].names[0] == EventName.driverDistracted + assert events[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+1.5)/DT_DMON)].names[0] == EventName.driverDistracted + assert len(events[int((DISTRACTED_SECONDS_TO_RED+2*_invisible_time+3.5)/DT_DMON)]) == 0 # 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): - 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 + _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) + events, _ = self._run_seq(ds_vector, interaction_vector, 2*always_true, 2*always_false) + assert len(events[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)]) == 0 + assert events[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)].names[0] == EventName.promptDriverUnresponsive + assert len(events[int((INVISIBLE_SECONDS_TO_ORANGE+0.1)/DT_DMON)]) == 0 + if _visible_time == 0.5: + assert events[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)].names[0] == EventName.promptDriverUnresponsive + assert events[int((INVISIBLE_SECONDS_TO_ORANGE*2+1+0.1+_visible_time)/DT_DMON)].names[0] == EventName.preDriverUnresponsive + elif _visible_time == 10: + assert events[int((INVISIBLE_SECONDS_TO_ORANGE*2+1-0.1)/DT_DMON)].names[0] == EventName.promptDriverUnresponsive + assert len(events[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 @@ -177,51 +166,105 @@ class TestMonitoring: ds_vector[int(INVISIBLE_SECONDS_TO_RED/DT_DMON):int((INVISIBLE_SECONDS_TO_RED+_visible_time)/DT_DMON)] = [msg_ATTENTIVE] * int(_visible_time/DT_DMON) 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(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 - assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED+_visible_time+0.5)/DT_DMON)] == 3 - assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED+_visible_time+1+0.1)/DT_DMON)] == 0 + events, _ = self._run_seq(ds_vector, interaction_vector, op_vector, always_false) + assert len(events[int(INVISIBLE_SECONDS_TO_ORANGE*0.5/DT_DMON)]) == 0 + assert events[int((INVISIBLE_SECONDS_TO_ORANGE-0.1)/DT_DMON)].names[0] == EventName.promptDriverUnresponsive + assert events[int((INVISIBLE_SECONDS_TO_RED-0.1)/DT_DMON)].names[0] == EventName.driverUnresponsive + assert events[int((INVISIBLE_SECONDS_TO_RED+0.5*_visible_time)/DT_DMON)].names[0] == EventName.driverUnresponsive + assert events[int((INVISIBLE_SECONDS_TO_RED+_visible_time+0.5)/DT_DMON)].names[0] == EventName.driverUnresponsive + assert len(events[int((INVISIBLE_SECONDS_TO_RED+_visible_time+1+0.1)/DT_DMON)]) == 0 # disengaged, always distracted driver # - dm should stay quiet when not engaged def test_pure_dashcam_user(self): - alert_lvls, _ = self._run_seq(always_distracted, always_false, always_false, always_false) - assert all(a == 0 for a in alert_lvls) + events, _ = self._run_seq(always_distracted, always_false, always_false, always_false) + assert sum(len(event) for event in events) == 0 # engaged, car stops at traffic light, down to orange, no action, then car starts moving # - should only reach green when stopped, but continues counting down on launch def test_long_traffic_light_victim(self): _redlight_time = 60 # seconds - 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 - assert alert_lvls[int((_redlight_time+0.5)/DT_DMON)] == 1 - 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 low speed - def test_distracted_then_stops(self): - _stop_time = DISTRACTED_SECONDS_TO_ORANGE + 1 # stop 1 second after reaching orange - 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 + standstill_vector = always_true[:] + standstill_vector[int(_redlight_time/DT_DMON):] = [False] * int((TEST_TIMESPAN-_redlight_time)/DT_DMON) + events, d_status = self._run_seq(always_distracted, always_false, always_true, standstill_vector) + assert events[int((d_status.settings._DISTRACTED_TIME-d_status.settings._DISTRACTED_PRE_TIME_TILL_TERMINAL+1)/DT_DMON)].names[0] == \ + EventName.preDriverDistracted + assert events[int((_redlight_time-0.1)/DT_DMON)].names[0] == EventName.preDriverDistracted + assert events[int((_redlight_time+0.5)/DT_DMON)].names[0] == EventName.promptDriverDistracted # engaged, model is somehow uncertain and driver is distracted # - should fall back to wheel touch after uncertain alert def test_somehow_indecisive_model(self): ds_vector = [msg_DISTRACTED_BUT_SOMEHOW_UNCERTAIN] * int(TEST_TIMESPAN/DT_DMON) interaction_vector = always_false[:] - alert_lvls, d_status = self._run_seq(ds_vector, interaction_vector, always_true, always_false) - s = d_status.settings - assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*s._HI_STD_FALLBACK_TIME-0.1)/DT_DMON)] == 1 - assert alert_lvls[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*s._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)] == 2 - assert alert_lvls[int((INVISIBLE_SECONDS_TO_RED-1+DT_DMON*s._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)] == 3 + events, d_status = self._run_seq(ds_vector, interaction_vector, always_true, always_false) + assert EventName.preDriverUnresponsive in \ + events[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*d_status.settings._HI_STD_FALLBACK_TIME-0.1)/DT_DMON)].names + assert EventName.promptDriverUnresponsive in \ + events[int((INVISIBLE_SECONDS_TO_ORANGE-1+DT_DMON*d_status.settings._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)].names + assert EventName.driverUnresponsive in \ + events[int((INVISIBLE_SECONDS_TO_RED-1+DT_DMON*d_status.settings._HI_STD_FALLBACK_TIME+0.1)/DT_DMON)].names + + +@pytest.mark.parametrize("enabled_state, lat_active_state, expected", [ + (False, False, False), # Both Disabled + (True, False, True), # OP Enabled, Lat Inactive + (False, True, True), # OP Disabled, Lat Active (e.g. AOL) + (True, True, True) # Both Active +]) +def test_enabled_states(enabled_state, lat_active_state, expected): + """ + Test DriverMonitoring.run_step with all 4 combinations of: + - selfdriveState.enabled (True/False) + - carControl.latActive (True/False) + """ + cs = car.CarState.new_message() + cs.vEgo = 30.0 + cs.gearShifter = car.CarState.GearShifter.drive + cs.standstill = False + cs.steeringPressed = False + cs.gasPressed = False + + ss = log.SelfdriveState.new_message() + ss.enabled = enabled_state + + cc = car.CarControl.new_message() + cc.latActive = lat_active_state + + mv2 = log.ModelDataV2.new_message() + mv2.meta.disengagePredictions.brakeDisengageProbs = [0.0] + + lc = log.LiveCalibrationData.new_message() + lc.rpyCalib = [0.0, 0.0, 0.0] + + ds = make_msg(False) + + sm = { + 'carState': cs, + 'selfdriveState': ss, + 'carControl': cc, + 'modelV2': mv2, + 'liveCalibration': lc, + 'driverStateV2': ds + } + + driver_monitoring = DriverMonitoring() + + # run_test doesn't assign enabled to a variable, so we need to spy on _update_events to see its value + captured_args = [] + original_update_events = driver_monitoring._update_events + + def spy_update_events(driver_engaged, op_engaged, standstill, wrong_gear, car_speed): + captured_args.append(op_engaged) + return original_update_events(driver_engaged, op_engaged, standstill, wrong_gear, car_speed) + + driver_monitoring._update_events = spy_update_events + + driver_monitoring.run_step(sm, demo=False) + + # Assertion + assert len(captured_args) == 1, "Expected _update_events to be called exactly once" + actual_enabled = captured_args[0] + + assert actual_enabled == expected, f"Expected op_engaged={expected}, but got {actual_enabled}" + diff --git a/selfdrive/selfdrived/events.py b/selfdrive/selfdrived/events.py index 5f47508..1085e11 100755 --- a/selfdrive/selfdrived/events.py +++ b/selfdrive/selfdrived/events.py @@ -79,15 +79,6 @@ def below_steer_speed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.S Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 0.4) -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 = sm['driverMonitoringState'].lockoutMinutesRemaining - if mins_left <= 0: - return NoEntryAlert("Distraction Level Too High", priority=Priority.HIGH) - return NoEntryAlert("Too Distracted", f"{mins_left} minute{'s' if mins_left != 1 else ''} Left", priority=Priority.HIGH) - return NoEntryAlert("Pay Attention to Engage", priority=Priority.HIGH) - - def calibration_incomplete_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert: first_word = 'Recalibrating' if sm['liveCalibration'].calStatus == log.LiveCalibrationData.Status.recalibrating else 'Calibrating' return Alert( @@ -235,8 +226,7 @@ def invalid_lkas_setting_alert(CP: car.CarParams, CS: car.CarState, sm: messagin return NormalPermanentAlert(title, text) -def invalid_lkas_setting_no_entry_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, - metric: bool, soft_disable_time: int, personality) -> Alert: +def invalid_lkas_setting_no_entry_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert: if CP.brand == "tesla": return NoEntryAlert("FSD / Autosteer is active", alert_text_1="Dashcam Mode") return NoEntryAlert("Invalid LKAS setting") @@ -370,15 +360,15 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = { Priority.LOW, VisualAlert.steerRequired, AudibleAlert.prompt, 1.8), }, - EventName.driverDistracted1: { + EventName.preDriverDistracted: { ET.PERMANENT: Alert( "Pay Attention", "", AlertStatus.normal, AlertSize.small, - Priority.LOW, VisualAlert.none, AudibleAlert.preAlert, .1), + Priority.LOW, VisualAlert.none, AudibleAlert.none, .1), }, - EventName.driverDistracted2: { + EventName.promptDriverDistracted: { ET.PERMANENT: Alert( "Pay Attention", "Driver Distracted", @@ -386,7 +376,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = { Priority.MID, VisualAlert.steerRequired, AudibleAlert.promptDistracted, .1), }, - EventName.driverDistracted3: { + EventName.driverDistracted: { ET.PERMANENT: Alert( "DISENGAGE IMMEDIATELY", "Driver Distracted", @@ -394,7 +384,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = { Priority.HIGH, VisualAlert.steerRequired, AudibleAlert.warningImmediate, .1), }, - EventName.driverUnresponsive1: { + EventName.preDriverUnresponsive: { ET.PERMANENT: Alert( "Touch Steering Wheel: No Face Detected", "", @@ -402,7 +392,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = { Priority.LOW, VisualAlert.steerRequired, AudibleAlert.none, .1), }, - EventName.driverUnresponsive2: { + EventName.promptDriverUnresponsive: { ET.PERMANENT: Alert( "Touch Steering Wheel", "Driver Unresponsive", @@ -410,7 +400,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = { Priority.MID, VisualAlert.steerRequired, AudibleAlert.promptDistracted, .1), }, - EventName.driverUnresponsive3: { + EventName.driverUnresponsive: { ET.PERMANENT: Alert( "DISENGAGE IMMEDIATELY", "Driver Unresponsive", @@ -642,7 +632,7 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = { }, EventName.tooDistracted: { - ET.NO_ENTRY: too_distracted_alert, + ET.NO_ENTRY: NoEntryAlert("Distraction Level Too High"), }, EventName.excessiveActuation: { @@ -888,14 +878,14 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = { if HARDWARE.get_device_type() == 'mici': EVENTS.update({ - EventName.driverDistracted1: { + EventName.preDriverDistracted: { ET.PERMANENT: Alert( "Pay Attention", "", AlertStatus.normal, AlertSize.small, - Priority.LOW, VisualAlert.none, AudibleAlert.preAlert, 2), + Priority.LOW, VisualAlert.none, AudibleAlert.none, 2), }, - EventName.driverDistracted2: { + EventName.promptDriverDistracted: { ET.PERMANENT: Alert( "Pay Attention", "Driver Distracted", diff --git a/selfdrive/selfdrived/selfdrived.py b/selfdrive/selfdrived/selfdrived.py index 15da7cc..d533581 100755 --- a/selfdrive/selfdrived/selfdrived.py +++ b/selfdrive/selfdrived/selfdrived.py @@ -54,8 +54,6 @@ EventName = log.OnroadEvent.EventName ButtonType = car.CarState.ButtonEvent.Type SafetyModel = car.CarParams.SafetyModel TurnDirection = custom.IQTurnSignalDirection -AlertLevel = log.DriverMonitoringState.AlertLevel -MonitoringPolicy = log.DriverMonitoringState.MonitoringPolicy IGNORED_SAFETY_MODES = (SafetyModel.silent, SafetyModel.noOutput) @@ -129,6 +127,7 @@ class SelfdriveD(GapButtonActions): self.is_ldw_enabled = self.params.get_bool("IsLdwEnabled") self.disengage_on_accelerator = self.params.get_bool("DisengageOnAccelerator") self.nav_exit_lane_change = self._read_nav_exit_lane_change() + self.model_download_pending = self.params.get("ModelManager_DownloadIndex") is not None car_recognized = self.CP.brand != 'mock' @@ -149,7 +148,6 @@ class SelfdriveD(GapButtonActions): self.events_prev = [] self.logged_comm_issue = None self.not_running_prev = None - self.dm_lockout_set = False self.experimental_mode = False self.personality = get_sanitize_int_param( "LongitudinalPersonality", @@ -186,6 +184,7 @@ class SelfdriveD(GapButtonActions): self.events_iq = IQEvents() self.events_iq_prev = [] + self._cached_dm_event_names: tuple[int, ...] = () self._cached_plan_event_names: tuple[int, ...] = () self._cached_model_event_names: tuple[int, ...] = () self._cached_nav_event_names: tuple[int, ...] = () @@ -207,6 +206,10 @@ class SelfdriveD(GapButtonActions): if self.sm.updated['iqPlan']: self._cached_plan_event_names = tuple(event.name.raw for event in self._get_longitudinal_plan_ext().events) + def _refresh_cached_dm_events(self) -> None: + if self.sm.updated['driverMonitoringState']: + self._cached_dm_event_names = tuple(event.name.raw for event in self.sm['driverMonitoringState'].events) + def _refresh_cached_model_events(self) -> None: if not self.sm.updated['iqDriveModelData']: return @@ -295,24 +298,8 @@ class SelfdriveD(GapButtonActions): self.events.add(EventName.resumeBlocked) if not self.CP.notCar: - 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 - - if self.sm['driverMonitoringState'].lockout or self.sm['driverMonitoringState'].alwaysOnLockout: - self.events.add(EventName.tooDistracted) - - vision_dm = self.sm['driverMonitoringState'].activePolicy == MonitoringPolicy.vision - if self.sm['driverMonitoringState'].alertLevel == AlertLevel.one: - self.events.add(EventName.driverDistracted1 if vision_dm else EventName.driverUnresponsive1) - elif self.sm['driverMonitoringState'].alertLevel == AlertLevel.two: - self.events.add(EventName.driverDistracted2 if vision_dm else EventName.driverUnresponsive2) - elif self.sm['driverMonitoringState'].alertLevel == AlertLevel.three: - self.events.add(EventName.driverDistracted3 if vision_dm else EventName.driverUnresponsive3) - + self._refresh_cached_dm_events() + self._add_event_names(self._cached_dm_event_names) self._refresh_cached_plan_events() self._add_iq_event_names(self._cached_plan_event_names) @@ -443,6 +430,8 @@ class SelfdriveD(GapButtonActions): self.not_running_prev = not_running if self.sm.recv_frame['managerState'] and (not_running - self.ignored_processes): self.events.add(EventName.processNotRunning) + if 'iqmodeld' in not_running and self.model_download_pending: + self.events_iq.add(custom.IQOnroadEvent.EventName.modelUpdating) else: if not SIMULATION and not self.rk.lagging: if not self.sm.all_alive(self.camera_packets): @@ -756,6 +745,7 @@ class SelfdriveD(GapButtonActions): self.experimental_mode = self.params.get_bool("ExperimentalMode") and self.CP.openpilotLongitudinalControl self.personality = self.params.get("LongitudinalPersonality", return_default=True) self.nav_exit_lane_change = self._read_nav_exit_lane_change() + self.model_download_pending = self.params.get("ModelManager_DownloadIndex") is not None self.aol.read_params() time.sleep(0.1) diff --git a/selfdrive/selfdrived/tests/test_driver_monitoring.py b/selfdrive/selfdrived/tests/test_driver_monitoring.py deleted file mode 100644 index 71bf8dd..0000000 --- a/selfdrive/selfdrived/tests/test_driver_monitoring.py +++ /dev/null @@ -1,40 +0,0 @@ -from types import SimpleNamespace - -from cereal import car, log - -from openpilot.selfdrive.selfdrived.events import EVENTS, ET - - -EventName = log.OnroadEvent.EventName -AudibleAlert = car.CarControl.HUDControl.AudibleAlert - - -def test_driver_monitoring_alert_stages(): - expected_sounds = { - EventName.driverDistracted1: AudibleAlert.preAlert, - EventName.driverDistracted2: AudibleAlert.promptDistracted, - EventName.driverDistracted3: AudibleAlert.warningImmediate, - EventName.driverUnresponsive1: AudibleAlert.none, - EventName.driverUnresponsive2: AudibleAlert.promptDistracted, - EventName.driverUnresponsive3: AudibleAlert.warningImmediate, - } - - for event_name, audible_alert in expected_sounds.items(): - assert EVENTS[event_name][ET.PERMANENT].audible_alert == audible_alert - - -def test_driver_monitoring_lockout_alert(): - callback = EVENTS[EventName.tooDistracted][ET.NO_ENTRY] - sm = {'driverMonitoringState': SimpleNamespace(lockout=True, lockoutMinutesRemaining=5)} - alert = callback(None, None, sm, False, 0, None) - - assert alert.alert_text_1 == "5 minutes Left" - assert alert.alert_text_2 == "Too Distracted" - - -def test_legacy_driver_monitoring_lockout_alert(): - callback = EVENTS[EventName.tooDistracted][ET.NO_ENTRY] - sm = {'driverMonitoringState': SimpleNamespace(lockout=True, lockoutMinutesRemaining=0)} - alert = callback(None, None, sm, False, 0, None) - - assert alert.alert_text_2 == "Distraction Level Too High" diff --git a/selfdrive/test/process_replay/migration.py b/selfdrive/test/process_replay/migration.py index b135a68..010ce3f 100644 --- a/selfdrive/test/process_replay/migration.py +++ b/selfdrive/test/process_replay/migration.py @@ -455,46 +455,21 @@ def migrate_onroadEvents(msgs): return ops, [], [] -@migration(inputs=["driverMonitoringStateDEPRECATED"]) +@migration(inputs=["driverMonitoringState"]) def migrate_driverMonitoringState(msgs): ops = [] for index, msg in msgs: - old = msg.driverMonitoringStateDEPRECATED - new_msg = messaging.new_message('driverMonitoringState', valid=msg.valid, logMonoTime=msg.logMonoTime) - dm = new_msg.driverMonitoringState - dm.isRHD = old.isRHD - dm.activePolicy = log.DriverMonitoringState.MonitoringPolicy.vision if old.isActiveMode else \ - log.DriverMonitoringState.MonitoringPolicy.wheeltouch + msg = msg.as_builder() + events = [] + for event in msg.driverMonitoringState.eventsDEPRECATED: + try: + if not str(event.name).endswith('DEPRECATED'): + # dict converts name enum into string representation + events.append(log.OnroadEvent(**event.to_dict())) + except RuntimeError: # Member was null + traceback.print_exc() - AlertLevel = log.DriverMonitoringState.AlertLevel - event_to_alert_level = { - 'driverDistracted1': AlertLevel.one, 'driverUnresponsive1': AlertLevel.one, - 'driverDistracted2': AlertLevel.two, 'driverUnresponsive2': AlertLevel.two, - 'driverDistracted3': AlertLevel.three, 'driverUnresponsive3': AlertLevel.three, - } - for event in old.events: - level = event_to_alert_level.get(str(event.name)) - if level is not None: - dm.alertLevel = level - break - dm.lockout = any(str(event.name) == 'tooDistracted' for event in old.events) - - dm.visionPolicyState.awarenessPercent = int(max(0, min(100, (old.awarenessStatus if old.isActiveMode else old.awarenessActive) * 100))) - dm.visionPolicyState.awarenessStep = old.stepChange if old.isActiveMode else 0. - dm.visionPolicyState.isDistracted = old.isDistracted - dm.visionPolicyState.distractedTypes.pose = bool(old.distractedType & 1) - dm.visionPolicyState.distractedTypes.eye = bool(old.distractedType & 2) - dm.visionPolicyState.distractedTypes.phone = bool(old.distractedType & 4) - dm.visionPolicyState.faceDetected = old.faceDetected - dm.visionPolicyState.pose.pitchCalib.offset = old.posePitchOffset - dm.visionPolicyState.pose.pitchCalib.calibratedPercent = int(min(100, old.posePitchValidCount / 1200 * 100)) - dm.visionPolicyState.pose.yawCalib.offset = old.poseYawOffset - dm.visionPolicyState.pose.yawCalib.calibratedPercent = int(min(100, old.poseYawValidCount / 1200 * 100)) - dm.visionPolicyState.pose.calibrated = old.posePitchValidCount >= 1200 and old.poseYawValidCount >= 1200 - dm.visionPolicyState.wheeltouchFallbackPercent = int(min(100, old.hiStdCount / 200 * 100)) - dm.visionPolicyState.uncertainOffroadAlertPercent = int(min(100, old.uncertainCount / 1200 * 100)) - dm.wheeltouchPolicyState.awarenessPercent = int(max(0, min(100, (old.awarenessPassive if old.isActiveMode else old.awarenessStatus) * 100))) - dm.wheeltouchPolicyState.awarenessStep = 0. if old.isActiveMode else old.stepChange - ops.append((index, new_msg.as_reader())) + msg.driverMonitoringState.events = events + ops.append((index, msg.as_reader())) return ops, [], [] diff --git a/selfdrive/ui/layouts/home.py b/selfdrive/ui/layouts/home.py index 2000a01..bf910af 100644 --- a/selfdrive/ui/layouts/home.py +++ b/selfdrive/ui/layouts/home.py @@ -10,7 +10,7 @@ from openpilot.selfdrive.ui.widgets.offroad_alerts import UpdateAlert, OffroadAl from openpilot.selfdrive.ui.widgets.setup import SetupWidget from openpilot.selfdrive.ui.widgets.inspire_widget import InspireWidget from openpilot.selfdrive.ui.widgets.map_panel_widget import MapPanelWidget -from openpilot.iqpilot.ui.layouts.settings.trips import TripsLayout +from openpilot.iqpilot.ui.layouts.settings.drive_history import TripsLayout from openpilot.selfdrive.ui.layouts.sidebar import NETWORK_TYPES from openpilot.selfdrive.ui.lib.wifi_ssid import current_ssid from openpilot.selfdrive.ui.ui_state import ui_state diff --git a/selfdrive/ui/layouts/settings/toggles.py b/selfdrive/ui/layouts/settings/toggles.py index eda7e3b..69145bb 100644 --- a/selfdrive/ui/layouts/settings/toggles.py +++ b/selfdrive/ui/layouts/settings/toggles.py @@ -214,7 +214,7 @@ class TogglesLayout(Widget): toyota_stock_long_forced = bool( ui_state.CP is not None and ui_state.CP.brand == "toyota" and - self._params.get_bool("ToyotaEnforceStockLongitudinal") + self._params.get_bool("IQToyotaFactoryLong") ) iq_modes_selectable = alpha_available or alpha_requested or toyota_stock_long_forced availability_note = "" @@ -268,7 +268,7 @@ class TogglesLayout(Widget): def _apply_longitudinal_control_mode(self, button_index: int): # 0 = Stock ACC, 1 = IQ.Standard, 2 = IQ.Dynamic, 3 = IQ.Pilot previous_alpha = self._params.get_bool("AlphaLongitudinalEnabled") - previous_toyota_stock_long = self._params.get_bool("ToyotaEnforceStockLongitudinal") + previous_toyota_stock_long = self._params.get_bool("IQToyotaFactoryLong") if button_index == 0: self._params.put_bool("AlphaLongitudinalEnabled", False) @@ -289,9 +289,9 @@ class TogglesLayout(Widget): self._params.put_bool("IQDynamicMode", False) if button_index != 0 and previous_toyota_stock_long: - self._params.put_bool("ToyotaEnforceStockLongitudinal", False) + self._params.put_bool("IQToyotaFactoryLong", False) - if previous_alpha != self._params.get_bool("AlphaLongitudinalEnabled") or previous_toyota_stock_long != self._params.get_bool("ToyotaEnforceStockLongitudinal"): + if previous_alpha != self._params.get_bool("AlphaLongitudinalEnabled") or previous_toyota_stock_long != self._params.get_bool("IQToyotaFactoryLong"): self._params.put_bool("OnroadCycleRequested", True) def _toggle_callback(self, state: bool, param: str): diff --git a/selfdrive/ui/layouts/stats.py b/selfdrive/ui/layouts/stats.py index bd2861c..ea52c7f 100644 --- a/selfdrive/ui/layouts/stats.py +++ b/selfdrive/ui/layouts/stats.py @@ -1,7 +1,7 @@ import pyray as rl from collections.abc import Callable -from openpilot.iqpilot.ui.layouts.settings.trips import TripsLayout +from openpilot.iqpilot.ui.layouts.settings.drive_history import TripsLayout from openpilot.selfdrive.ui.widgets.screen_header import ScreenHeader, HEADER_HEIGHT from openpilot.system.ui.lib.multilang import tr from openpilot.system.ui.widgets import Widget diff --git a/selfdrive/ui/mici/layouts/onboarding.py b/selfdrive/ui/mici/layouts/onboarding.py index 8efcdd9..11a8154 100644 --- a/selfdrive/ui/mici/layouts/onboarding.py +++ b/selfdrive/ui/mici/layouts/onboarding.py @@ -200,7 +200,7 @@ class TrainingGuideDMTutorial(Widget): looking_center = False # stay at 100% once reached - if (dm_state.visionPolicyState.faceDetected and looking_center) or self._progress.x > 0.99: + if (dm_state.faceDetected and looking_center) or self._progress.x > 0.99: slow = self._progress.x < 0.25 duration = self.PROGRESS_DURATION * 2 if slow else self.PROGRESS_DURATION self._progress.x += 1.0 / (duration * gui_app.target_fps) diff --git a/selfdrive/ui/mici/layouts/settings/trips.py b/selfdrive/ui/mici/layouts/settings/drive_history.py similarity index 100% rename from selfdrive/ui/mici/layouts/settings/trips.py rename to selfdrive/ui/mici/layouts/settings/drive_history.py diff --git a/selfdrive/ui/mici/layouts/settings/models.py b/selfdrive/ui/mici/layouts/settings/models.py index 23fd338..86ddb98 100644 --- a/selfdrive/ui/mici/layouts/settings/models.py +++ b/selfdrive/ui/mici/layouts/settings/models.py @@ -223,7 +223,7 @@ class ModelsLayoutMici(NavScroller): @staticmethod def _read_favorites() -> set: - favs = ui_state.params.get("ModelManager_Favs") + favs = ui_state.params.get("IQModelFavorites") return set(favs.split(';')) if favs else set() def _toggle_favorite(self, bundle) -> bool: @@ -232,7 +232,7 @@ class ModelsLayoutMici(NavScroller): favs.discard(bundle.ref) else: favs.add(bundle.ref) - ui_state.params.put("ModelManager_Favs", ';'.join(sorted(favs))) + ui_state.params.put("IQModelFavorites", ';'.join(sorted(favs))) return bundle.ref in favs def _confirm_clear_cache(self): diff --git a/selfdrive/ui/mici/layouts/settings/settings.py b/selfdrive/ui/mici/layouts/settings/settings.py index 90dc4e3..a2aab7e 100644 --- a/selfdrive/ui/mici/layouts/settings/settings.py +++ b/selfdrive/ui/mici/layouts/settings/settings.py @@ -11,7 +11,7 @@ from openpilot.selfdrive.ui.mici.layouts.settings.cruise import CruiseLayoutMici from openpilot.selfdrive.ui.mici.layouts.settings.visuals import VisualsLayoutMici from openpilot.selfdrive.ui.mici.layouts.settings.models import ModelsLayoutMici from openpilot.selfdrive.ui.mici.layouts.settings.display import DisplayLayoutMici -from openpilot.selfdrive.ui.mici.layouts.settings.trips import TripsLayoutMici +from openpilot.selfdrive.ui.mici.layouts.settings.drive_history import TripsLayoutMici from openpilot.selfdrive.ui.mici.layouts.settings.vehicle import VehicleLayoutMici from openpilot.selfdrive.ui.mici.layouts.settings.dashcam import DashcamLayoutMici from openpilot.selfdrive.ui.mici.layouts.settings.network.network_layout import NetworkLayoutMici diff --git a/selfdrive/ui/mici/layouts/settings/vehicle.py b/selfdrive/ui/mici/layouts/settings/vehicle.py index be0f29d..a228155 100644 --- a/selfdrive/ui/mici/layouts/settings/vehicle.py +++ b/selfdrive/ui/mici/layouts/settings/vehicle.py @@ -69,17 +69,17 @@ class VehicleLayoutMici(NavScroller): self._vehicle_btn = BigButton("vehicle") self._vehicle_btn.set_click_callback(self._on_vehicle_clicked) - self._toyota_long = BigParamControl("enforce factory long.", "ToyotaEnforceStockLongitudinal", + self._toyota_long = BigParamControl("enforce factory long.", "IQToyotaFactoryLong", toggle_callback=self._on_toyota_long) - self._hyundai_tuning = MappedParamToggle("hyundai long. tuning", "HyundaiLongitudinalTuning", + self._hyundai_tuning = MappedParamToggle("hyundai long. tuning", "IQHyundaiLongTune", ["off", "dynamic", "predictive"], [0, 1, 2]) - self._subaru_snag = BigParamControl("creep from standstill (beta)", "SubaruStopAndGo") - self._subaru_manual = BigParamControl("stop and go manual brake", "SubaruStopAndGoManualParkingBrake") + self._subaru_snag = BigParamControl("creep from standstill (beta)", "IQSubaruCreepAssist") + self._subaru_manual = BigParamControl("stop and go manual brake", "IQSubaruCreepAssistManualBrake") self._vw_pq_hca = BigParamControl("PQ HCA status 7 mode", "pqhca5or7Toggle") self._vw_lateral = BigParamControl("lateral when cruise faulted", "AllowLateralWhenLongUnavailable") self._vw_mqb_acc_resume = BigParamControl("MQB ACC resume", "iqMqbAccResume") self._vw_mqb_steering_lockout = BigParamControl("MQB steering lockout", "iqMqbSteeringLockout") - self._tesla_vtb = BigParamControl("virtual torque blending", "TeslaCoopSteering") + self._tesla_vtb = BigParamControl("virtual torque blending", "IQTeslaTorqueBlend") self._brand_widgets = { "toyota": [self._toyota_long], diff --git a/selfdrive/ui/mici/layouts/settings/visuals.py b/selfdrive/ui/mici/layouts/settings/visuals.py index 67f7cce..35dac74 100644 --- a/selfdrive/ui/mici/layouts/settings/visuals.py +++ b/selfdrive/ui/mici/layouts/settings/visuals.py @@ -9,11 +9,11 @@ from openpilot.system.ui.widgets.scroller import NavScroller class VisualsLayoutMici(NavScroller): def __init__(self): super().__init__() - self._blind_spot = BigParamControl("Blind Spot Warnings", "BlindSpot") - self._steering_arc = BigParamControl("Steering Effort Arc", "TorqueBar") - self._road_name = BigParamControl("Road Name", "RoadNameToggle") - self._turn_signals = BigParamControl("Turn Signals", "ShowTurnSignals") - self._accel_bar = BigParamControl("Acceleration Bar", "RocketFuel") + self._blind_spot = BigParamControl("Blind Spot Warnings", "IQBlindSpotAlerts") + self._steering_arc = BigParamControl("Steering Effort Arc", "IQSteerEffortArc") + self._road_name = BigParamControl("Road Name", "IQRoadNameOverlay") + self._turn_signals = BigParamControl("Turn Signals", "IQBlinkerIndicators") + self._accel_bar = BigParamControl("Acceleration Bar", "IQAccelMeter") self._toggles = [self._blind_spot, self._steering_arc, self._road_name, self._turn_signals, self._accel_bar] diff --git a/selfdrive/ui/mici/onroad/augmented_road_view.py b/selfdrive/ui/mici/onroad/augmented_road_view.py index 0d32f6c..7ca48b1 100644 --- a/selfdrive/ui/mici/onroad/augmented_road_view.py +++ b/selfdrive/ui/mici/onroad/augmented_road_view.py @@ -29,7 +29,7 @@ from openpilot.iqpilot.ui.onroad.augmented_road_view import BORDER_COLORS_IQ if gui_app.iqpilot_ui(): from openpilot.iqpilot.ui.mici.onroad.hud_renderer import IQMiciHudRenderer as HudRenderer - from openpilot.iqpilot.ui.mici.onroad.road_name import RoadNameRendererMici + from openpilot.iqpilot.ui.mici.onroad.road_label import RoadNameRendererMici from openpilot.selfdrive.ui.ui_state import OnroadTimerStatus OpState = log.SelfdriveState.OpenpilotState diff --git a/selfdrive/ui/mici/onroad/driver_camera_dialog.py b/selfdrive/ui/mici/onroad/driver_camera_dialog.py index 1ad90a2..68ff785 100644 --- a/selfdrive/ui/mici/onroad/driver_camera_dialog.py +++ b/selfdrive/ui/mici/onroad/driver_camera_dialog.py @@ -1,14 +1,20 @@ import pyray as rl -from cereal import car, log, messaging +from cereal import log, messaging from msgq.visionipc import VisionStreamType from openpilot.selfdrive.ui.mici.onroad.cameraview import CameraView from openpilot.selfdrive.ui.mici.onroad.driver_state import DriverStateRenderer from openpilot.selfdrive.ui.ui_state import ui_state, device +from openpilot.selfdrive.selfdrived.events import EVENTS, ET from openpilot.system.ui.lib.application import gui_app, FontWeight from openpilot.system.ui.lib.multilang import tr from openpilot.system.ui.widgets.nav_widget import NavWidget from openpilot.system.ui.widgets.label import gui_label +EventName = log.OnroadEvent.EventName + +EVENT_TO_INT = EventName.schema.enumerants + + class DriverCameraView(CameraView): def _calc_frame_matrix(self, rect: rl.Rectangle): base = super()._calc_frame_matrix(rect) @@ -110,14 +116,10 @@ class DriverCameraDialog(NavWidget): return msg = messaging.new_message('selfdriveState') - if dm_state is not None: - AudibleAlert = car.CarControl.HUDControl.AudibleAlert - alert_sounds = { - 'one': AudibleAlert.preAlert, - 'two': AudibleAlert.promptDistracted, - 'three': AudibleAlert.warningImmediate, - } - msg.selfdriveState.alertSound = alert_sounds.get(str(dm_state.alertLevel), AudibleAlert.none) + if dm_state is not None and len(dm_state.events): + event_name = EVENT_TO_INT[dm_state.events[0].name] + if event_name is not None and event_name in EVENTS and ET.PERMANENT in EVENTS[event_name]: + msg.selfdriveState.alertSound = EVENTS[event_name][ET.PERMANENT].audible_alert self._pm.send('selfdriveState', msg) def _render_dm_alerts(self, rect: rl.Rectangle): @@ -125,30 +127,29 @@ class DriverCameraDialog(NavWidget): dm_state = ui_state.sm["driverMonitoringState"] self._publish_alert_sound(dm_state) - is_vision = dm_state.activePolicy == log.DriverMonitoringState.MonitoringPolicy.vision - awareness_pct = dm_state.visionPolicyState.awarenessPercent if is_vision else dm_state.wheeltouchPolicyState.awarenessPercent gui_label(rl.Rectangle(rect.x + 2, rect.y + 2, rect.width, rect.height), - f"Awareness: {awareness_pct:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM, + f"Awareness: {dm_state.awarenessStatus * 100:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM, alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT, alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP, color=rl.Color(0, 0, 0, 180)) - gui_label(rect, f"Awareness: {awareness_pct:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM, + gui_label(rect, f"Awareness: {dm_state.awarenessStatus * 100:.0f}%", font_size=44, font_weight=FontWeight.MEDIUM, alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT, alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP, color=rl.Color(255, 255, 255, int(255 * 0.9))) - if dm_state.alertLevel == log.DriverMonitoringState.AlertLevel.none: + if not dm_state.events: return - alert_level_str = f"{'Pay Attention' if is_vision else 'Touch Wheel'} - level {dm_state.alertLevel}" + # Show first event (only one should be active at a time) + event_name_str = str(dm_state.events[0].name).split('.')[-1] alignment = rl.GuiTextAlignment.TEXT_ALIGN_RIGHT if self.driver_state_renderer.is_rhd else rl.GuiTextAlignment.TEXT_ALIGN_LEFT shadow_rect = rl.Rectangle(rect.x + 2, rect.y + 2, rect.width, rect.height) - gui_label(shadow_rect, alert_level_str, font_size=40, font_weight=FontWeight.BOLD, + gui_label(shadow_rect, event_name_str, font_size=40, font_weight=FontWeight.BOLD, alignment=alignment, alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_BOTTOM, color=rl.Color(0, 0, 0, 180)) - gui_label(rect, alert_level_str, font_size=40, font_weight=FontWeight.BOLD, + gui_label(rect, event_name_str, font_size=40, font_weight=FontWeight.BOLD, alignment=alignment, alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_BOTTOM, color=rl.Color(255, 255, 255, int(255 * 0.9))) @@ -165,7 +166,7 @@ class DriverCameraDialog(NavWidget): def _draw_face_detection(self, rect: rl.Rectangle): dm_state = ui_state.sm["driverMonitoringState"] driver_data = self.driver_state_renderer.get_driver_data() - if not dm_state.visionPolicyState.faceDetected: + if not dm_state.faceDetected: return # Get face position and orientation diff --git a/selfdrive/ui/mici/onroad/driver_state.py b/selfdrive/ui/mici/onroad/driver_state.py index bd2e694..8a20137 100644 --- a/selfdrive/ui/mici/onroad/driver_state.py +++ b/selfdrive/ui/mici/onroad/driver_state.py @@ -6,12 +6,12 @@ from openpilot.common.filter_simple import FirstOrderFilter from openpilot.system.ui.lib.application import gui_app from openpilot.system.ui.widgets import Widget from openpilot.selfdrive.ui.ui_state import ui_state +from openpilot.selfdrive.monitoring.helpers import face_orientation_from_net AlertSize = log.SelfdriveState.AlertSize DEBUG = False ACTIVE_ACCENT = rl.Color(0x0C, 0x94, 0x96, 0xFF) -CONE_COLOR_ORANGE = (255, 115, 0) LOOKING_CENTER_THRESHOLD_UPPER = math.radians(6) LOOKING_CENTER_THRESHOLD_LOWER = math.radians(3) @@ -21,7 +21,6 @@ class DriverStateRenderer(Widget): BASE_SIZE = 60 LINES_ANGLE_INCREMENT = 5 LINES_STALE_ANGLES = 3.0 # seconds - AWARENESS_UNFULL_PERCENT = 95 def __init__(self, lines: bool = False, inset: bool = False): super().__init__() @@ -36,15 +35,11 @@ class DriverStateRenderer(Widget): self._is_active = False self._is_rhd = False self._face_detected = False - self._face_pitch = 0. - self._face_yaw = 0. self._should_draw = False self._force_active = False self._looking_center = False - self._awareness_unfull = False self._fade_filter = FirstOrderFilter(0.0, 0.05, 1 / gui_app.target_fps) - self._color_fade_filter = FirstOrderFilter(1.0, 0.05, 1 / gui_app.target_fps) self._pitch_filter = FirstOrderFilter(0.0, 0.05, 1 / gui_app.target_fps, initialized=False) self._yaw_filter = FirstOrderFilter(0.0, 0.05, 1 / gui_app.target_fps, initialized=False) self._rotation_filter = FirstOrderFilter(0.0, 0.1, 1 / gui_app.target_fps, initialized=False) @@ -100,7 +95,6 @@ class DriverStateRenderer(Widget): rl.Color(255, 255, 255, int(255 * 0.9 * self._fade_filter.x))) if self.effective_active: - active_amount = self._color_fade_filter.update(0.0 if self._awareness_unfull else 1.0) source_rect = rl.Rectangle(0, 0, self._dm_cone.width, self._dm_cone.height) dest_rect = rl.Rectangle( self._rect.x + self._rect.width / 2, @@ -110,16 +104,13 @@ class DriverStateRenderer(Widget): ) if not self._lines: - r = int(round(ACTIVE_ACCENT.r * active_amount + CONE_COLOR_ORANGE[0] * (1 - active_amount))) - g = int(round(ACTIVE_ACCENT.g * active_amount + CONE_COLOR_ORANGE[1] * (1 - active_amount))) - b = int(round(ACTIVE_ACCENT.b * active_amount + CONE_COLOR_ORANGE[2] * (1 - active_amount))) rl.draw_texture_pro( self._dm_cone, source_rect, dest_rect, rl.Vector2(dest_rect.width / 2, dest_rect.height / 2), self._rotation_filter.x - 90, - rl.Color(r, g, b, int(255 * self._fade_filter.x)), + rl.Color(ACTIVE_ACCENT.r, ACTIVE_ACCENT.g, ACTIVE_ACCENT.b, int(255 * self._fade_filter.x)), ) else: @@ -159,12 +150,9 @@ class DriverStateRenderer(Widget): sm = ui_state.sm dm_state = sm["driverMonitoringState"] - self._is_active = dm_state.activePolicy == log.DriverMonitoringState.MonitoringPolicy.vision + self._is_active = dm_state.isActiveMode self._is_rhd = dm_state.isRHD - self._face_detected = dm_state.visionPolicyState.faceDetected - self._awareness_unfull = self.effective_active and dm_state.visionPolicyState.awarenessPercent < self.AWARENESS_UNFULL_PERCENT - self._face_pitch = dm_state.visionPolicyState.pose.pitch + math.radians(6) - self._face_yaw = -dm_state.visionPolicyState.pose.yaw + self._face_detected = dm_state.faceDetected driverstate = sm["driverStateV2"] driver_data = driverstate.rightDriverData if self._is_rhd else driverstate.leftDriverData @@ -172,9 +160,24 @@ class DriverStateRenderer(Widget): def _update_state(self): # Get monitoring state - _ = self.get_driver_data() - pitch = self._pitch_filter.update(self._face_pitch) - yaw = self._yaw_filter.update(self._face_yaw) + driver_data = self.get_driver_data() + driver_orient = driver_data.faceOrientation + + if len(driver_orient) != 3: + return + + # Calibrate orientation so looking straight ahead at the road (instead of at the device) reads + # (0, 0), using live calibration. Makes the cone point in the correct direction. (stock PR #37149) + sm = ui_state.sm + if sm.valid['liveCalibration'] and len(sm['liveCalibration'].rpyCalib) == 3: + cal_rpy = sm['liveCalibration'].rpyCalib + else: + cal_rpy = [0.0, 0.0, 0.0] + _, pitch, yaw = face_orientation_from_net(driver_orient, driver_data.facePosition, cal_rpy) + yaw = -yaw # undo sign flip in face_orientation_from_net to match UI convention + + pitch = self._pitch_filter.update(pitch) + yaw = self._yaw_filter.update(yaw) # hysteresis on looking center if abs(pitch) < LOOKING_CENTER_THRESHOLD_LOWER and abs(yaw) < LOOKING_CENTER_THRESHOLD_LOWER: @@ -195,8 +198,9 @@ class DriverStateRenderer(Widget): rl.draw_circle(int(pitch_x), 100, 5, rl.GREEN) rl.draw_circle(int(yaw_x), 120, 5, rl.GREEN) - # filter head rotation, handling wrap-around - rotation = math.degrees(math.atan2(pitch * 2, yaw)) + # filter head rotation, handling wrap-around (bias pitch up since calib/DM pose isn't exact, + # and halve yaw sensitivity) + rotation = math.degrees(math.atan2((pitch + math.radians(6)) * 2, yaw)) angle_diff = rotation - self._rotation_filter.x angle_diff = ((angle_diff + 180) % 360) - 180 self._rotation_filter.update(self._rotation_filter.x + angle_diff) diff --git a/selfdrive/ui/onroad/driver_state.py b/selfdrive/ui/onroad/driver_state.py index e34b2c1..39aa6d1 100644 --- a/selfdrive/ui/onroad/driver_state.py +++ b/selfdrive/ui/onroad/driver_state.py @@ -114,7 +114,7 @@ class DriverStateRenderer(Widget): # Get monitoring state dm_state = sm["driverMonitoringState"] - self.is_active = dm_state.activePolicy == log.DriverMonitoringState.MonitoringPolicy.vision + self.is_active = dm_state.isActiveMode self.is_rhd = dm_state.isRHD # Update fade state (smoother transition between active/inactive) diff --git a/selfdrive/ui/onroad/model_renderer.py b/selfdrive/ui/onroad/model_renderer.py index ec10c64..df604dc 100644 --- a/selfdrive/ui/onroad/model_renderer.py +++ b/selfdrive/ui/onroad/model_renderer.py @@ -12,7 +12,7 @@ from openpilot.system.ui.lib.application import gui_app from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient from openpilot.system.ui.widgets import Widget -from openpilot.iqpilot.ui.onroad.model_renderer import ChevronMetrics, IQModelRenderer +from openpilot.iqpilot.ui.onroad.hud_overlays import ChevronMetrics from openpilot.iqpilot.ui.onroad.lead_confidence import driving_confidence CLIP_MARGIN = 500 @@ -68,10 +68,9 @@ class VisionDot: _VD_EASE = 0.4 -class ModelRenderer(Widget, IQModelRenderer): +class ModelRenderer(Widget): def __init__(self): Widget.__init__(self) - IQModelRenderer.__init__(self) self.chevron_metrics = ChevronMetrics() self._lead_orb = gui_app.texture("icons/lead_orb.png", 256, 256) self._longitudinal_control = False @@ -433,9 +432,6 @@ class ModelRenderer(Widget, IQModelRenderer): allow_throttle = sm['longitudinalPlan'].allowThrottle or not self._longitudinal_control self._blend_filter.update(int(allow_throttle)) - if ui_state.rainbow_path: - self.rainbow_path.draw_rainbow_path(self._rect, self._path) - return if self._experimental_mode: # Draw with acceleration coloring diff --git a/selfdrive/ui/soundd.py b/selfdrive/ui/soundd.py index 9d92e80..e956e73 100644 --- a/selfdrive/ui/soundd.py +++ b/selfdrive/ui/soundd.py @@ -45,28 +45,26 @@ sound_list_iq: dict[int, tuple[str, int | None, float]] = { AudibleAlertIQ.promptSingleHigh: ("prompt_single_high.wav", 1, MAX_VOLUME), } -def get_sound_list(device_type: str) -> dict[int, tuple[str, int | None, float]]: - sounds = { +sound_list: dict[int, tuple[str, int | None, float]] = { + # AudibleAlert, file name, play count (none for infinite) + AudibleAlert.engage: ("engage.wav", 1, MAX_VOLUME), + AudibleAlert.disengage: ("disengage.wav", 1, MAX_VOLUME), + AudibleAlert.refuse: ("refuse.wav", 1, MAX_VOLUME), + + AudibleAlert.prompt: ("prompt.wav", 1, MAX_VOLUME), + AudibleAlert.promptRepeat: ("prompt.wav", None, MAX_VOLUME), + AudibleAlert.promptDistracted: ("prompt_distracted.wav", None, MAX_VOLUME), + + AudibleAlert.warningSoft: ("warning_soft.wav", None, MAX_VOLUME), + AudibleAlert.warningImmediate: ("warning_immediate.wav", None, MAX_VOLUME), + + **sound_list_iq, +} +if HARDWARE.get_device_type() in ("tizi", "tici"): + sound_list.update({ AudibleAlert.engage: ("engage.wav", 1, MAX_VOLUME), AudibleAlert.disengage: ("disengage.wav", 1, MAX_VOLUME), - AudibleAlert.refuse: ("refuse.wav", 1, MAX_VOLUME), - AudibleAlert.prompt: ("prompt.wav", 1, MAX_VOLUME), - 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), - **sound_list_iq, - } - if device_type in ("tizi", "tici"): - sounds.update({ - AudibleAlert.engage: ("engage.wav", 1, MAX_VOLUME), - AudibleAlert.disengage: ("disengage.wav", 1, MAX_VOLUME), - }) - return sounds - - -sound_list = get_sound_list(HARDWARE.get_device_type()) + }) def check_selfdrive_timeout_alert(sm): ss_missing = time.monotonic() - sm.recv_time['selfdriveState'] diff --git a/selfdrive/ui/tests/test_soundd.py b/selfdrive/ui/tests/test_soundd.py index a1e18e8..a9da845 100644 --- a/selfdrive/ui/tests/test_soundd.py +++ b/selfdrive/ui/tests/test_soundd.py @@ -2,19 +2,13 @@ from cereal import car from cereal import messaging from cereal.messaging import SubMaster, PubMaster from openpilot.selfdrive.ui.soundd import SELFDRIVE_STATE_TIMEOUT, check_selfdrive_timeout_alert -from openpilot.selfdrive.ui.soundd import get_sound_list -import pytest import time AudibleAlert = car.CarControl.HUDControl.AudibleAlert class TestSoundd: - @pytest.mark.parametrize("device_type", ["mici", "tici", "tizi"]) - def test_prompt_distracted_sound(self, device_type): - assert get_sound_list(device_type)[AudibleAlert.promptDistracted][0] == "prompt_distracted.wav" - def test_check_selfdrive_timeout_alert(self): sm = SubMaster(['selfdriveState']) pm = PubMaster(['selfdriveState']) @@ -38,3 +32,4 @@ class TestSoundd: assert check_selfdrive_timeout_alert(sm) # TODO: add test with micd for checking that soundd actually outputs sounds + diff --git a/selfdrive/ui/ui_state.py b/selfdrive/ui/ui_state.py index f181763..c0cee13 100644 --- a/selfdrive/ui/ui_state.py +++ b/selfdrive/ui/ui_state.py @@ -142,15 +142,14 @@ class IQUIState: _PARAM_MIRROR = { "active_bundle": ("ModelManager_ActiveBundle", "raw"), - "blindspot": ("BlindSpot", "bool"), - "chevron_metrics": ("ChevronInfo", "raw"), + "blindspot": ("IQBlindSpotAlerts", "bool"), + "chevron_metrics": ("IQLeadReadouts", "raw"), "developer_ui": ("IQDevUIInfo", "raw"), "night_mode": ("NightMode", "bool"), - "rainbow_path": ("RainbowMode", "bool"), - "road_name_toggle": ("RoadNameToggle", "bool"), - "rocket_fuel": ("RocketFuel", "bool"), - "torque_bar": ("TorqueBar", "bool"), - "turn_signals": ("ShowTurnSignals", "bool"), + "road_name_toggle": ("IQRoadNameOverlay", "bool"), + "rocket_fuel": ("IQAccelMeter", "bool"), + "torque_bar": ("IQSteerEffortArc", "bool"), + "turn_signals": ("IQBlinkerIndicators", "bool"), "custom_interactive_timeout": ("InteractivityTimeout", "default"), "onroad_brightness_timer_param": ("OnroadScreenOffTimer", "default"), "speed_limit_mode": ("IQSpeedAssistMode", "default"), diff --git a/system/manager/process_config.py b/system/manager/process_config.py index 81518cb..8136a5e 100644 --- a/system/manager/process_config.py +++ b/system/manager/process_config.py @@ -79,7 +79,7 @@ def navrenderd_onroad(started: bool, params: Params, CP: car.CarParams) -> bool: def iqmapd_needed(params: Params) -> bool: return ( - params.get_bool("RoadNameToggle") + params.get_bool("IQRoadNameOverlay") or params.get_bool("ShowSpeedLimits") or params.get_bool("SpeedLimitController") or params.get_bool("EnableSpeedLimitControl") diff --git a/tools/iqpilot/mici_preview.py b/tools/iqpilot/mici_preview.py index d77fbf4..aef1f09 100755 --- a/tools/iqpilot/mici_preview.py +++ b/tools/iqpilot/mici_preview.py @@ -145,12 +145,12 @@ def _patch_mock_state(): mp.put("IQLaneChangeBsmDelay", False) # ── Visuals (correct param keys matching visuals.py) ───────────────────── - mp.put("BlindSpot", True) - mp.put("TorqueBar", True) - mp.put("RoadNameToggle", True) - mp.put("ShowTurnSignals", True) - mp.put("RocketFuel", False) - mp.put("ChevronInfo", 0) # 0=off + mp.put("IQBlindSpotAlerts", True) + mp.put("IQSteerEffortArc", True) + mp.put("IQRoadNameOverlay", True) + mp.put("IQBlinkerIndicators", True) + mp.put("IQAccelMeter", False) + mp.put("IQLeadReadouts", 0) # 0=off mp.put("IQDevUIInfo", 0) # 0=off mp.put("AlphaLongitudinalEnabled", False) # real param; gates ChevronInfo diff --git a/tools/sim/lib/simulated_sensors.py b/tools/sim/lib/simulated_sensors.py index 6ac7c4f..a8374a0 100644 --- a/tools/sim/lib/simulated_sensors.py +++ b/tools/sim/lib/simulated_sensors.py @@ -92,12 +92,11 @@ class SimulatedSensors: # dmonitoringd output dat = messaging.new_message('driverMonitoringState', valid=True) - dm = dat.driverMonitoringState - dm.alertLevel = log.DriverMonitoringState.AlertLevel.none - dm.activePolicy = log.DriverMonitoringState.MonitoringPolicy.vision - dm.visionPolicyState.faceDetected = True - dm.visionPolicyState.isDistracted = False - dm.visionPolicyState.awarenessPercent = 100 + dat.driverMonitoringState = { + "faceDetected": True, + "isDistracted": False, + "awarenessStatus": 1., + } self.pm.send('driverMonitoringState', dat) def send_camera_images(self, world: 'World'):