393 lines
21 KiB
Python
393 lines
21 KiB
Python
#!/usr/bin/env python3
|
|
import numpy as np
|
|
from iqdbc.car import get_safety_config, structs, uds
|
|
from iqdbc.car.common.conversions import Conversions as CV
|
|
from iqdbc.car.disable_ecu import disable_ecu, clear_all_dtcs, clear_ecu_dtcs
|
|
from iqdbc.car.honda.hondacan import CanBus
|
|
from iqdbc.car.honda.values import CarControllerParams, HondaFlags, CAR, HONDA_BOSCH, HONDA_BOSCH_CANFD, \
|
|
HONDA_NIDEC_ALT_SCM_MESSAGES, HONDA_BOSCH_RADARLESS, \
|
|
HONDA_RADAR_SCAN_VERIFIED, HondaSafetyFlags
|
|
from iqdbc.car.honda.carcontroller import CarController
|
|
from iqdbc.car.honda.carstate import CarState
|
|
from iqdbc.car.honda.radar_interface import RadarInterface
|
|
from iqdbc.car.interfaces import CarInterfaceBase
|
|
|
|
from iqdbc.lvbs.car.honda.iq_values import HondaFlagsIQ, HondaSafetyFlagsIQ
|
|
|
|
TransmissionType = structs.CarParams.TransmissionType
|
|
|
|
|
|
class CarInterface(CarInterfaceBase):
|
|
CarState = CarState
|
|
CarController = CarController
|
|
RadarInterface = RadarInterface
|
|
|
|
DRIVABLE_GEARS = (structs.CarState.GearShifter.sport,)
|
|
|
|
@staticmethod
|
|
def get_pid_accel_limits(CP, CP_IQ, current_speed, cruise_speed):
|
|
if CP.carFingerprint in HONDA_BOSCH:
|
|
return CarControllerParams.BOSCH_ACCEL_MIN, CarControllerParams.BOSCH_ACCEL_MAX
|
|
elif CP_IQ.enableGasInterceptor:
|
|
return CarControllerParams.NIDEC_ACCEL_MIN, CarControllerParams.NIDEC_ACCEL_MAX
|
|
else:
|
|
# NIDECs don't allow acceleration near cruise_speed,
|
|
# so limit limits of pid to prevent windup
|
|
ACCEL_MAX_VALS = [CarControllerParams.NIDEC_ACCEL_MAX, 0.2]
|
|
ACCEL_MAX_BP = [cruise_speed - 2., cruise_speed - .2]
|
|
return CarControllerParams.NIDEC_ACCEL_MIN, np.interp(current_speed, ACCEL_MAX_BP, ACCEL_MAX_VALS)
|
|
|
|
@staticmethod
|
|
def _get_params(ret: structs.CarParams, candidate, fingerprint, car_fw, alpha_long, is_release, docs) -> structs.CarParams:
|
|
ret.brand = "honda"
|
|
|
|
CAN = CanBus(ret, fingerprint)
|
|
|
|
if candidate in HONDA_BOSCH:
|
|
cfgs = [get_safety_config(structs.CarParams.SafetyModel.hondaBosch)]
|
|
if candidate in HONDA_BOSCH_CANFD and CAN.pt >= 4:
|
|
cfgs.insert(0, get_safety_config(structs.CarParams.SafetyModel.noOutput))
|
|
ret.safetyConfigs = cfgs
|
|
|
|
# The object scan survives openpilot longitudinal: the radar disable is subnet-scoped to the
|
|
# powertrain bus, while the scan rides the camera-side ACC-CAN
|
|
ret.radarUnavailable = docs or candidate not in HONDA_RADAR_SCAN_VERIFIED
|
|
# Disable the radar and let openpilot control longitudinal
|
|
# WARNING: THIS DISABLES AEB!
|
|
# If Bosch radarless, this blocks ACC messages from the camera
|
|
ret.alphaLongitudinalAvailable = True
|
|
ret.openpilotLongitudinalControl = alpha_long
|
|
ret.pcmCruise = not ret.openpilotLongitudinalControl
|
|
else:
|
|
ret.safetyConfigs = [get_safety_config(structs.CarParams.SafetyModel.hondaNidec)]
|
|
ret.openpilotLongitudinalControl = True
|
|
|
|
ret.pcmCruise = True
|
|
|
|
if candidate == CAR.HONDA_CRV_5G:
|
|
ret.enableBsm = 0x12f8bfa7 in fingerprint[CAN.radar]
|
|
|
|
# Detect Bosch cars with new HUD msgs
|
|
if any(0x33DA in f for f in fingerprint.values()):
|
|
ret.flags |= HondaFlags.BOSCH_EXT_HUD.value
|
|
|
|
if 0x184 in fingerprint[CAN.pt]:
|
|
ret.flags |= HondaFlags.HYBRID.value
|
|
|
|
if ret.flags & HondaFlags.ALLOW_MANUAL_TRANS and all(msg not in fingerprint[CAN.pt] for msg in (0x191, 0x1A3)):
|
|
# Manual transmission support for allowlisted cars only, to prevent silent fall-through on auto-detection failures
|
|
ret.transmissionType = TransmissionType.manual
|
|
elif 0x191 in fingerprint[CAN.pt] and candidate != CAR.ACURA_RDX:
|
|
# Traditional CVTs, gearshift position in GEARBOX_CVT
|
|
ret.transmissionType = TransmissionType.cvt
|
|
else:
|
|
# Traditional autos, direct-drive EVs and eCVTs, gearshift position in GEARBOX_AUTO
|
|
ret.transmissionType = TransmissionType.automatic
|
|
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0], [0]]
|
|
ret.lateralTuning.pid.kiBP, ret.lateralTuning.pid.kpBP = [[0.], [0.]]
|
|
ret.lateralTuning.pid.kf = 0.00006 # conservative feed-forward
|
|
ret.steerActuatorDelay = 0.1
|
|
|
|
if candidate in HONDA_BOSCH:
|
|
if candidate in HONDA_BOSCH_RADARLESS:
|
|
ret.stopAccel = CarControllerParams.BOSCH_ACCEL_MIN # stock uses -4.0 m/s^2 once stopped but limited by safety model
|
|
ret.longitudinalActuatorDelay = 0.25 # s
|
|
elif candidate in HONDA_BOSCH_CANFD:
|
|
ret.longitudinalActuatorDelay = 0.05 # near zero, canfd seems to have stock feedforward correction
|
|
else:
|
|
ret.longitudinalActuatorDelay = 0.25 # s, per Bosch A log
|
|
else:
|
|
# default longitudinal tuning for all hondas
|
|
ret.longitudinalTuning.kiBP = [0., 5., 35.]
|
|
ret.longitudinalTuning.kiV = [1.2, 0.8, 0.5]
|
|
|
|
# Disable control if EPS mod detected
|
|
for fw in car_fw:
|
|
if fw.ecu == "eps" and b"," in fw.fwVersion:
|
|
ret.dashcamOnly = True
|
|
|
|
if candidate == CAR.HONDA_CIVIC:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 2560], [0, 2560]]
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[1.1], [0.33]]
|
|
|
|
elif candidate in (CAR.HONDA_CIVIC_BOSCH, CAR.HONDA_CIVIC_BOSCH_DIESEL):
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.8], [0.24]]
|
|
|
|
elif candidate == CAR.HONDA_CIVIC_2022:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 5120], [0, 5120]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpBP, ret.lateralTuning.pid.kpV = [[0, 10], [0.05, 0.5]]
|
|
ret.lateralTuning.pid.kiBP, ret.lateralTuning.pid.kiV = [[0, 10], [0.0125, 0.125]]
|
|
|
|
elif candidate == CAR.HONDA_ACCORD:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.6], [0.18]]
|
|
if ret.transmissionType == TransmissionType.manual:
|
|
CarControllerParams.BOSCH_GAS_LOOKUP_BP = [-0.2, 2.0]
|
|
|
|
elif candidate == CAR.HONDA_ACCORD_11G:
|
|
ret.steerActuatorDelay = 0.22
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 12747], [0, 12747]]
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.2], [0.18]]
|
|
|
|
elif candidate == CAR.ACURA_ILX:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 3840], [0, 3840]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.8], [0.24]]
|
|
|
|
elif candidate in (CAR.HONDA_CRV, CAR.HONDA_CRV_EU):
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 1000], [0, 1000]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.8], [0.24]]
|
|
ret.wheelSpeedFactor = 1.025
|
|
|
|
elif candidate == CAR.HONDA_CRV_5G:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 3840], [0, 3840]]
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.64], [0.192]]
|
|
ret.wheelSpeedFactor = 1.025
|
|
|
|
elif candidate == CAR.HONDA_CRV_HYBRID:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.6], [0.18]]
|
|
ret.wheelSpeedFactor = 1.025
|
|
|
|
elif candidate == CAR.HONDA_CRV_6G:
|
|
ret.steerActuatorDelay = 0.15
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 5100], [0, 5100]]
|
|
CarInterfaceBase.configure_torque_tune(candidate, ret.lateralTuning)
|
|
|
|
elif candidate == CAR.HONDA_FIT:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.2], [0.05]]
|
|
|
|
elif candidate == CAR.HONDA_FREED:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]]
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.2], [0.05]]
|
|
|
|
elif candidate in (CAR.HONDA_HRV, CAR.HONDA_HRV_3G):
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]]
|
|
if candidate == CAR.HONDA_HRV:
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.16], [0.025]]
|
|
ret.wheelSpeedFactor = 1.025
|
|
else:
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.8], [0.24]] # TODO: can probably use some tuning
|
|
|
|
elif candidate == CAR.ACURA_RDX:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 1000], [0, 1000]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.8], [0.24]]
|
|
|
|
elif candidate == CAR.ACURA_RDX_3G:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4095], [0, 4095]]
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.2], [0.06]]
|
|
|
|
elif candidate == CAR.HONDA_ODYSSEY:
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.28], [0.08]]
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
|
|
elif candidate == CAR.HONDA_ODYSSEY_TWN:
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.28], [0.08]]
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 32767], [0, 32767]] # TODO: determine if there is a dead zone at the top end
|
|
|
|
elif candidate in (CAR.HONDA_PILOT, CAR.HONDA_PILOT_4G, CAR.HONDA_PASSPORT_4G, CAR.ACURA_MDX_4G_MMR):
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpBP, ret.lateralTuning.pid.kpV = [[0, 10], [0.05, 0.5]]
|
|
ret.lateralTuning.pid.kiBP, ret.lateralTuning.pid.kiV = [[0, 10], [0.0125, 0.125]]
|
|
|
|
elif candidate == CAR.HONDA_RIDGELINE:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.38], [0.11]]
|
|
|
|
elif candidate in (CAR.HONDA_INSIGHT, CAR.HONDA_NBOX_2G):
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.6], [0.18]]
|
|
|
|
elif candidate == CAR.HONDA_E:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]] # TODO: determine if there is a dead zone at the top end
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.6], [0.18]] # TODO: can probably use some tuning
|
|
|
|
elif candidate == CAR.HONDA_ODYSSEY_5G_MMR:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 3810], [0, 3810]]
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.2], [0.06]]
|
|
ret.steerActuatorDelay = 0.15
|
|
CarControllerParams.BOSCH_GAS_LOOKUP_V = [0, 2000]
|
|
if not ret.openpilotLongitudinalControl:
|
|
# When using stock ACC, the radar intercepts and filters steering commands the EPS would otherwise accept
|
|
ret.minSteerSpeed = 70. * CV.KPH_TO_MS
|
|
|
|
elif candidate == CAR.ACURA_TLX_2G_MMR:
|
|
ret.steerActuatorDelay = 0.15
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 4096], [0, 4096]]
|
|
ret.lateralTuning.pid.kpBP, ret.lateralTuning.pid.kpV = [[0, 10], [0.05, 0.5]]
|
|
ret.lateralTuning.pid.kiBP, ret.lateralTuning.pid.kiV = [[0, 10], [0.0125, 0.125]]
|
|
|
|
elif candidate == CAR.HONDA_CLARITY:
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 2560], [0, 2560]]
|
|
ret.lateralTuning.pid.kpV, ret.lateralTuning.pid.kiV = [[0.8], [0.24]]
|
|
|
|
else:
|
|
ret.steerActuatorDelay = 0.15
|
|
ret.lateralParams.torqueBP, ret.lateralParams.torqueV = [[0, 2560], [0, 2560]]
|
|
CarInterfaceBase.configure_torque_tune(candidate, ret.lateralTuning)
|
|
|
|
if candidate == CAR.HONDA_PILOT_4G:
|
|
CarControllerParams.BOSCH_GAS_LOOKUP_V = [0, 2200]
|
|
elif candidate == CAR.ACURA_RDX_3G:
|
|
CarControllerParams.BOSCH_GAS_LOOKUP_V = [0, 2200]
|
|
elif candidate == CAR.HONDA_CRV_6G and ret.flags & HondaFlags.HYBRID:
|
|
CarControllerParams.BOSCH_GAS_LOOKUP_BP = [-0.3, 2.0]
|
|
|
|
# These cars use alternate user brake msg (0x1BE)
|
|
if 0x1BE in fingerprint[CAN.pt] and candidate in HONDA_BOSCH:
|
|
ret.flags |= HondaFlags.BOSCH_ALT_BRAKE.value
|
|
|
|
if ret.flags & HondaFlags.BOSCH_ALT_BRAKE:
|
|
ret.safetyConfigs[-1].safetyParam |= HondaSafetyFlags.ALT_BRAKE.value
|
|
if candidate in HONDA_NIDEC_ALT_SCM_MESSAGES:
|
|
ret.safetyConfigs[-1].safetyParam |= HondaSafetyFlags.NIDEC_ALT.value
|
|
if ret.openpilotLongitudinalControl and candidate in HONDA_BOSCH:
|
|
ret.safetyConfigs[-1].safetyParam |= HondaSafetyFlags.BOSCH_LONG.value
|
|
if candidate in HONDA_BOSCH_RADARLESS:
|
|
ret.safetyConfigs[-1].safetyParam |= HondaSafetyFlags.RADARLESS.value
|
|
if candidate in HONDA_BOSCH_CANFD:
|
|
ret.safetyConfigs[-1].safetyParam |= HondaSafetyFlags.BOSCH_CANFD.value
|
|
|
|
# min speed to enable ACC. if car can do stop and go, then set enabling speed
|
|
# to a negative value, so it won't matter. Otherwise, add 0.5 mph margin to not
|
|
# conflict with PCM acc
|
|
if (ret.transmissionType == TransmissionType.manual) and (not ret.openpilotLongitudinalControl):
|
|
ret.autoResumeSng = False
|
|
else:
|
|
ret.autoResumeSng = candidate in (HONDA_BOSCH | {CAR.HONDA_CIVIC})
|
|
if ret.autoResumeSng:
|
|
ret.minEnableSpeed = -1.
|
|
elif candidate == CAR.HONDA_ODYSSEY_TWN:
|
|
ret.minEnableSpeed = 19. * CV.MPH_TO_MS
|
|
else:
|
|
ret.minEnableSpeed = 25.51 * CV.MPH_TO_MS
|
|
|
|
ret.steerLimitTimer = 0.8
|
|
ret.radarDelay = 0.1
|
|
|
|
return ret
|
|
|
|
@staticmethod
|
|
def _get_params_iq(stock_cp: structs.CarParams, ret: structs.IQCarParams, candidate, fingerprint: dict[int, dict[int, int]],
|
|
car_fw: list[structs.CarParams.CarFw], alpha_long: bool, is_release_iq: bool, docs: bool) -> structs.IQCarParams:
|
|
CAN = CanBus(stock_cp, fingerprint)
|
|
|
|
for fw in car_fw:
|
|
if fw.ecu == "eps" and b"," in fw.fwVersion:
|
|
ret.flags |= HondaFlagsIQ.EPS_MODIFIED.value
|
|
stock_cp.dashcamOnly = False
|
|
|
|
if bool(stock_cp.flags & HondaFlags.NIDEC) and bool(stock_cp.flags & HondaFlags.HYBRID):
|
|
ret.flags |= HondaFlagsIQ.NIDEC_HYBRID.value
|
|
ret.iqSafetyFlags |= HondaSafetyFlagsIQ.NIDEC_HYBRID
|
|
# some hybrids use a different brake hold
|
|
if 0x223 in fingerprint[CAN.pt]:
|
|
ret.flags |= HondaFlagsIQ.HYBRID_ALT_BRAKEHOLD.value
|
|
|
|
if 0x35E in fingerprint[CAN.pt]:
|
|
ret.flags |= HondaFlagsIQ.HAS_CAMERA_MESSAGES.value
|
|
|
|
if candidate == CAR.HONDA_CIVIC:
|
|
if ret.flags & HondaFlagsIQ.EPS_MODIFIED:
|
|
# stock request input values: 0x0000, 0x00DE, 0x014D, 0x01EF, 0x0290, 0x0377, 0x0454, 0x0610, 0x06EE
|
|
# stock request output values: 0x0000, 0x0917, 0x0DC5, 0x1017, 0x119F, 0x140B, 0x1680, 0x1680, 0x1680
|
|
# modified request output values: 0x0000, 0x0917, 0x0DC5, 0x1017, 0x119F, 0x140B, 0x1680, 0x2880, 0x3180
|
|
# stock filter output values: 0x009F, 0x0108, 0x0108, 0x0108, 0x0108, 0x0108, 0x0108, 0x0108, 0x0108
|
|
# modified filter output values: 0x009F, 0x0108, 0x0108, 0x0108, 0x0108, 0x0108, 0x0108, 0x0400, 0x0480
|
|
# note: max request allowed is 4096, but request is capped at 3840 in firmware, so modifications result in 2x max
|
|
stock_cp.lateralParams.torqueBP, stock_cp.lateralParams.torqueV = [[0, 2560, 8000], [0, 2560, 3840]]
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.3], [0.1]]
|
|
|
|
elif candidate in (CAR.HONDA_CIVIC_BOSCH, CAR.HONDA_CIVIC_BOSCH_DIESEL):
|
|
if ret.flags & HondaFlagsIQ.EPS_MODIFIED:
|
|
stock_cp.lateralParams.torqueBP, stock_cp.lateralParams.torqueV = [[0, 2564, 8000], [0, 2564, 3840]]
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.3], [0.09]] # 2.5x Modded EPS
|
|
|
|
elif candidate == CAR.HONDA_CIVIC_2022:
|
|
if ret.flags & HondaFlagsIQ.EPS_MODIFIED:
|
|
stock_cp.lateralParams.torqueBP, stock_cp.lateralParams.torqueV = [[0, 2564, 8000], [0, 2564, 3840]]
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.3], [0.09]] # 2.5x Modded EPS
|
|
|
|
elif candidate == CAR.HONDA_ACCORD:
|
|
if ret.flags & HondaFlagsIQ.EPS_MODIFIED:
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.3], [0.09]]
|
|
|
|
elif candidate == CAR.HONDA_CRV_5G:
|
|
if ret.flags & HondaFlagsIQ.EPS_MODIFIED:
|
|
# stock request input values: 0x0000, 0x00DB, 0x01BB, 0x0296, 0x0377, 0x0454, 0x0532, 0x0610, 0x067F
|
|
# stock request output values: 0x0000, 0x0500, 0x0A15, 0x0E6D, 0x1100, 0x1200, 0x129A, 0x134D, 0x1400
|
|
# modified request output values: 0x0000, 0x0500, 0x0A15, 0x0E6D, 0x1100, 0x1200, 0x1ACD, 0x239A, 0x2800
|
|
stock_cp.lateralParams.torqueBP, stock_cp.lateralParams.torqueV = [[0, 2560, 10000], [0, 2560, 3840]]
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.21], [0.07]]
|
|
|
|
elif candidate == CAR.HONDA_CLARITY:
|
|
stock_cp.autoResumeSng = True
|
|
stock_cp.minEnableSpeed = -1
|
|
if ret.flags & HondaFlagsIQ.EPS_MODIFIED:
|
|
for fw in car_fw:
|
|
if fw.ecu == "eps" and b"-" not in fw.fwVersion and b"," in fw.fwVersion:
|
|
stock_cp.lateralTuning.pid.kf = 0.00004
|
|
stock_cp.lateralParams.torqueBP, stock_cp.lateralParams.torqueV = [[0, 5760, 15360], [0, 2560, 3840]]
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.1575], [0.05175]]
|
|
elif fw.ecu == "eps" and b"-" in fw.fwVersion and b"," in fw.fwVersion:
|
|
stock_cp.lateralParams.torqueBP, stock_cp.lateralParams.torqueV = [[0, 5760, 10240], [0, 2560, 3840]]
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.3], [0.1]]
|
|
else:
|
|
stock_cp.lateralParams.torqueBP, stock_cp.lateralParams.torqueV = [[0, 2560], [0, 2560]]
|
|
stock_cp.lateralTuning.pid.kpV, stock_cp.lateralTuning.pid.kiV = [[0.8], [0.24]]
|
|
|
|
if candidate in HONDA_BOSCH:
|
|
pass
|
|
else:
|
|
ret.enableGasInterceptor = 0x201 in fingerprint[CAN.pt]
|
|
stock_cp.pcmCruise = not ret.enableGasInterceptor
|
|
|
|
if ret.enableGasInterceptor and candidate not in HONDA_BOSCH:
|
|
ret.iqSafetyFlags |= HondaSafetyFlagsIQ.GAS_INTERCEPTOR
|
|
|
|
stock_cp.autoResumeSng = stock_cp.autoResumeSng or ret.enableGasInterceptor
|
|
|
|
if candidate == CAR.HONDA_CITY_7G:
|
|
ret.longitudinalStoppingSpeedOverride = 2.0
|
|
ret.stoppingDecelRateOverride = 0.3
|
|
else:
|
|
ret.longitudinalStoppingSpeedOverride = 0.5
|
|
ret.stoppingDecelRateOverride = 0.1
|
|
|
|
return ret
|
|
|
|
@staticmethod
|
|
def init(CP, CP_IQ, can_recv, can_send, communication_control=None):
|
|
if CP.carFingerprint in (HONDA_BOSCH - HONDA_BOSCH_RADARLESS) and CP.openpilotLongitudinalControl:
|
|
if communication_control is None and CP.carFingerprint in HONDA_BOSCH_CANFD:
|
|
# CAN FD: only clear DTCs here; the radar silencing itself is deferred to CarController until
|
|
# the comma relay is confirmed open. init() runs while the panda is still in the ELM327 safety
|
|
# mode, and silencing the radar from here raced the safety-mode switch: whenever the switch
|
|
# took longer than ~110 ms after radar silence, the brake module latched CRUISE_FAULT for the
|
|
# entire drive.
|
|
#
|
|
# The brake module's radar lost-communication DTC matures over trips (Honda two-trip
|
|
# detection): once confirmed from a previous drive, the very next comm-loss detection faults
|
|
# ~0.16 s after the radar goes silent. Broadcast-clear stored DTCs on the powertrain and
|
|
# camera buses every drive to reset the maturation counter, and clear the radar's own stored
|
|
# DTCs so codes accumulated while it was disabled don't re-fault a later drive. Clearing must
|
|
# precede the radar silence because a DTC clear can take an ECU several hundred ms.
|
|
# NOTE: ELM327 safety mode allows the 29-bit functional diagnostic address on every bus, so
|
|
# the broadcast needs no TX allowlist entry in the car safety mode
|
|
clear_all_dtcs(can_send, [CanBus(CP).pt, CanBus(CP).camera])
|
|
clear_ecu_dtcs(can_recv, can_send, bus=CanBus(CP).pt, addr=0x18DAB0F1)
|
|
else:
|
|
# 0x80 silences response
|
|
if communication_control is None:
|
|
communication_control = bytes([uds.SERVICE_TYPE.COMMUNICATION_CONTROL, 0x80 | uds.CONTROL_TYPE.DISABLE_RX_DISABLE_TX,
|
|
uds.MESSAGE_TYPE.NORMAL_AND_NETWORK_MANAGEMENT])
|
|
disable_ecu(can_recv, can_send, bus=CanBus(CP).pt, addr=0x18DAB0F1, com_cont_req=communication_control)
|
|
|
|
@staticmethod
|
|
def deinit(CP, can_recv, can_send):
|
|
communication_control = bytes([uds.SERVICE_TYPE.COMMUNICATION_CONTROL, 0x80 | uds.CONTROL_TYPE.ENABLE_RX_ENABLE_TX,
|
|
uds.MESSAGE_TYPE.NORMAL_AND_NETWORK_MANAGEMENT])
|
|
CarInterface.init(CP, None, can_recv, can_send, communication_control)
|