diff --git a/cereal/car.capnp b/cereal/car.capnp index 056cbf8b00..02971fda4f 100644 --- a/cereal/car.capnp +++ b/cereal/car.capnp @@ -530,14 +530,14 @@ struct CarParams { struct LateralTorqueTuning { useSteeringAngle @0 :Bool; - kp @1 :Float32; - ki @2 :Float32; - kd @8 :Float32; friction @3 :Float32; - kf @4 :Float32; steeringAngleDeadzoneDeg @5 :Float32; latAccelFactor @6 :Float32; latAccelOffset @7 :Float32; + kpDEPRECATED @1 :Float32; + kiDEPRECATED @2 :Float32; + kfDEPRECATED @4 :Float32; + kdDEPRECATED @8 : Float32; } struct LongitudinalPIDTuning { @@ -545,7 +545,7 @@ struct CarParams { kpV @1 :List(Float32); kiBP @2 :List(Float32); kiV @3 :List(Float32); - kf @6 :Float32; + kfDEPRECATED @6 :Float32; deadzoneBP @4 :List(Float32); deadzoneV @5 :List(Float32); } diff --git a/cereal/custom.capnp b/cereal/custom.capnp index 029709a266..ad587c63ac 100644 --- a/cereal/custom.capnp +++ b/cereal/custom.capnp @@ -106,10 +106,6 @@ struct FrogPilotCarParams @0xf35cc4560bbf6ec2 { openpilotLongitudinalControlDisabled @4 :Bool; safetyConfigs @5 :List(SafetyConfig); - lateralTuning :union { - pid @6 :Car.CarParams.LateralPIDTuning; - torque @7 :Car.CarParams.LateralTorqueTuning; - } struct SafetyConfig { safetyParam @0 :UInt16; diff --git a/cereal/log.capnp b/cereal/log.capnp index 54e877f2a0..8820869395 100644 --- a/cereal/log.capnp +++ b/cereal/log.capnp @@ -795,6 +795,8 @@ struct ControlsState @0x97ff69c53601abf1 { saturated @7 :Bool; actualLateralAccel @9 :Float32; desiredLateralAccel @10 :Float32; + desiredLateralJerk @11 :Float32; + version @12 :Int32; } struct LateralLQRState { diff --git a/frogpilot/assets/nnff_models/CHEVROLET_BOLT_EUV.json b/frogpilot/assets/nnff_models/CHEVROLET_BOLT_EUV.json new file mode 100644 index 0000000000..f228dcfa17 --- /dev/null +++ b/frogpilot/assets/nnff_models/CHEVROLET_BOLT_EUV.json @@ -0,0 +1 @@ +{"input_std":[[9.281861],[1.8477924],[0.7977224],[0.047467366],[1.7969038],[1.8168812],[1.8351218],[1.785757],[1.7335743],[1.6658221],[1.5893887],[0.047346078],[0.0473731],[0.047383286],[0.047291175],[0.047300573],[0.04712479],[0.046799928]],"model_test_loss":0.027355343103408813,"input_size":18,"current_date_and_time":"2023-08-05_05-11-44","input_mean":[[21.655252],[-0.07694559],[-0.006081294],[-0.007598456],[-0.07309746],[-0.075890236],[-0.07804942],[-0.076106496],[-0.07184982],[-0.06528668],[-0.060404416],[-0.0077262702],[-0.0077046235],[-0.0076850485],[-0.007687444],[-0.007708868],[-0.0077959923],[-0.008017422]],"input_vars":["v_ego","lateral_accel","lateral_jerk","roll","lateral_accel_m03","lateral_accel_m02","lateral_accel_m01","lateral_accel_p03","lateral_accel_p06","lateral_accel_p10","lateral_accel_p15","roll_m03","roll_m02","roll_m01","roll_p03","roll_p06","roll_p10","roll_p15"],"output_size":1,"layers":[{"dense_1_b":[[-0.35776415],[-0.126288],[0.007988413],[0.03850029],[-0.056796823],[0.0072075897],[0.17376427]],"dense_1_W":[[0.010538558,6.7293744,-0.007391298,-1.035045,-0.47446147,1.0940393,0.08225446,-0.5795131,0.573115,1.82923,-0.16999252,0.8818023,0.03560901,-0.9470653,-1.042151,1.1532398,1.9009485,-1.2265956],[0.009010456,-1.3618345,0.039026346,0.22943486,-0.6669799,-0.768271,-0.16828564,-0.13406865,0.19760236,-0.18953702,-0.019137766,0.1468623,0.26367718,0.4732375,0.73679143,0.62450147,0.30198866,-0.93340015],[-0.044318866,2.2138615,9.620889,-0.66480356,-0.06849887,-0.038568456,-0.30580127,-0.088089585,0.31187677,0.5968372,-1.1462088,0.13234706,0.29166338,-0.69978577,-0.01790655,-0.097928315,-0.56950736,0.7560642],[1.3758256,0.8700429,-0.24295154,0.20832618,-0.7735097,1.0379355,-0.60753095,-0.5457418,-1.0892137,-0.6708325,0.24982774,0.09251328,0.08596103,-0.58034134,-0.3046114,-0.19754426,0.006461508,0.5989185],[0.06314328,-2.492993,-0.28200585,0.49902886,0.8513198,-0.5704965,1.0960953,-0.08426956,-0.76074624,0.10669376,0.02775254,-0.42194095,-0.34657434,-0.10863868,0.17019278,0.0963825,-0.10169116,0.21243806],[0.007984091,-1.9276509,-0.0013926353,0.04057924,1.4438432,1.3440262,-2.506722,1.700801,0.72410774,0.13471895,-0.18753268,0.7303607,0.018133093,-0.71643597,0.07050904,-0.30161944,0.085108586,0.061202843],[0.9413167,-0.9954305,-0.19510143,-0.4711845,-0.12398665,-0.45175523,1.0616771,0.28550953,-0.55543137,-0.21576759,-0.2364377,-0.012782618,-0.050565187,0.257694,-0.20975965,0.00022543047,-0.08760746,0.4983852]],"activation":"σ"},{"dense_2_W":[[-0.71804935,0.017023304,-0.099854074,-0.3262651,-0.402829,-0.12073083,0.13537839],[-0.44002575,-0.1071093,-0.58886194,-0.17319413,-0.21134079,0.23135148,0.0006880979],[-0.55711204,-0.8693639,-0.6443761,-0.7382846,0.18980889,-0.6082511,-0.63103676],[0.11338112,-0.5327033,0.2856197,0.32239884,-0.72682667,0.5302305,-0.45094746],[-0.35197002,-0.14440043,-0.025249843,-0.48697743,0.3340018,-0.25992322,0.0050561456],[0.34757507,0.15670523,-0.14263277,0.50704384,-0.020171141,0.6408679,-0.3074123],[0.40258837,-0.59363264,0.35948923,-0.060853776,-0.0072541097,0.89743376,-0.49789146],[-0.63476,0.29580453,0.1689314,-0.5061521,0.24901053,-0.23218995,0.57968193],[-0.66173035,0.50861925,-0.5845035,-0.6602214,0.8341883,-0.31437424,0.8046359],[0.038493533,0.15464582,-0.04848341,-0.57820857,-0.25891733,-0.47527292,0.21441916],[-0.15464531,-0.07454202,-0.8215851,-0.12614948,-0.5924209,0.00017916794,0.24154592],[0.6091424,-0.112086505,0.1144111,-0.31035227,-0.9237534,0.041003596,-0.3542808],[0.2989792,-0.23780549,0.116059326,-0.6056522,0.5499526,-0.9001413,0.5200723]],"activation":"σ","dense_2_b":[[-0.2638964],[-0.24607328],[-0.15493082],[-0.0071187904],[-0.23515384],[-0.09098133],[-0.034066215],[0.03609036],[-0.03842933],[-0.042302527],[-0.2439947],[-0.16342077],[-0.01030317]]},{"dense_3_W":[[0.45771673,-0.2084603,0.3570187,0.35835707,0.13684571,-0.582958,0.29889587,0.43543494,0.11841301,-0.26185623,-0.4988437,0.5752996,-0.28057483],[-0.19594137,0.050280698,-0.29057446,-0.2829161,-0.16987291,-0.21278952,-0.59946907,0.21295123,0.7040468,0.53549695,-0.52553934,-0.19560973,0.6233473],[-0.19091003,0.08669418,-0.5792192,0.57799137,-0.36263424,0.6037143,0.27898273,-0.30951327,-0.3572644,0.46720102,-0.5403428,0.32415462,-0.60570025]],"activation":"identity","dense_3_b":[[-0.0047377176],[0.023170695],[-0.021546118]]},{"dense_4_W":[[-0.12453941,-1.006034,0.96776205]],"dense_4_b":[[-0.02351544]],"activation":"identity"}]} \ No newline at end of file diff --git a/frogpilot/common/frogpilot_utilities.py b/frogpilot/common/frogpilot_utilities.py index 72ebb0b4c0..9f722438db 100644 --- a/frogpilot/common/frogpilot_utilities.py +++ b/frogpilot/common/frogpilot_utilities.py @@ -296,12 +296,12 @@ def update_openpilot(): if params.get("UpdaterState", encoding="utf-8") != "idle": return - while params.get_bool("IsOnroad") or params_memory.get_bool("UpdateSpeedLimits") or running_threads.get("lock_doors", threading.Thread()).is_alive(): - time.sleep(60) - if not update_available(): return + while params.get_bool("IsOnroad") or params_memory.get_bool("UpdateSpeedLimits") or running_threads.get("lock_doors", threading.Thread()).is_alive(): + time.sleep(60) + while True: if not update_available(): break diff --git a/frogpilot/common/frogpilot_variables.py b/frogpilot/common/frogpilot_variables.py index 3c072c2d5a..25005724f6 100644 --- a/frogpilot/common/frogpilot_variables.py +++ b/frogpilot/common/frogpilot_variables.py @@ -19,6 +19,7 @@ from openpilot.selfdrive.car.mock.interface import CarInterface from openpilot.selfdrive.car.mock.values import CAR as MOCK from openpilot.selfdrive.car.toyota.values import ToyotaFlags, ToyotaFrogPilotFlags from openpilot.selfdrive.controls.lib.desire_helper import LANE_CHANGE_SPEED_MIN +from openpilot.selfdrive.controls.lib.latcontrol_torque import KP from openpilot.selfdrive.modeld.constants import ModelConstants from openpilot.system.hardware import HARDWARE from openpilot.system.hardware.power_monitoring import VBATT_PAUSE_CHARGING @@ -531,6 +532,10 @@ class FrogPilotVariables: safety_config.safetyModel = car.CarParams.SafetyModel.noOutput CP.safetyConfigs = [safety_config] + is_torque_car = CP.lateralTuning.which() == "torque" + if not is_torque_car: + CarInterfaceBase.configure_torque_tune(MOCK.MOCK, CP.lateralTuning) + fpmsg_bytes = params.get("FrogPilotCarParams" if started else "FrogPilotCarParamsPersistent", block=started) if fpmsg_bytes: with custom.FrogPilotCarParams.from_bytes(fpmsg_bytes) as fpcp_reader: @@ -539,17 +544,13 @@ class FrogPilotVariables: CarInterface, _, _ = interfaces[MOCK.MOCK] FPCP = CarInterface.get_frogpilot_params(MOCK.MOCK, gen_empty_fingerprint(), [], CP, toggle) - is_torque_car = FPCP.lateralTuning.which() == "torque" - if not is_torque_car: - CarInterfaceBase.configure_torque_tune(MOCK.MOCK, FPCP.lateralTuning) - toggle.always_on_lateral_set = bool(CP.alternativeExperience & ALTERNATIVE_EXPERIENCE.ALWAYS_ON_LATERAL) toggle.car_make = CP.carName toggle.car_model = CP.carFingerprint toggle.disable_openpilot_long = params.get_bool("DisableOpenpilotLongitudinal") if tuning_level >= level["DisableOpenpilotLongitudinal"] else default.get_bool("DisableOpenpilotLongitudinal") - friction = FPCP.lateralTuning.torque.friction - has_auto_tune = toggle.car_make in {"hyundai", "toyota"} and FPCP.lateralTuning.which() == "torque" + friction = CP.lateralTuning.torque.friction + has_auto_tune = toggle.car_make in {"hyundai", "toyota"} and CP.lateralTuning.which() == "torque" has_bsm = CP.enableBsm toggle.has_cc_long = toggle.car_make == "gm" and bool(CP.flags & GMFlags.CC_LONG.value) has_nnff = nnff_supported(toggle.car_model) @@ -559,14 +560,14 @@ class FrogPilotVariables: has_sng = CP.autoResumeSng toggle.has_zss = toggle.car_make == "toyota" and bool(FPCP.fpFlags & ToyotaFrogPilotFlags.ZSS.value) is_angle_car = CP.steerControlType == car.CarParams.SteerControlType.angle - latAccelFactor = FPCP.lateralTuning.torque.latAccelFactor + latAccelFactor = CP.lateralTuning.torque.latAccelFactor longitudinalActuatorDelay = CP.longitudinalActuatorDelay toggle.openpilot_longitudinal = CP.openpilotLongitudinalControl and not toggle.disable_openpilot_long pcm_cruise = CP.pcmCruise startAccel = CP.startAccel stopAccel = CP.stopAccel steerActuatorDelay = CP.steerActuatorDelay - steerKp = FPCP.lateralTuning.torque.kp + steerKp = CP.lateralTuning.pid.kp if CP.lateralTuning.which() == "pid" else KP steerRatio = CP.steerRatio toggle.stoppingDecelRate = CP.stoppingDecelRate taco_hacks_allowed = CP.safetyConfigs[0].safetyModel == SafetyModel.hyundaiCanfd diff --git a/frogpilot/controls/frogpilot_planner.py b/frogpilot/controls/frogpilot_planner.py index d0b854778b..5c2047b21f 100644 --- a/frogpilot/controls/frogpilot_planner.py +++ b/frogpilot/controls/frogpilot_planner.py @@ -32,7 +32,6 @@ class FrogPilotPlanner: self.tracking_lead_filter = FirstOrderFilter(0, 0.5, DT_MDL) - self.disable_throttle = False self.driving_in_curve = False self.lateral_check = False self.model_stopped = False @@ -66,9 +65,6 @@ class FrogPilotPlanner: self.cem.curve_detected = False self.cem.stop_sign_and_light(v_ego, sm, PLANNER_TIME - 2) - self.disable_throttle = self.tracking_lead and not self.frogpilot_following.following_lead - self.disable_throttle &= self.lead_one.vLead + COMFORT_BRAKE < v_ego > CRUISING_SPEED - self.disable_throttle &= sm["controlsState"].enabled self.driving_in_curve = abs(self.lateral_acceleration) >= MINIMUM_LATERAL_ACCELERATION @@ -146,7 +142,7 @@ class FrogPilotPlanner: frogpilotPlan.desiredFollowDistance = self.frogpilot_following.desired_follow_distance - frogpilotPlan.disableThrottle = self.disable_throttle + frogpilotPlan.disableThrottle = self.frogpilot_following.disable_throttle frogpilotPlan.experimentalMode = self.cem.experimental_mode or self.frogpilot_vcruise.slc.experimental_mode diff --git a/frogpilot/controls/lib/frogpilot_following.py b/frogpilot/controls/lib/frogpilot_following.py index 8aefa244db..072fcc7ab9 100644 --- a/frogpilot/controls/lib/frogpilot_following.py +++ b/frogpilot/controls/lib/frogpilot_following.py @@ -11,6 +11,7 @@ class FrogPilotFollowing: def __init__(self, FrogPilotPlanner): self.frogpilot_planner = FrogPilotPlanner + self.disable_throttle = False self.following_lead = False self.slower_lead = False @@ -63,7 +64,12 @@ class FrogPilotFollowing: self.danger_jerk = self.base_danger_jerk self.speed_jerk = self.base_speed_jerk - self.following_lead = self.frogpilot_planner.tracking_lead and self.frogpilot_planner.lead_one.dRel < (self.t_follow + 1) * v_ego + self.following_lead = self.frogpilot_planner.tracking_lead and self.frogpilot_planner.lead_one.dRel < (self.t_follow * 2) * v_ego + + + self.disable_throttle = self.frogpilot_planner.tracking_lead and not self.following_lead + self.disable_throttle &= self.frogpilot_planner.lead_one.dRel + 6.0 < (self.t_follow * 2 * 2) * v_ego + self.disable_throttle &= self.frogpilot_planner.lead_one.vLead < v_ego * 0.75 if sm["controlsState"].enabled and self.frogpilot_planner.tracking_lead: self.update_follow_values(self.frogpilot_planner.lead_one.dRel, v_ego, self.frogpilot_planner.lead_one.vLead, frogpilot_toggles) diff --git a/frogpilot/controls/lib/neural_network_feedforward.py b/frogpilot/controls/lib/neural_network_feedforward.py index d2dcf99edb..a882e6a97d 100644 --- a/frogpilot/controls/lib/neural_network_feedforward.py +++ b/frogpilot/controls/lib/neural_network_feedforward.py @@ -1,16 +1,21 @@ #!/usr/bin/env python3 -# Twilsonco's Lateral Neural Network Feedforward -from collections import deque -from difflib import SequenceMatcher - +# Twilsonco's Lateral Neural Network Feedforward Controller import json import math import numpy as np import os +from collections import deque +from difflib import SequenceMatcher +from cereal import log from openpilot.common.filter_simple import FirstOrderFilter from openpilot.common.numpy_fast import interp +from openpilot.common.params import Params from openpilot.selfdrive.controls.lib.drive_helpers import CONTROL_N +from openpilot.selfdrive.controls.lib.latcontrol import LatControl +from openpilot.selfdrive.controls.lib.latcontrol_torque import KD, KI, KP +from openpilot.selfdrive.controls.lib.pid import PIDController +from openpilot.selfdrive.controls.lib.vehicle_model import ACCELERATION_DUE_TO_GRAVITY from openpilot.selfdrive.modeld.constants import ModelConstants from openpilot.frogpilot.common.frogpilot_variables import NNFF_MODELS_PATH, get_nnff_model_files, params @@ -29,8 +34,8 @@ from openpilot.frogpilot.common.frogpilot_variables import NNFF_MODELS_PATH, get # dict used to rename activation functions whose names aren't valid python identifiers ACTIVATION_FUNCTION_NAMES = {'σ': 'sigmoid'} -LOW_SPEED_Y_NN = [12, 3, 1, 0] - +LOW_SPEED_X = [0, 10, 20, 30] +LOW_SPEED_Y = [12, 3, 1, 0] LAT_PLAN_MIN_IDX = 5 @@ -40,6 +45,7 @@ class FluxModel: params = json.load(f) self.input_size = params["input_size"] + self.output_size = params["output_size"] self.input_mean = np.array(params["input_mean"], dtype=np.float32).T self.input_std = np.array(params["input_std"], dtype=np.float32).T @@ -123,7 +129,7 @@ def get_nn_model_path(car, eps_firmware) -> str | None: def find_valid_model(*queries): for query in queries: path, score = best_model_path(query) - if path and car in path and score >= 0.9: + if path and candidate in path and score >= 0.9: return path return None @@ -149,16 +155,18 @@ def sign(x): def similarity(s1: str, s2: str) -> float: return SequenceMatcher(None, s1, s2).ratio() - -class NeuralNetworkFeedforward: - def __init__(self, CP, LatControlTorque): - self.lat_control_torque = LatControlTorque - +class LatControlNNFF(LatControl): + def __init__(self, CP, CI, dt): + super().__init__(CP, CI, dt) self.lat_torque_nn_model = get_nn_model(CP.carFingerprint, str(next((fw.fwVersion for fw in CP.carFw if fw.ecu == "eps"), "")).replace("\\", "")) + self.nnff_loaded = self.lat_torque_nn_model is not None - self.torque_from_lateral_accel = self.lat_control_torque.torque_from_lateral_accel - - self.use_steering_angle = self.lat_control_torque.torque_params.useSteeringAngle + self.torque_params = CP.lateralTuning.torque + self.pid = PIDController(KP, KI, k_d=KD, + pos_limit=self.steer_max, neg_limit=-self.steer_max) + self.torque_from_lateral_accel = CI.torque_from_lateral_accel() + self.use_steering_angle = self.torque_params.useSteeringAngle + self.steering_angle_deadzone_deg = self.torque_params.steeringAngleDeadzoneDeg # Instantaneous lateral jerk changes very rapidly, making it not useful on its own, # however, we can "look ahead" to the future planned lateral jerk in order to gauge @@ -176,7 +184,6 @@ class NeuralNetworkFeedforward: self.lat_jerk_friction_factor = 0.4 # precompute time differences between ModelConstants.T_IDXS - self.lateral_delay = CP.steerActuatorDelay self.t_diffs = np.diff(ModelConstants.T_IDXS) self.pitch = FirstOrderFilter(0.0, 0.5, 0.01) @@ -188,7 +195,7 @@ class NeuralNetworkFeedforward: # setup future time offsets self.future_times = [0.3, 0.6, 1.0, 1.5] # seconds in the future - self.nn_future_times = [time + self.lateral_delay for time in self.future_times] + self.nn_future_times = [time + CP.steerActuatorDelay for time in self.future_times] # setup past time offsets self.past_times = [-0.3, -0.2, -0.1] @@ -199,95 +206,150 @@ class NeuralNetworkFeedforward: self.roll_deque = deque(maxlen=history_check_frames[0]) def update_live_delay(self, lateral_delay): - self.lateral_delay = lateral_delay - - self.nn_future_times = [time + self.lateral_delay for time in self.future_times] + self.nn_future_times = [time + lateral_delay for time in self.future_times] self.past_future_len = len(self.past_times) + len(self.nn_future_times) - def compute_nnff(self, CS, VM, actual_lateral_accel, future_desired_lateral_accel, error, gravity_adjusted_future_lateral_accel, llk, measurement, model_data, params, pid_log, setpoint, frogpilot_toggles): - if self.use_steering_angle: - actual_curvature_rate = -VM.calc_curvature(math.radians(CS.steeringRateDeg), CS.vEgo, 0.0) - actual_lateral_jerk = actual_curvature_rate * CS.vEgo ** 2 + def update_live_torque_params(self, latAccelFactor, latAccelOffset, friction): + self.torque_params.latAccelFactor = latAccelFactor + self.torque_params.latAccelOffset = latAccelOffset + self.torque_params.friction = friction + + def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, curvature_limited, lat_delay, llk, model_data, frogpilot_toggles): + pid_log = log.ControlsState.LateralTorqueState.new_message() + if not active: + output_torque = 0.0 + pid_log.active = False else: - actual_lateral_jerk = 0.0 + actual_curvature_vm = -VM.calc_curvature(math.radians(CS.steeringAngleDeg - params.angleOffsetDeg), CS.vEgo, params.roll) + roll_compensation = params.roll * ACCELERATION_DUE_TO_GRAVITY + if self.use_steering_angle: + actual_curvature = actual_curvature_vm + curvature_deadzone = abs(VM.calc_curvature(math.radians(self.steering_angle_deadzone_deg), CS.vEgo, 0.0)) + else: + actual_curvature_llk = llk.angularVelocityCalibrated.value[2] / CS.vEgo + actual_curvature = interp(CS.vEgo, [2.0, 5.0], [actual_curvature_vm, actual_curvature_llk]) + curvature_deadzone = 0.0 + desired_lateral_accel = desired_curvature * CS.vEgo ** 2 - model_good = model_data is not None and len(model_data.orientation.x) >= CONTROL_N + # desired rate is the desired rate of change in the setpoint, not the absolute desired curvature + # desired_lateral_jerk = desired_curvature_rate * CS.vEgo ** 2 + actual_lateral_accel = actual_curvature * CS.vEgo ** 2 + lateral_accel_deadzone = curvature_deadzone * CS.vEgo ** 2 - if model_good: - # prepare "look-ahead" desired lateral jerk - lookahead = interp(CS.vEgo, self.friction_look_ahead_bp, self.friction_look_ahead_v) - friction_upper_idx = next((idxs for idxs, value in enumerate(ModelConstants.T_IDXS) if value > lookahead), 16) + low_speed_factor = interp(CS.vEgo, LOW_SPEED_X, LOW_SPEED_Y)**2 + setpoint = desired_lateral_accel + low_speed_factor * desired_curvature + measurement = actual_lateral_accel + low_speed_factor * actual_curvature + gravity_adjusted_lateral_accel = desired_lateral_accel - roll_compensation + if self.nnff_loaded and frogpilot_toggles.nnff or frogpilot_toggles.nnff_lite: + if self.use_steering_angle: + actual_curvature_rate = -VM.calc_curvature(math.radians(CS.steeringRateDeg), CS.vEgo, 0.0) + actual_lateral_jerk = actual_curvature_rate * CS.vEgo ** 2 + else: + actual_lateral_jerk = 0.0 - predicted_lateral_jerk = get_predicted_lateral_jerk(model_data.acceleration.y, self.t_diffs) - desired_lateral_jerk = (interp(self.lateral_delay, ModelConstants.T_IDXS, model_data.acceleration.y) - future_desired_lateral_accel) / self.lateral_delay + model_good = model_data is not None and len(model_data.orientation.x) >= CONTROL_N - lookahead_lateral_jerk = get_lookahead_value(predicted_lateral_jerk[LAT_PLAN_MIN_IDX:friction_upper_idx], desired_lateral_jerk) + if model_good: + # prepare "look-ahead" desired lateral jerk + lookahead = interp(CS.vEgo, self.friction_look_ahead_bp, self.friction_look_ahead_v) + friction_upper_idx = next((idxs for idxs, value in enumerate(ModelConstants.T_IDXS) if value > lookahead), 16) - if not self.use_steering_angle or lookahead_lateral_jerk == 0.0: - lookahead_lateral_jerk = 0.0 - actual_lateral_jerk = 0.0 - self.lat_accel_friction_factor = 1.0 + predicted_lateral_jerk = get_predicted_lateral_jerk(model_data.acceleration.y, self.t_diffs) + desired_lateral_jerk = (interp(lat_delay, ModelConstants.T_IDXS, model_data.acceleration.y) - desired_lateral_accel) / lat_delay - lateral_jerk_setpoint = self.lat_jerk_friction_factor * lookahead_lateral_jerk - lateral_jerk_measurement = self.lat_jerk_friction_factor * actual_lateral_jerk - else: - lateral_jerk_setpoint = 0 - lateral_jerk_measurement = 0 - lookahead_lateral_jerk = 0 + lookahead_lateral_jerk = get_lookahead_value(predicted_lateral_jerk[LAT_PLAN_MIN_IDX:friction_upper_idx], desired_lateral_jerk) - if self.lat_control_torque.nnff_loaded and model_good and frogpilot_toggles.nnff: - # update past data - pitch = 0 - roll = params.roll - if len(llk.calibratedOrientationNED.value) > 1: - pitch = self.pitch.update(llk.calibratedOrientationNED.value[1]) - roll = roll_pitch_adjust(roll, pitch) + if not self.use_steering_angle or lookahead_lateral_jerk == 0.0: + lookahead_lateral_jerk = 0.0 + actual_lateral_jerk = 0.0 + self.lat_accel_friction_factor = 1.0 - self.roll_deque.append(roll) - self.lateral_accel_desired_deque.append(future_desired_lateral_accel) + lateral_jerk_setpoint = self.lat_jerk_friction_factor * lookahead_lateral_jerk + lateral_jerk_measurement = self.lat_jerk_friction_factor * actual_lateral_jerk + else: + lateral_jerk_setpoint = 0 + lateral_jerk_measurement = 0 + lookahead_lateral_jerk = 0 - # prepare past and future values - # adjust future times to account for longitudinal acceleration - adjusted_future_times = [time + 0.5 * CS.aEgo * (time / max(CS.vEgo, 1.0)) for time in self.nn_future_times] - past_rolls = [self.roll_deque[min(len(self.roll_deque)-1, offset)] for offset in self.history_frame_offsets] - future_rolls = [roll_pitch_adjust(interp(time, ModelConstants.T_IDXS, model_data.orientation.x) + roll, interp(time, ModelConstants.T_IDXS, model_data.orientation.y) + pitch) for time in adjusted_future_times] + if self.nnff_loaded and model_good and frogpilot_toggles.nnff: + # update past data + pitch = 0 + roll = params.roll + if len(llk.calibratedOrientationNED.value) > 1: + pitch = self.pitch.update(llk.calibratedOrientationNED.value[1]) + roll = roll_pitch_adjust(roll, pitch) - past_lateral_accels_desired = [self.lateral_accel_desired_deque[min(len(self.lateral_accel_desired_deque)-1, offset)] for offset in self.history_frame_offsets] - future_lateral_accels = [interp(time, ModelConstants.T_IDXS[:CONTROL_N], model_data.acceleration.y) for time in adjusted_future_times] + self.roll_deque.append(roll) + self.lateral_accel_desired_deque.append(desired_lateral_accel) - base_input = [CS.vEgo, roll] - nnff_common = past_rolls + future_rolls + # prepare past and future values + # adjust future times to account for longitudinal acceleration + adjusted_future_times = [time + 0.5 * CS.aEgo * (time / max(CS.vEgo, 1.0)) for time in self.nn_future_times] + past_rolls = [self.roll_deque[min(len(self.roll_deque)-1, offset)] for offset in self.history_frame_offsets] + future_rolls = [roll_pitch_adjust(interp(time, ModelConstants.T_IDXS, model_data.orientation.x) + roll, interp(time, ModelConstants.T_IDXS, model_data.orientation.y) + pitch) for time in adjusted_future_times] - # compute NNFF error response - nnff_setpoint_input = base_input[:1] + [setpoint, lateral_jerk_setpoint] + base_input[1:] + [setpoint] * self.past_future_len + nnff_common - nnff_measurement_input = base_input[:1] + [measurement, lateral_jerk_measurement] + base_input[1:] + [measurement] * self.past_future_len + nnff_common + past_lateral_accels_desired = [self.lateral_accel_desired_deque[min(len(self.lateral_accel_desired_deque)-1, offset)] for offset in self.history_frame_offsets] + future_lateral_accels = [interp(time, ModelConstants.T_IDXS[:CONTROL_N], model_data.acceleration.y) for time in adjusted_future_times] - torque_from_setpoint = self.lat_torque_nn_model.evaluate(nnff_setpoint_input) - torque_from_measurement = self.lat_torque_nn_model.evaluate(nnff_measurement_input) + base_input = [CS.vEgo, roll] + nnff_common = past_rolls + future_rolls - pid_log.error = torque_from_setpoint - torque_from_measurement + # compute NNFF error response + nnff_setpoint_input = base_input[:1] + [setpoint, lateral_jerk_setpoint] + base_input[1:] + [setpoint] * self.past_future_len + nnff_common + nnff_measurement_input = base_input[:1] + [measurement, lateral_jerk_measurement] + base_input[1:] + [measurement] * self.past_future_len + nnff_common - error_blend = interp(abs(future_desired_lateral_accel), [1.0, 2.0], [0.0, 1.0]) - if error_blend > 0.0: # blend in stronger error response when in high lat accel - torque_from_error = self.lat_torque_nn_model.evaluate([CS.vEgo, setpoint - measurement, lateral_jerk_setpoint - lateral_jerk_measurement, 0.0]) - if sign(pid_log.error) == sign(torque_from_error) and abs(pid_log.error) < abs(torque_from_error): - pid_log.error = pid_log.error * (1.0 - error_blend) + torque_from_error * error_blend + torque_from_setpoint = self.lat_torque_nn_model.evaluate(nnff_setpoint_input) + torque_from_measurement = self.lat_torque_nn_model.evaluate(nnff_measurement_input) - # compute feedforward (same as nn setpoint output) - friction_input = self.lat_accel_friction_factor * error + self.lat_jerk_friction_factor * lookahead_lateral_jerk - nn_input = [CS.vEgo, future_desired_lateral_accel, friction_input, roll] + past_lateral_accels_desired + future_lateral_accels + nnff_common - ff = self.lat_torque_nn_model.evaluate(nn_input) + pid_log.error = torque_from_setpoint - torque_from_measurement - # apply friction override for cars with low NN friction response - if self.nn_friction_override: - pid_log.error += self.torque_from_lateral_accel(0.0, self.lat_control_torque.torque_params) - else: - torque_from_measurement = self.torque_from_lateral_accel(measurement, self.lat_control_torque.torque_params) - torque_from_setpoint = self.torque_from_lateral_accel(setpoint, self.lat_control_torque.torque_params) + error_blend = interp(abs(desired_lateral_accel), [1.0, 2.0], [0.0, 1.0]) + if error_blend > 0.0: # blend in stronger error response when in high lat accel + torque_from_error = self.lat_torque_nn_model.evaluate([CS.vEgo, setpoint - measurement, lateral_jerk_setpoint - lateral_jerk_measurement, 0.0]) + if sign(pid_log.error) == sign(torque_from_error) and abs(pid_log.error) < abs(torque_from_error): + pid_log.error = pid_log.error * (1.0 - error_blend) + torque_from_error * error_blend - pid_log.error = float(torque_from_setpoint - torque_from_measurement) + # compute feedforward (same as nn setpoint output) + error = setpoint - measurement + friction_input = self.lat_accel_friction_factor * error + self.lat_jerk_friction_factor * lookahead_lateral_jerk + nn_input = [CS.vEgo, desired_lateral_accel, friction_input, roll] + past_lateral_accels_desired + future_lateral_accels + nnff_common + ff = self.lat_torque_nn_model.evaluate(nn_input) - friction_input = self.lat_accel_friction_factor * error + self.lat_jerk_friction_factor * lookahead_lateral_jerk - ff = self.torque_from_lateral_accel(gravity_adjusted_future_lateral_accel, self.lat_control_torque.torque_params) + # apply friction override for cars with low NN friction response + if self.nn_friction_override: + pid_log.error += self.torque_from_lateral_accel(0.0, self.torque_params) + else: + torque_from_measurement = self.torque_from_lateral_accel(measurement, self.torque_params) + torque_from_setpoint = self.torque_from_lateral_accel(setpoint, self.torque_params) - return pid_log, ff + pid_log.error = float(torque_from_setpoint - torque_from_measurement) + + error = desired_lateral_accel - actual_lateral_accel + friction_input = self.lat_accel_friction_factor * error + self.lat_jerk_friction_factor * lookahead_lateral_jerk + ff = self.torque_from_lateral_accel(gravity_adjusted_lateral_accel, self.torque_params) + else: + torque_from_measurement = self.torque_from_lateral_accel(measurement, self.torque_params) + torque_from_setpoint = self.torque_from_lateral_accel(setpoint, self.torque_params) + + pid_log.error = float(torque_from_setpoint - torque_from_measurement) + + ff = self.torque_from_lateral_accel(gravity_adjusted_lateral_accel, self.torque_params) + + freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5 + output_torque = self.pid.update(pid_log.error, + feedforward=ff, + speed=CS.vEgo, + freeze_integrator=freeze_integrator) + + pid_log.active = True + pid_log.p = float(self.pid.p) + pid_log.i = float(self.pid.i) + pid_log.d = float(self.pid.d) + pid_log.f = float(self.pid.f) + pid_log.output = float(-output_torque) + pid_log.actualLateralAccel = float(actual_lateral_accel) + pid_log.desiredLateralAccel = float(desired_lateral_accel) + pid_log.saturated = bool(self._check_saturation(self.steer_max - abs(output_torque) < 1e-3, CS, steer_limited_by_safety, curvature_limited)) + + # TODO left is positive in this convention + return -output_torque, 0.0, pid_log diff --git a/frogpilot/system/environment_variables b/frogpilot/system/environment_variables old mode 100755 new mode 100644 index 6bf4f6a8fb..0e968181e7 Binary files a/frogpilot/system/environment_variables and b/frogpilot/system/environment_variables differ diff --git a/frogpilot/ui/qt/offroad/frogpilot_settings.cc b/frogpilot/ui/qt/offroad/frogpilot_settings.cc index 64dc5cfb19..2ce9a4e1d4 100644 --- a/frogpilot/ui/qt/offroad/frogpilot_settings.cc +++ b/frogpilot/ui/qt/offroad/frogpilot_settings.cc @@ -277,17 +277,21 @@ void FrogPilotSettingsWindow::updateVariables() { isHKG = carMake == "hyundai"; isHKGCanFd = isHKG && safetyModel == cereal::CarParams::SafetyModel::HYUNDAI_CANFD; isSubaru = carMake == "subaru"; + isTorqueCar = CP.getLateralTuning().which() == cereal::CarParams::LateralTuning::TORQUE; isToyota = carMake == "toyota"; isTSK = CP.getSecOcRequired(); isVolt = carFingerprint == "CHEVROLET_VOLT"; longitudinalActuatorDelay = CP.getLongitudinalActuatorDelay(); startAccel = CP.getStartAccel(); steerActuatorDelay = CP.getSteerActuatorDelay(); + steerKp = CP.getLateralTuning().which() == cereal::CarParams::LateralTuning::PID ? CP.getLateralTuning().getPid().getKpV()[0] : 0.6; steerRatio = CP.getSteerRatio(); stopAccel = CP.getStopAccel(); stoppingDecelRate = CP.getStoppingDecelRate(); vEgoStarting = CP.getVEgoStarting(); vEgoStopping = CP.getVEgoStopping(); + friction = CP.getLateralTuning().getTorque().getFriction(); + latAccelFactor = CP.getLateralTuning().getTorque().getLatAccelFactor(); float currentDelayStock = params.getFloat("SteerDelayStock"); float currentFrictionStock = params.getFloat("SteerFrictionStock"); @@ -387,12 +391,17 @@ void FrogPilotSettingsWindow::updateVariables() { canUsePedal = FPCP.getCanUsePedal(); canUseSDSU = FPCP.getCanUseSDSU(); - friction = FPCP.getLateralTuning().getTorque().getFriction(); - hasAutoTune = (carMake == "hyundai" || carMake == "toyota") && FPCP.getLateralTuning().which() == cereal::FrogPilotCarParams::LateralTuning::TORQUE; - isTorqueCar = FPCP.getLateralTuning().which() == cereal::FrogPilotCarParams::LateralTuning::TORQUE; - latAccelFactor = FPCP.getLateralTuning().getTorque().getLatAccelFactor(); openpilotLongitudinalControlDisabled = FPCP.getOpenpilotLongitudinalControlDisabled(); - steerKp = FPCP.getLateralTuning().getTorque().getKp(); + } + + std::string liveTorqueParameters = params.get("LiveTorqueParameters"); + if (!liveTorqueParameters.empty()) { + AlignedBuffer aligned_buf; + capnp::FlatArrayMessageReader reader(aligned_buf.align(liveTorqueParameters.data(), liveTorqueParameters.size())); + cereal::Event::Reader event = reader.getRoot(); + cereal::LiveTorqueParametersData::Reader LTP = event.getLiveTorqueParameters(); + + hasAutoTune = LTP.getUseParams(); } isC3 = util::read_file("/sys/firmware/devicetree/base/model").find("tici") != std::string::npos; diff --git a/frogpilot/ui/qt/offroad/lateral_settings.cc b/frogpilot/ui/qt/offroad/lateral_settings.cc index 3247356f77..d99244d54b 100644 --- a/frogpilot/ui/qt/offroad/lateral_settings.cc +++ b/frogpilot/ui/qt/offroad/lateral_settings.cc @@ -39,11 +39,11 @@ FrogPilotLateralPanel::FrogPilotLateralPanel(FrogPilotSettingsWindow *parent) : const std::vector> lateralToggles { {"AdvancedLateralTune", tr("Advanced Lateral Tuning"), tr("Advanced steering control changes to fine-tune how openpilot drives."), "../../frogpilot/assets/toggle_icons/icon_advanced_lateral_tune.png"}, - {"SteerDelay", steerActuatorDelay != 0 ? QString(tr("Actuator Delay (Default: %1)")).arg(QString::number(steerActuatorDelay, 'f', 2)) : tr("Actuator Delay"), tr("The time between openpilot's steering command and the vehicle's response. Increase if the vehicle reacts late; decrease if it feels jumpy. Auto-learned by default."), ""}, - {"SteerFriction", friction != 0 ? QString(tr("Friction (Default: %1)")).arg(QString::number(friction, 'f', 2)) : tr("Friction"), tr("Compensates for steering friction. Increase if the wheel sticks near center; decrease if it jitters. Auto-learned by default."), ""}, - {"SteerKP", steerKp != 0 ? QString(tr("Kp Factor (Default: %1)")).arg(QString::number(steerKp, 'f', 2)) : tr("Kp Factor"), tr("How strongly openpilot corrects lane position. Higher is tighter but twitchier; lower is smoother but slower. Auto-learned by default."), ""}, - {"SteerLatAccel", latAccelFactor != 0 ? QString(tr("Lateral Acceleration (Default: %1)")).arg(QString::number(latAccelFactor, 'f', 2)) : tr("Lateral Acceleration"), tr("Maps steering torque to turning response. Increase for sharper turns; decrease for gentler steering. Auto-learned by default."), ""}, - {"SteerRatio", steerRatio != 0 ? QString(tr("Steer Ratio (Default: %1)")).arg(QString::number(steerRatio, 'f', 2)) : tr("Steer Ratio"), tr("The relationship between steering wheel rotation and road wheel angle. Increase if steering feels too quick or twitchy; decrease if it feels too slow or weak. Auto-learned by default."), ""}, + {"SteerDelay", parent->steerActuatorDelay != 0 ? QString(tr("Actuator Delay (Default: %1)")).arg(QString::number(parent->steerActuatorDelay, 'f', 2)) : tr("Actuator Delay"), tr("The time between openpilot's steering command and the vehicle's response. Increase if the vehicle reacts late; decrease if it feels jumpy. Auto-learned by default."), ""}, + {"SteerFriction", parent->friction != 0 ? QString(tr("Friction (Default: %1)")).arg(QString::number(parent->friction, 'f', 2)) : tr("Friction"), tr("Compensates for steering friction. Increase if the wheel sticks near center; decrease if it jitters. Auto-learned by default."), ""}, + {"SteerKP", parent->steerKp != 0 ? QString(tr("Kp Factor (Default: %1)")).arg(QString::number(parent->steerKp, 'f', 2)) : tr("Kp Factor"), tr("How strongly openpilot corrects lane position. Higher is tighter but twitchier; lower is smoother but slower. Auto-learned by default."), ""}, + {"SteerLatAccel", parent->latAccelFactor != 0 ? QString(tr("Lateral Acceleration (Default: %1)")).arg(QString::number(parent->latAccelFactor, 'f', 2)) : tr("Lateral Acceleration"), tr("Maps steering torque to turning response. Increase for sharper turns; decrease for gentler steering. Auto-learned by default."), ""}, + {"SteerRatio", parent->steerRatio != 0 ? QString(tr("Steer Ratio (Default: %1)")).arg(QString::number(parent->steerRatio, 'f', 2)) : tr("Steer Ratio"), tr("The relationship between steering wheel rotation and road wheel angle. Increase if steering feels too quick or twitchy; decrease if it feels too slow or weak. Auto-learned by default."), ""}, {"ForceAutoTune", tr("Force Auto-Tune On"), tr("Force-enable openpilot's live auto-tuning for \"Friction\" and \"Lateral Acceleration\"."), ""}, {"ForceAutoTuneOff", tr("Force Auto-Tune Off"), tr("Force-disable openpilot's live auto-tuning for \"Friction\" and \"Lateral Acceleration\" and use the set value instead."), ""}, {"ForceTorqueController", tr("Force Torque Controller"), tr("Use torque-based steering control instead of angle-based control for smoother lane keeping, especially in curves."), ""}, @@ -89,13 +89,13 @@ FrogPilotLateralPanel::FrogPilotLateralPanel(FrogPilotSettingsWindow *parent) : lateralToggle = new FrogPilotParamValueButtonControl(param, title, desc, icon, 0, 0.5, QString(), std::map(), 0.01, false, {}, steerFrictionButton, false, false); } else if (param == "SteerKP") { std::vector steerKPButton{"Reset"}; - lateralToggle = new FrogPilotParamValueButtonControl(param, title, desc, icon, steerKp * 0.5, steerKp * 1.5, QString(), std::map(), 0.01, false, {}, steerKPButton, false, false); + lateralToggle = new FrogPilotParamValueButtonControl(param, title, desc, icon, parent->steerKp * 0.5, parent->steerKp * 1.5, QString(), std::map(), 0.01, false, {}, steerKPButton, false, false); } else if (param == "SteerLatAccel") { std::vector steerLatAccelButton{"Reset"}; - lateralToggle = new FrogPilotParamValueButtonControl(param, title, desc, icon, latAccelFactor * 0.75, latAccelFactor * 1.25, QString(), std::map(), 0.01, false, {}, steerLatAccelButton, false, false); + lateralToggle = new FrogPilotParamValueButtonControl(param, title, desc, icon, parent->latAccelFactor * 0.75, parent->latAccelFactor * 1.25, QString(), std::map(), 0.01, false, {}, steerLatAccelButton, false, false); } else if (param == "SteerRatio") { std::vector steerRatioButton{"Reset"}; - lateralToggle = new FrogPilotParamValueButtonControl(param, title, desc, icon, steerRatio * 0.5, steerRatio * 1.5, QString(), std::map(), 0.01, false, {}, steerRatioButton, false, false); + lateralToggle = new FrogPilotParamValueButtonControl(param, title, desc, icon, parent->steerRatio * 0.5, parent->steerRatio * 1.5, QString(), std::map(), 0.01, false, {}, steerRatioButton, false, false); } else if (param == "AlwaysOnLateral") { FrogPilotManageControl *aolToggle = new FrogPilotManageControl(param, title, desc, icon); @@ -191,12 +191,6 @@ FrogPilotLateralPanel::FrogPilotLateralPanel(FrogPilotSettingsWindow *parent) : if (FrogPilotConfirmationDialog::toggleReboot(this)) { Hardware::reboot(); } - } else if (key == "NNFF" || key == "NNFFLite") { - if (!isTorqueCar) { - if (FrogPilotConfirmationDialog::toggleReboot(this)) { - Hardware::reboot(); - } - } } else if (key != "AlwaysOnLateral") { if (FrogPilotConfirmationDialog::toggleReboot(this)) { Hardware::reboot(); @@ -207,41 +201,41 @@ FrogPilotLateralPanel::FrogPilotLateralPanel(FrogPilotSettingsWindow *parent) : } steerDelayToggle = static_cast(toggles["SteerDelay"]); - QObject::connect(steerDelayToggle, &FrogPilotParamValueButtonControl::buttonClicked, [this]() { + QObject::connect(steerDelayToggle, &FrogPilotParamValueButtonControl::buttonClicked, [parent, this]() { if (FrogPilotConfirmationDialog::yesorno(tr("Reset Actuator Delay to its default value?"), this)) { - params.putFloat("SteerDelay", steerActuatorDelay); + params.putFloat("SteerDelay", parent->steerActuatorDelay); steerDelayToggle->refresh(); } }); steerFrictionToggle = static_cast(toggles["SteerFriction"]); - QObject::connect(steerFrictionToggle, &FrogPilotParamValueButtonControl::buttonClicked, [this]() { + QObject::connect(steerFrictionToggle, &FrogPilotParamValueButtonControl::buttonClicked, [parent, this]() { if (FrogPilotConfirmationDialog::yesorno(tr("Reset Friction to its default value?"), this)) { - params.putFloat("SteerFriction", friction); + params.putFloat("SteerFriction", parent->friction); steerFrictionToggle->refresh(); } }); steerKPToggle = static_cast(toggles["SteerKP"]); - QObject::connect(steerKPToggle, &FrogPilotParamValueButtonControl::buttonClicked, [this]() { + QObject::connect(steerKPToggle, &FrogPilotParamValueButtonControl::buttonClicked, [parent, this]() { if (FrogPilotConfirmationDialog::yesorno(tr("Reset Kp Factor to its default value?"), this)) { - params.putFloat("SteerKP", steerKp); + params.putFloat("SteerKP", parent->steerKp); steerKPToggle->refresh(); } }); steerLatAccelToggle = static_cast(toggles["SteerLatAccel"]); - QObject::connect(steerLatAccelToggle, &FrogPilotParamValueButtonControl::buttonClicked, [this]() { + QObject::connect(steerLatAccelToggle, &FrogPilotParamValueButtonControl::buttonClicked, [parent, this]() { if (FrogPilotConfirmationDialog::yesorno(tr("Reset Lateral Accel to its default value?"), this)) { - params.putFloat("SteerLatAccel", latAccelFactor); + params.putFloat("SteerLatAccel", parent->latAccelFactor); steerLatAccelToggle->refresh(); } }); steerRatioToggle = static_cast(toggles["SteerRatio"]); - QObject::connect(steerRatioToggle, &FrogPilotParamValueButtonControl::buttonClicked, [this]() { + QObject::connect(steerRatioToggle, &FrogPilotParamValueButtonControl::buttonClicked, [parent, this]() { if (FrogPilotConfirmationDialog::yesorno(tr("Reset Steer Ratio to its default value?"), this)) { - params.putFloat("SteerRatio", steerRatio); + params.putFloat("SteerRatio", parent->steerRatio); steerRatioToggle->refresh(); } }); @@ -258,27 +252,15 @@ FrogPilotLateralPanel::FrogPilotLateralPanel(FrogPilotSettingsWindow *parent) : void FrogPilotLateralPanel::showEvent(QShowEvent *event) { frogpilotToggleLevels = parent->frogpilotToggleLevels; - friction = parent->friction; - hasAutoTune = parent->hasAutoTune; - hasNNFFLog = parent->hasNNFFLog; - hasOpenpilotLongitudinal = parent->hasOpenpilotLongitudinal; - isAngleCar = parent->isAngleCar; - isHKGCanFd = parent->isHKGCanFd; - isTorqueCar = parent->isTorqueCar; - latAccelFactor = parent->latAccelFactor; - steerActuatorDelay = parent->steerActuatorDelay; - steerKp = parent->steerKp; - steerRatio = parent->steerRatio; - tuningLevel = parent->tuningLevel; - steerDelayToggle->setTitle(QString(tr("Actuator Delay (Default: %1)")).arg(QString::number(steerActuatorDelay, 'f', 2))); - steerFrictionToggle->setTitle(QString(tr("Friction (Default: %1)")).arg(QString::number(friction, 'f', 2))); - steerKPToggle->setTitle(QString(tr("Kp Factor (Default: %1)")).arg(QString::number(steerKp, 'f', 2))); - steerKPToggle->updateControl(steerKp * 0.5, steerKp * 1.5); - steerLatAccelToggle->setTitle(QString(tr("Lateral Accel (Default: %1)")).arg(QString::number(latAccelFactor, 'f', 2))); - steerLatAccelToggle->updateControl(latAccelFactor * 0.75, latAccelFactor * 1.25); - steerRatioToggle->setTitle(QString(tr("Steer Ratio (Default: %1)")).arg(QString::number(steerRatio, 'f', 2))); - steerRatioToggle->updateControl(steerRatio * 0.5, steerRatio * 1.5); + steerDelayToggle->setTitle(QString(tr("Actuator Delay (Default: %1)")).arg(QString::number(parent->steerActuatorDelay, 'f', 2))); + steerFrictionToggle->setTitle(QString(tr("Friction (Default: %1)")).arg(QString::number(parent->friction, 'f', 2))); + steerKPToggle->setTitle(QString(tr("Kp Factor (Default: %1)")).arg(QString::number(parent->steerKp, 'f', 2))); + steerKPToggle->updateControl(parent->steerKp * 0.5, parent->steerKp * 1.5); + steerLatAccelToggle->setTitle(QString(tr("Lateral Accel (Default: %1)")).arg(QString::number(parent->latAccelFactor, 'f', 2))); + steerLatAccelToggle->updateControl(parent->latAccelFactor * 0.75, parent->latAccelFactor * 1.25); + steerRatioToggle->setTitle(QString(tr("Steer Ratio (Default: %1)")).arg(QString::number(parent->steerRatio, 'f', 2))); + steerRatioToggle->updateControl(parent->steerRatio * 0.5, parent->steerRatio * 1.5); updateToggles(); } @@ -358,41 +340,41 @@ void FrogPilotLateralPanel::updateToggles() { } } - bool forcingAutoTune = !hasAutoTune && params.getBool("ForceAutoTune"); - bool forcingAutoTuneOff = hasAutoTune && params.getBool("ForceAutoTuneOff"); - bool forcingTorqueController = !isAngleCar && params.getBool("ForceTorqueController"); - bool usingNNFF = hasNNFFLog && params.getBool("LateralTune") && params.getBool("NNFF"); + bool forcingAutoTune = !parent->hasAutoTune && params.getBool("ForceAutoTune"); + bool forcingAutoTuneOff = parent->hasAutoTune && params.getBool("ForceAutoTuneOff"); + bool forcingTorqueController = !parent->isAngleCar && params.getBool("ForceTorqueController"); + bool usingNNFF = parent->hasNNFFLog && params.getBool("LateralTune") && params.getBool("NNFF"); for (auto &[key, toggle] : toggles) { if (parentKeys.contains(key)) { continue; } - bool setVisible = tuningLevel >= frogpilotToggleLevels[key].toDouble(); + bool setVisible = parent->tuningLevel >= frogpilotToggleLevels[key].toDouble(); if (key == "AlwaysOnLateralLKAS") { - setVisible &= isHKGCanFd; - setVisible &= !hasOpenpilotLongitudinal; + setVisible &= parent->isHKGCanFd; + setVisible &= !parent->hasOpenpilotLongitudinal; } else if (key == "AlwaysOnLateralMain") { - setVisible &= !isHKGCanFd; - setVisible |= hasOpenpilotLongitudinal; + setVisible &= !parent->isHKGCanFd; + setVisible |= parent->hasOpenpilotLongitudinal; } else if (key == "ForceAutoTune") { - setVisible &= !hasAutoTune; - setVisible &= !isAngleCar; - setVisible &= isTorqueCar || forcingTorqueController; + setVisible &= !parent->hasAutoTune; + setVisible &= !parent->isAngleCar; + setVisible &= parent->isTorqueCar || forcingTorqueController; } else if (key == "ForceAutoTuneOff") { - setVisible &= hasAutoTune; + setVisible &= parent->hasAutoTune; } else if (key == "ForceTorqueController") { - setVisible &= !isAngleCar; - setVisible &= !isTorqueCar; + setVisible &= !parent->isAngleCar; + setVisible &= !parent->isTorqueCar; } else if (key == "LaneChangeTime") { @@ -404,42 +386,41 @@ void FrogPilotLateralPanel::updateToggles() { } else if (key == "NNFF") { - setVisible &= hasNNFFLog; - setVisible &= !isAngleCar; + setVisible &= parent->hasNNFFLog; + setVisible &= !parent->isAngleCar; } else if (key == "NNFFLite") { setVisible &= !usingNNFF; - setVisible &= !isAngleCar; + setVisible &= !parent->isAngleCar; } else if (key == "SteerDelay") { - setVisible &= steerActuatorDelay != 0; + setVisible &= parent->steerActuatorDelay != 0; } else if (key == "SteerFriction") { - setVisible &= friction != 0; - setVisible &= hasAutoTune ? forcingAutoTuneOff : !forcingAutoTune; - setVisible &= isTorqueCar || forcingTorqueController; + setVisible &= parent->friction != 0; + setVisible &= parent->hasAutoTune ? forcingAutoTuneOff : !forcingAutoTune; + setVisible &= parent->isTorqueCar || forcingTorqueController; setVisible &= !usingNNFF; } else if (key == "SteerKP") { - setVisible &= steerKp != 0; - setVisible &= hasAutoTune ? forcingAutoTuneOff : !forcingAutoTune; - setVisible &= isTorqueCar || forcingTorqueController; + setVisible &= parent->steerKp != 0; + setVisible &= !parent->isAngleCar; } else if (key == "SteerLatAccel") { - setVisible &= latAccelFactor != 0; - setVisible &= hasAutoTune ? forcingAutoTuneOff : !forcingAutoTune; - setVisible &= isTorqueCar || forcingTorqueController; + setVisible &= parent->latAccelFactor != 0; + setVisible &= parent->hasAutoTune ? forcingAutoTuneOff : !forcingAutoTune; + setVisible &= parent->isTorqueCar || forcingTorqueController; setVisible &= !usingNNFF; } else if (key == "SteerRatio") { - setVisible &= steerRatio != 0; - setVisible &= hasAutoTune ? forcingAutoTuneOff : !forcingAutoTune; + setVisible &= parent->steerRatio != 0; + setVisible &= parent->hasAutoTune ? forcingAutoTuneOff : !forcingAutoTune; } toggle->setVisible(setVisible); diff --git a/selfdrive/car/gm/interface.py b/selfdrive/car/gm/interface.py index eedc245558..046cc7bd53 100644 --- a/selfdrive/car/gm/interface.py +++ b/selfdrive/car/gm/interface.py @@ -207,7 +207,6 @@ class CarInterface(CarInterfaceBase): elif candidate in (CAR.CHEVROLET_BOLT_EUV, CAR.CHEVROLET_BOLT_CC): ret.steerActuatorDelay = 0.2 CarInterfaceBase.configure_torque_tune(candidate, ret.lateralTuning) - ret.lateralTuning.torque.kp = 0.6 if ret.enableGasInterceptor: # ACC Bolts use pedal for full longitudinal control, not just sng @@ -279,7 +278,7 @@ class CarInterface(CarInterfaceBase): # Note: Low speed, stop and go not tested. Should be fairly smooth on highway ret.longitudinalTuning.kiBP = [0., 3., 6., 35.] ret.longitudinalTuning.kiV = [0.125, 0.175, 0.225, 0.33] - ret.longitudinalTuning.kf = 0.25 + ret.longitudinalTuning.kfDEPRECATED = 0.25 ret.stoppingDecelRate = 0.8 else: # Pedal used for SNG, ACC for longitudinal control otherwise ret.safetyConfigs[0].safetyParam |= Panda.FLAG_GM_HW_CAM_LONG diff --git a/selfdrive/car/interfaces.py b/selfdrive/car/interfaces.py index ce63eb2c57..f652104e1f 100644 --- a/selfdrive/car/interfaces.py +++ b/selfdrive/car/interfaces.py @@ -155,6 +155,11 @@ class CarInterfaceBase(ABC): ret.rotationalInertia = scale_rot_inertia(ret.mass, ret.wheelbase) ret.tireStiffnessFront, ret.tireStiffnessRear = scale_tire_stiffness(ret.mass, ret.wheelbase, ret.centerToFront, ret.tireStiffnessFactor) + # FrogPilot variables + toggles_to_check = ("force_torque_controller", "nnff", "nnff_lite") + if ret.steerControlType != car.CarParams.SteerControlType.angle and any(getattr(frogpilot_toggles, toggle, False) for toggle in toggles_to_check): + CarInterfaceBase.configure_torque_tune(candidate, ret.lateralTuning) + return ret @classmethod @@ -217,14 +222,6 @@ class CarInterfaceBase(ABC): fp_ret.canUsePedal = not CP.autoResumeSng fp_ret.canUseSDSU = not CP.enableDsu and candidate not in UNSUPPORTED_DSU_CAR and candidate not in TSS2_CAR - if CP.steerControlType != car.CarParams.SteerControlType.angle: - if CP.lateralTuning.which() == "pid" and (frogpilot_toggles.force_torque_controller or frogpilot_toggles.nnff or frogpilot_toggles.nnff_lite): - CarInterfaceBase.configure_torque_tune(candidate, fp_ret.lateralTuning) - elif CP.lateralTuning.which() == "torque": - CarInterfaceBase.configure_torque_tune(candidate, fp_ret.lateralTuning) - else: - fp_ret.lateralTuning.init("pid") - fp_ret.openpilotLongitudinalControlDisabled = frogpilot_toggles.disable_openpilot_long return fp_ret @@ -286,7 +283,6 @@ class CarInterfaceBase(ABC): ret.vEgoStopping = 0.5 ret.vEgoStarting = 0.5 ret.stoppingControl = True - ret.longitudinalTuning.kf = 1. ret.longitudinalTuning.kpBP = [0.] ret.longitudinalTuning.kpV = [0.] ret.longitudinalTuning.kiBP = [0.] @@ -302,10 +298,6 @@ class CarInterfaceBase(ABC): tune.init('torque') tune.torque.useSteeringAngle = use_steering_angle - tune.torque.kf = 0.95 - tune.torque.kp = 0.6 - tune.torque.ki = 0.3 - tune.torque.kd = 0.3 tune.torque.friction = params['FRICTION'] tune.torque.latAccelFactor = params['LAT_ACCEL_FACTOR'] tune.torque.latAccelOffset = 0.0 diff --git a/selfdrive/car/toyota/carcontroller.py b/selfdrive/car/toyota/carcontroller.py index e30f870a25..d6520d065e 100644 --- a/selfdrive/car/toyota/carcontroller.py +++ b/selfdrive/car/toyota/carcontroller.py @@ -53,7 +53,7 @@ def get_long_tune(CP, params): kiBP = [2., 5.] kiV = [0.5, 0.25] - return PIDController(0.0, (kiBP, kiV), k_f=1.0, + return PIDController(0.0, (kiBP, kiV), pos_limit=params.ACCEL_MAX, neg_limit=params.ACCEL_MIN, rate=1 / (DT_CTRL * 3)) diff --git a/selfdrive/controls/controlsd.py b/selfdrive/controls/controlsd.py index dba18a9f0f..90e3f23e9e 100644 --- a/selfdrive/controls/controlsd.py +++ b/selfdrive/controls/controlsd.py @@ -34,6 +34,7 @@ from openpilot.frogpilot.tinygrad_modeld.tinygrad_modeld import LAT_SMOOTH_SECON from openpilot.system.hardware import HARDWARE from openpilot.frogpilot.common.frogpilot_variables import get_frogpilot_toggles, params_memory +from openpilot.frogpilot.controls.lib.neural_network_feedforward import LatControlNNFF SOFT_DISABLE_TIME = 3 # seconds LDW_MIN_SPEED = 31 * CV.MPH_TO_MS @@ -137,10 +138,10 @@ class Controls: self.LaC: LatControl if self.CP.steerControlType == car.CarParams.SteerControlType.angle: self.LaC = LatControlAngle(self.CP, self.CI, DT_CTRL) - elif self.FPCP.lateralTuning.which() == 'pid': + elif self.CP.lateralTuning.which() == 'pid': self.LaC = LatControlPID(self.CP, self.CI, DT_CTRL) - elif self.FPCP.lateralTuning.which() == 'torque': - self.LaC = LatControlTorque(self.CP, self.FPCP, self.CI, DT_CTRL) + elif self.CP.lateralTuning.which() == 'torque': + self.LaC = LatControlTorque(self.CP, self.CI, DT_CTRL) self.initialized = False self.state = State.disabled @@ -205,6 +206,10 @@ class Controls: self.frogpilot_toggles = get_frogpilot_toggles() + if self.CP.lateralTuning.which() == "torque" and (self.frogpilot_toggles.nnff or self.frogpilot_toggles.nnff_lite): + self.LaC = LatControlNNFF(self.CP, self.CI, DT_CTRL) + + self.frogpilot_toggles.is_metric = self.is_metric def set_initial_state(self): @@ -616,14 +621,14 @@ class Controls: self.curvature = -self.VM.calc_curvature(steer_angle_without_offset, CS.vEgo, lp.roll) # Update Torque Params - if self.FPCP.lateralTuning.which() == 'torque': + if self.CP.lateralTuning.which() == 'torque': torque_params = self.sm['liveTorqueParameters'] if self.sm.all_checks(['liveTorqueParameters']) and (torque_params.useParams or self.frogpilot_toggles.force_auto_tune): self.LaC.update_live_torque_params(torque_params.latAccelFactorFiltered, torque_params.latAccelOffsetFiltered, torque_params.frictionCoefficientFiltered) - if self.sm.updated['liveDelay'] and (self.frogpilot_toggles.nnff or self.frogpilot_toggles.nnff_lite): - self.LaC.nnff.update_live_delay(self.sm['liveDelay'].lateralDelay) + if self.sm.updated['liveDelay'] and hasattr(self.LaC, "update_live_delay"): + self.LaC.update_live_delay(self.sm['liveDelay'].lateralDelay) long_plan = self.sm['longitudinalPlan'] model_v2 = self.sm['modelV2'] @@ -892,7 +897,7 @@ class Controls: controlsState.experimentalMode = self.experimental_mode controlsState.personality = self.personality - lat_tuning = self.FPCP.lateralTuning.which() + lat_tuning = self.CP.lateralTuning.which() if self.joystick_mode: controlsState.lateralControlState.debugState = lac_log elif self.CP.steerControlType == car.CarParams.SteerControlType.angle: diff --git a/selfdrive/controls/lib/drive_helpers.py b/selfdrive/controls/lib/drive_helpers.py index 620abd51e9..1227ae43df 100644 --- a/selfdrive/controls/lib/drive_helpers.py +++ b/selfdrive/controls/lib/drive_helpers.py @@ -189,7 +189,7 @@ def smooth_value(val, prev_val, tau, dt=DT_MDL): alpha = 1 - np.exp(-dt/tau) if tau > 0 else 1 return alpha * val + (1 - alpha) * prev_val -def clip_curvature(v_ego, prev_curvature, new_curvature, roll): +def clip_curvature(v_ego, prev_curvature, new_curvature, roll) -> tuple[float, bool]: # This function respects ISO lateral jerk and acceleration limits + a max curvature v_ego = max(v_ego, MIN_SPEED) max_curvature_rate = MAX_LATERAL_JERK / (v_ego ** 2) # inexact calculation, check https://github.com/commaai/openpilot/pull/24755 diff --git a/selfdrive/controls/lib/latcontrol_pid.py b/selfdrive/controls/lib/latcontrol_pid.py index 73ed3b17be..1944a5a9cc 100644 --- a/selfdrive/controls/lib/latcontrol_pid.py +++ b/selfdrive/controls/lib/latcontrol_pid.py @@ -10,7 +10,8 @@ class LatControlPID(LatControl): super().__init__(CP, CI, dt) self.pid = PIDController((CP.lateralTuning.pid.kpBP, CP.lateralTuning.pid.kpV), (CP.lateralTuning.pid.kiBP, CP.lateralTuning.pid.kiV), - k_f=CP.lateralTuning.pid.kf, pos_limit=self.steer_max, neg_limit=-self.steer_max) + pos_limit=self.steer_max, neg_limit=-self.steer_max) + self.ff_factor = CP.lateralTuning.pid.kf self.get_steer_feedforward = CI.get_steer_feedforward_function() def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, curvature_limited, lat_delay, llk, model_data, frogpilot_toggles): @@ -30,7 +31,7 @@ class LatControlPID(LatControl): else: # offset does not contribute to resistive torque - ff = self.get_steer_feedforward(angle_steers_des_no_offset, CS.vEgo) + ff = self.ff_factor * self.get_steer_feedforward(angle_steers_des_no_offset, CS.vEgo) freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5 output_torque = self.pid.update(error, diff --git a/selfdrive/controls/lib/latcontrol_torque.py b/selfdrive/controls/lib/latcontrol_torque.py index db647ae507..fa6bf76b38 100644 --- a/selfdrive/controls/lib/latcontrol_torque.py +++ b/selfdrive/controls/lib/latcontrol_torque.py @@ -4,50 +4,46 @@ from collections import deque from cereal import log from openpilot.common.filter_simple import FirstOrderFilter -from openpilot.selfdrive.controls.lib.drive_helpers import MIN_SPEED, get_friction from openpilot.selfdrive.car.interfaces import FRICTION_THRESHOLD +from openpilot.selfdrive.controls.lib.drive_helpers import MIN_SPEED, get_friction from openpilot.selfdrive.controls.lib.latcontrol import LatControl from openpilot.selfdrive.controls.lib.pid import PIDController from openpilot.selfdrive.controls.lib.vehicle_model import ACCELERATION_DUE_TO_GRAVITY -from openpilot.frogpilot.controls.lib.neural_network_feedforward import LOW_SPEED_Y_NN, NeuralNetworkFeedforward - # At higher speeds (25+mph) we can assume: # Lateral acceleration achieved by a specific car correlates to # torque applied to the steering rack. It does not correlate to # wheel slip, or to speed. # This controller applies torque to achieve desired lateral -# accelerations. To compensate for the low speed effects we -# use a LOW_SPEED_FACTOR in the error. Additionally, there is -# friction in the steering wheel that needs to be overcome to -# move it at all, this is compensated for too. +# accelerations. To compensate for the low speed effects the +# proportional gain is increased at low speeds by the PID controller. +# Additionally, there is friction in the steering wheel that needs +# to be overcome to move it at all, this is compensated for too. -MAX_LAT_JERK_UP = 2.5 # m/s^3 - -LOW_SPEED_X = [0, 10, 20, 30] -LOW_SPEED_Y = [15, 13, 10, 5] +KP = 0.6 +KI = 0.3 +KD = 0.0 +INTERP_SPEEDS = [1, 1.5, 2.0, 3.0, 5, 7.5, 10, 15, 30] +KP_INTERP = [250, 120, 65, 30, 11.5, 5.5, 3.5, 2.0, KP] +LP_FILTER_CUTOFF_HZ = 1.2 +LAT_ACCEL_REQUEST_BUFFER_SECONDS = 1.0 +VERSION = 0 class LatControlTorque(LatControl): - def __init__(self, CP, FPCP, CI, dt): + def __init__(self, CP, CI, dt): super().__init__(CP, CI, dt) - self.torque_params = FPCP.lateralTuning.torque + self.torque_params = CP.lateralTuning.torque self.torque_from_lateral_accel = CI.torque_from_lateral_accel() self.lateral_accel_from_torque = CI.lateral_accel_from_torque() - self.pid = PIDController(self.torque_params.kp, self.torque_params.ki, - k_f=self.torque_params.kf, rate=1/self.dt) + self.pid = PIDController([INTERP_SPEEDS, KP_INTERP], KI, KD, rate=1/self.dt) self.update_limits() self.steering_angle_deadzone_deg = self.torque_params.steeringAngleDeadzoneDeg - self.LATACCEL_REQUEST_BUFFER_NUM_FRAMES = int(1 / self.dt) - self.requested_lateral_accel_buffer = deque([0.] * self.LATACCEL_REQUEST_BUFFER_NUM_FRAMES , maxlen=self.LATACCEL_REQUEST_BUFFER_NUM_FRAMES) + self.lat_accel_request_buffer_len = int(LAT_ACCEL_REQUEST_BUFFER_SECONDS / self.dt) + self.lat_accel_request_buffer = deque([0.] * self.lat_accel_request_buffer_len , maxlen=self.lat_accel_request_buffer_len) self.previous_measurement = 0.0 - self.measurement_rate_filter = FirstOrderFilter(0.0, 1 / (2 * np.pi * (MAX_LAT_JERK_UP - 0.5)), self.dt) - - # FrogPilot variables - self.nnff = NeuralNetworkFeedforward(CP, self) - - self.nnff_loaded = self.nnff.lat_torque_nn_model != None + self.measurement_rate_filter = FirstOrderFilter(0.0, 1 / (2 * np.pi * LP_FILTER_CUTOFF_HZ), self.dt) def update_live_torque_params(self, latAccelFactor, latAccelOffset, friction): self.torque_params.latAccelFactor = latAccelFactor @@ -61,6 +57,7 @@ class LatControlTorque(LatControl): def update(self, active, CS, VM, params, steer_limited_by_safety, desired_curvature, curvature_limited, lat_delay, llk, model_data, frogpilot_toggles): pid_log = log.ControlsState.LateralTorqueState.new_message() + pid_log.version = VERSION if not active: output_torque = 0.0 pid_log.active = False @@ -70,11 +67,11 @@ class LatControlTorque(LatControl): curvature_deadzone = abs(VM.calc_curvature(math.radians(self.steering_angle_deadzone_deg), CS.vEgo, 0.0)) lateral_accel_deadzone = curvature_deadzone * CS.vEgo ** 2 - delay_frames = int(np.clip(lat_delay / self.dt, 1, self.LATACCEL_REQUEST_BUFFER_NUM_FRAMES)) - expected_lateral_accel = self.requested_lateral_accel_buffer[-delay_frames] + delay_frames = int(np.clip(lat_delay / self.dt, 1, self.lat_accel_request_buffer_len)) + expected_lateral_accel = self.lat_accel_request_buffer[-delay_frames] # TODO factor out lateral jerk from error to later replace it with delay independent alternative future_desired_lateral_accel = desired_curvature * CS.vEgo ** 2 - self.requested_lateral_accel_buffer.append(future_desired_lateral_accel) + self.lat_accel_request_buffer.append(future_desired_lateral_accel) gravity_adjusted_future_lateral_accel = future_desired_lateral_accel - roll_compensation desired_lateral_jerk = (future_desired_lateral_accel - expected_lateral_accel) / lat_delay @@ -82,47 +79,34 @@ class LatControlTorque(LatControl): measurement_rate = self.measurement_rate_filter.update((measurement - self.previous_measurement) / self.dt) self.previous_measurement = measurement - low_speed_factor = (np.interp(CS.vEgo, LOW_SPEED_X, LOW_SPEED_Y_NN if frogpilot_toggles.nnff else LOW_SPEED_Y) / max(CS.vEgo, MIN_SPEED)) ** 2 setpoint = lat_delay * desired_lateral_jerk + expected_lateral_accel error = setpoint - measurement - error_lsf = error + low_speed_factor / self.torque_params.kp * error - if self.nnff_loaded and frogpilot_toggles.nnff or frogpilot_toggles.nnff_lite: - pid_log, ff = self.nnff.compute_nnff( - CS, VM, measurement, error, future_desired_lateral_accel, gravity_adjusted_future_lateral_accel, - llk, measurement, model_data, params, pid_log, setpoint, frogpilot_toggles - ) + # do error correction in lateral acceleration space, convert at end to handle non-linear torque responses correctly + pid_log.error = float(error) + ff = gravity_adjusted_future_lateral_accel + # latAccelOffset corrects roll compensation bias from device roll misalignment relative to car roll + ff -= self.torque_params.latAccelOffset + # TODO jerk is weighted by lat_delay for legacy reasons, but should be made independent of it + ff += get_friction(error, lateral_accel_deadzone, FRICTION_THRESHOLD, self.torque_params) - freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5 - output_torque = self.pid.update(pid_log.error, + freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5 + output_lataccel = self.pid.update(pid_log.error, + -measurement_rate, feedforward=ff, speed=CS.vEgo, freeze_integrator=freeze_integrator) - else: - # do error correction in lateral acceleration space, convert at end to handle non-linear torque responses correctly - pid_log.error = float(error_lsf) - ff = gravity_adjusted_future_lateral_accel - # latAccelOffset corrects roll compensation bias from device roll misalignment relative to car roll - ff -= self.torque_params.latAccelOffset - # TODO jerk is weighted by lat_delay for legacy reasons, but should be made independent of it - ff += get_friction(error, lateral_accel_deadzone, FRICTION_THRESHOLD, self.torque_params) - - freeze_integrator = steer_limited_by_safety or CS.steeringPressed or CS.vEgo < 5 - output_lataccel = self.pid.update(pid_log.error, - -measurement_rate, - feedforward=ff, - speed=CS.vEgo, - freeze_integrator=freeze_integrator) - output_torque = self.torque_from_lateral_accel(output_lataccel, self.torque_params) + output_torque = self.torque_from_lateral_accel(output_lataccel, self.torque_params) pid_log.active = True pid_log.p = float(self.pid.p) pid_log.i = float(self.pid.i) pid_log.d = float(self.pid.d) pid_log.f = float(self.pid.f) - pid_log.output = float(-output_torque) # TODO: log lat accel? + pid_log.output = float(-output_torque) # TODO: log lat accel? pid_log.actualLateralAccel = float(measurement) pid_log.desiredLateralAccel = float(setpoint) + pid_log.desiredLateralJerk = float(desired_lateral_jerk) pid_log.saturated = bool(self._check_saturation(self.steer_max - abs(output_torque) < 1e-3, CS, steer_limited_by_safety, curvature_limited)) # TODO left is positive in this convention diff --git a/selfdrive/controls/lib/longcontrol.py b/selfdrive/controls/lib/longcontrol.py index 6563b142da..afb0a018fa 100644 --- a/selfdrive/controls/lib/longcontrol.py +++ b/selfdrive/controls/lib/longcontrol.py @@ -95,8 +95,10 @@ class LongControl: pos_p_limit = 0.0 # if params("NoPositivePResponse") else None # put parameter-based control here self.pid = PIDController((CP.longitudinalTuning.kpBP, CP.longitudinalTuning.kpV), (CP.longitudinalTuning.kiBP, CP.longitudinalTuning.kiV), - k_f=CP.longitudinalTuning.kf, rate=1 / DT_CTRL, - pos_p_limit=pos_p_limit) + rate=1 / DT_CTRL, pos_p_limit=pos_p_limit) + # Preserve legacy behaviour when no feedforward gain is provided (default of 0.0) + kf = getattr(CP.longitudinalTuning, 'kfDEPRECATED', 0.0) + self.feedforward_gain = kf if kf != 0.0 else 1.0 self.v_pid = 0.0 self._mode_setup() self.last_output_accel = 0.0 @@ -159,7 +161,8 @@ class LongControl: else: # LongCtrlState.pid error = a_target - CS.aEgo self.update_mpc_mode(self.experimental_mode) - raw_output_accel = self.pid.update(error, speed=CS.vEgo, feedforward=a_target) + feedforward = a_target * self.feedforward_gain + raw_output_accel = self.pid.update(error, speed=CS.vEgo, feedforward=feedforward) if self.transitioning and self.prev_mode == 'acc' and self.current_mode == 'blended': @@ -236,8 +239,9 @@ class LongControl: error = self.v_pid - CS.vEgo error_deadzone = apply_deadzone(error, deadzone) + feedforward = a_target * self.feedforward_gain output_accel = self.pid.update(error_deadzone, speed=CS.vEgo, - feedforward=a_target, + feedforward=feedforward, freeze_integrator=freeze_integrator) self.last_output_accel = clip(output_accel, accel_limits[0], accel_limits[1]) diff --git a/selfdrive/controls/lib/pid.py b/selfdrive/controls/lib/pid.py index a076ea2e00..fad8ce5814 100644 --- a/selfdrive/controls/lib/pid.py +++ b/selfdrive/controls/lib/pid.py @@ -1,17 +1,11 @@ import numpy as np from numbers import Number -from openpilot.common.numpy_fast import clip, interp - - class PIDController: - def __init__(self, k_p, k_i, k_f=0., k_d=0., - pos_limit=1e308, neg_limit=-1e308, rate=100, - pos_p_limit=None, neg_p_limit=None): + def __init__(self, k_p, k_i, k_d=0., pos_limit=1e308, neg_limit=-1e308, rate=100, pos_p_limit=None, neg_p_limit=None): self._k_p = k_p self._k_i = k_i self._k_d = k_d - self.k_f = k_f # feedforward gain if isinstance(self._k_p, Number): self._k_p = [[0], [self._k_p]] if isinstance(self._k_i, Number): @@ -19,13 +13,8 @@ class PIDController: if isinstance(self._k_d, Number): self._k_d = [[0], [self._k_d]] - self.pos_limit = pos_limit - self.neg_limit = neg_limit + self.set_limits(pos_limit, neg_limit) - self.pos_p_limit = pos_p_limit - self.neg_p_limit = neg_p_limit - - self.i_unwind_rate = 0.3 / rate self.i_dt = 1.0 / rate self.speed = 0.0 @@ -33,23 +22,15 @@ class PIDController: @property def k_p(self): - return interp(self.speed, self._k_p[0], self._k_p[1]) + return np.interp(self.speed, self._k_p[0], self._k_p[1]) @property def k_i(self): - return interp(self.speed, self._k_i[0], self._k_i[1]) + return np.interp(self.speed, self._k_i[0], self._k_i[1]) @property def k_d(self): - return interp(self.speed, self._k_d[0], self._k_d[1]) - - @property - def error_integral(self): - return self.i/self.k_i - - def set_limits(self, pos_limit, neg_limit): - self.pos_limit = pos_limit - self.neg_limit = neg_limit + return np.interp(self.speed, self._k_d[0], self._k_d[1]) def reset(self): self.p = 0.0 @@ -58,29 +39,25 @@ class PIDController: self.f = 0.0 self.control = 0 - def update(self, error, error_rate=0.0, speed=0.0, override=False, feedforward=0., freeze_integrator=False): + def set_limits(self, pos_limit, neg_limit): + self.pos_limit = pos_limit + self.neg_limit = neg_limit + + def update(self, error, error_rate=0.0, speed=0.0, feedforward=0., freeze_integrator=False): self.speed = speed - self.p = self.k_p * float(error) - if self.pos_p_limit is not None and self.p > self.pos_p_limit: - self.p = self.pos_p_limit - elif self.neg_p_limit is not None and self.p < self.neg_p_limit: - self.p = self.neg_p_limit self.d = self.k_d * error_rate - self.f = self.k_f * feedforward + self.f = feedforward - if override: - self.i -= self.i_unwind_rate * float(np.sign(self.i)) - else: - if not freeze_integrator: - self.i = self.i + self.k_i * self.i_dt * error + if not freeze_integrator: + i = self.i + self.k_i * self.i_dt * error - # Clip i to prevent exceeding control limits - control_no_i = self.p + self.d + self.f - control_no_i = clip(control_no_i, self.neg_limit, self.pos_limit) - self.i = clip(self.i, self.neg_limit - control_no_i, self.pos_limit - control_no_i) + # Don't allow windup if already clipping + test_control = self.p + i + self.d + self.f + i_upperbound = self.i if test_control > self.pos_limit else self.pos_limit + i_lowerbound = self.i if test_control < self.neg_limit else self.neg_limit + self.i = np.clip(i, i_lowerbound, i_upperbound) control = self.p + self.i + self.d + self.f - - self.control = clip(control, self.neg_limit, self.pos_limit) + self.control = np.clip(control, self.neg_limit, self.pos_limit) return self.control diff --git a/selfdrive/locationd/paramsd.py b/selfdrive/locationd/paramsd.py index 5ef0ebcae0..ac1f9abfea 100755 --- a/selfdrive/locationd/paramsd.py +++ b/selfdrive/locationd/paramsd.py @@ -187,8 +187,6 @@ def main(): # FrogPilot variables frogpilot_toggles = get_frogpilot_toggles() - with custom.FrogPilotCarParams.from_bytes(params_reader.get("FrogPilotCarParams", block=True)) as msg: - FPCP = msg while True: sm.update() @@ -240,7 +238,7 @@ def main(): 0.2 <= liveParameters.stiffnessFactor <= 5.0, min_sr <= liveParameters.steerRatio <= max_sr, )) - if CP.carFingerprint == "RAM_HD" or CP.carName == "subaru" and FPCP.lateralTuning.which() == "torque": + if CP.carFingerprint == "RAM_HD" or CP.carName == "subaru" and CP.lateralTuning.which() == "torque": liveParameters.valid = True liveParameters.steerRatioStd = float(P[States.STEER_RATIO].item()) liveParameters.stiffnessFactorStd = float(P[States.STIFFNESS].item()) diff --git a/selfdrive/locationd/torqued.py b/selfdrive/locationd/torqued.py index 051f4a5830..160c9f72fb 100755 --- a/selfdrive/locationd/torqued.py +++ b/selfdrive/locationd/torqued.py @@ -52,7 +52,7 @@ class TorqueBuckets(PointBuckets): class TorqueEstimator(ParameterEstimator): - def __init__(self, CP, FPCP, decimated=False): + def __init__(self, CP, decimated=False): self.hist_len = int(HISTORY / DT_MDL) self.lag = 0.0 if decimated: @@ -72,11 +72,11 @@ class TorqueEstimator(ParameterEstimator): self.offline_friction = 0.0 self.offline_latAccelFactor = 0.0 self.resets = 0.0 - self.use_params = CP.carName in ALLOWED_CARS and FPCP.lateralTuning.which() == 'torque' + self.use_params = CP.carName in ALLOWED_CARS and CP.lateralTuning.which() == 'torque' - if FPCP.lateralTuning.which() == 'torque': - self.offline_friction = FPCP.lateralTuning.torque.friction - self.offline_latAccelFactor = FPCP.lateralTuning.torque.latAccelFactor + if CP.lateralTuning.which() == 'torque': + self.offline_friction = CP.lateralTuning.torque.friction + self.offline_latAccelFactor = CP.lateralTuning.torque.latAccelFactor self.reset() @@ -102,7 +102,7 @@ class TorqueEstimator(ParameterEstimator): cache_ltp = log_evt.liveTorqueParameters with car.CarParams.from_bytes(params_cache) as msg: cache_CP = msg - if self.get_restore_key(cache_CP, FPCP, cache_ltp.version) == self.get_restore_key(CP, FPCP, VERSION): + if self.get_restore_key(cache_CP, cache_ltp.version) == self.get_restore_key(CP, VERSION): if cache_ltp.liveValid: initial_params = { 'latAccelFactor': cache_ltp.latAccelFactorFiltered, @@ -121,12 +121,12 @@ class TorqueEstimator(ParameterEstimator): for param in initial_params: self.filtered_params[param] = FirstOrderFilter(initial_params[param], self.decay, DT_MDL) - def get_restore_key(self, CP, FPCP, version): + def get_restore_key(self, CP, version): a, b = None, None - if FPCP.lateralTuning.which() == 'torque': - a = FPCP.lateralTuning.torque.friction - b = FPCP.lateralTuning.torque.latAccelFactor - return (CP.carFingerprint, FPCP.lateralTuning.which(), a, b, version) + if CP.lateralTuning.which() == 'torque': + a = CP.lateralTuning.torque.friction + b = CP.lateralTuning.torque.latAccelFactor + return (CP.carFingerprint, CP.lateralTuning.which(), a, b, version) def reset(self): self.resets += 1.0 @@ -227,14 +227,14 @@ def main(demo=False): sm = messaging.SubMaster(['carControl', 'carOutput', 'carState', 'liveLocationKalman', 'liveDelay', 'frogpilotPlan'], poll='liveLocationKalman') params = Params() - with car.CarParams.from_bytes(params.get("CarParams", block=True)) as CP, custom.FrogPilotCarParams.from_bytes(params.get("FrogPilotCarParams", block=True)) as FPCP: - estimator = TorqueEstimator(CP, FPCP) + with car.CarParams.from_bytes(params.get("CarParams", block=True)) as CP: + estimator = TorqueEstimator(CP) # FrogPilot variables frogpilot_toggles = get_frogpilot_toggles() if not frogpilot_toggles.liveValid: - estimator = TorqueEstimator(CP, FPCP, decimated=True) + estimator = TorqueEstimator(CP, decimated=True) while True: sm.update() diff --git a/system/hardware/fan_controller.py b/system/hardware/fan_controller.py index f32133f6bf..cd06e39813 100755 --- a/system/hardware/fan_controller.py +++ b/system/hardware/fan_controller.py @@ -18,7 +18,7 @@ class TiciFanController(BaseFanController): cloudlog.info("Setting up TICI fan handler") self.last_ignition = False - self.controller = PIDController(k_p=0, k_i=4e-3, k_f=1, rate=(1 / DT_HW)) + self.controller = PIDController(k_p=0, k_i=4e-3, rate=(1 / DT_HW)) def update(self, cur_temp: float, ignition: bool) -> int: self.controller.neg_limit = -(100 if ignition else 30) @@ -35,4 +35,3 @@ class TiciFanController(BaseFanController): self.last_ignition = ignition return fan_pwr_out -