mawei/sunnypilot
1
0
Fork 0
mirror of https://github.com/sunnypilot/sunnypilot.git synced 2026-02-18 21:14:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

Car interfaces: remove hard-coded signal definitions (#27773)

Browse Source 
* What if: no signals! 🙅🤌🎆

* do hyundai

* honda!

* do gm

* and vw! (sorry comments)

* do those

* -500

* little more

* fix subie

* change back

* bumpopendbc

* oof lol

* messages

* some clean up

* here too

* clean up honda radar_interface.py

fix

rm

* bump opendbc to master

* add todo

* rename checks in tesla/radar_interface

---------

Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>
old-commit-hash: cbfcc40571
This commit is contained in:
Shane Smiskol
2023-08-10 20:30:35 -07:00
committed by GitHub
parent a0e9fe94d2
commit 151b707901
20 changed files with 199 additions and 1457 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
opendbc

Submodule opendbc updated: df9c11ddc1...a1582f5e28

24
selfdrive/car/body/carstate.py
View File

@@ -32,29 +32,9 @@ class CarState(CarStateBase):
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("SPEED_L", "MOTORS_DATA"),
("SPEED_R", "MOTORS_DATA"),
("ELEC_ANGLE_L", "MOTORS_DATA"),
("ELEC_ANGLE_R", "MOTORS_DATA"),
("COUNTER", "MOTORS_DATA"),
("CHECKSUM", "MOTORS_DATA"),
("IGNITION", "VAR_VALUES"),
("ENABLE_MOTORS", "VAR_VALUES"),
("FAULT", "VAR_VALUES"),
("MOTOR_ERR_L", "VAR_VALUES"),
("MOTOR_ERR_R", "VAR_VALUES"),
("MCU_TEMP", "BODY_DATA"),
("BATT_VOLTAGE", "BODY_DATA"),
("BATT_PERCENTAGE", "BODY_DATA"),
("CHARGER_CONNECTED", "BODY_DATA"),
]
checks = [
messages = [
("MOTORS_DATA", 100),
("VAR_VALUES", 10),
("BODY_DATA", 1),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 0)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)

82
selfdrive/car/chrysler/carstate.py
View File

@@ -98,51 +98,16 @@ class CarState(CarStateBase):
return ret
@staticmethod
def get_cruise_signals():
signals = [
("ACC_AVAILABLE", "DAS_3"),
("ACC_ACTIVE", "DAS_3"),
("ACC_FAULTED", "DAS_3"),
("ACC_STANDSTILL", "DAS_3"),
("COUNTER", "DAS_3"),
("ACC_SET_SPEED_KPH", "DAS_4"),
("ACC_STATE", "DAS_4"),
]
checks = [
def get_cruise_messages():
messages = [
("DAS_3", 50),
("DAS_4", 50),
]
return signals, checks
return messages
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("DOOR_OPEN_FL", "BCM_1"),
("DOOR_OPEN_FR", "BCM_1"),
("DOOR_OPEN_RL", "BCM_1"),
("DOOR_OPEN_RR", "BCM_1"),
("Brake_Pedal_State", "ESP_1"),
("Accelerator_Position", "ECM_5"),
("WHEEL_SPEED_FL", "ESP_6"),
("WHEEL_SPEED_RR", "ESP_6"),
("WHEEL_SPEED_RL", "ESP_6"),
("WHEEL_SPEED_FR", "ESP_6"),
("STEERING_ANGLE", "STEERING"),
("STEERING_ANGLE_HP", "STEERING"),
("STEERING_RATE", "STEERING"),
("TURN_SIGNALS", "STEERING_LEVERS"),
("HIGH_BEAM_PRESSED", "STEERING_LEVERS"),
("SEATBELT_DRIVER_UNLATCHED", "ORC_1"),
("COUNTER", "EPS_2",),
("COLUMN_TORQUE", "EPS_2"),
("EPS_TORQUE_MOTOR", "EPS_2"),
("LKAS_TEMPORARY_FAULT", "EPS_2"),
("LKAS_STATE", "EPS_2"),
("COUNTER", "CRUISE_BUTTONS"),
]
checks = [
messages = [
# sig_address, frequency
("ESP_1", 50),
("EPS_2", 100),
@@ -156,53 +121,30 @@ class CarState(CarStateBase):
]
if CP.enableBsm:
signals += [
("RIGHT_STATUS", "BSM_1"),
("LEFT_STATUS", "BSM_1"),
]
checks.append(("BSM_1", 2))
messages.append(("BSM_1", 2))
if CP.carFingerprint in RAM_CARS:
signals += [
("DASM_FAULT", "EPS_3"),
("Vehicle_Speed", "ESP_8"),
("Gear_State", "Transmission_Status"),
]
checks += [
messages += [
("ESP_8", 50),
("EPS_3", 50),
("Transmission_Status", 50),
]
else:
signals += [
("PRNDL", "GEAR"),
("SPEED_LEFT", "SPEED_1"),
("SPEED_RIGHT", "SPEED_1"),
]
checks += [
messages += [
("GEAR", 50),
("SPEED_1", 100),
]
signals += CarState.get_cruise_signals()[0]
checks += CarState.get_cruise_signals()[1]
messages += CarState.get_cruise_messages()
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 0)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
@staticmethod
def get_cam_can_parser(CP):
signals = [
# sig_name, sig_address, default
("CAR_MODEL", "DAS_6"),
]
checks = [
messages = [
("DAS_6", 4),
]
if CP.carFingerprint in RAM_CARS:
signals += [
("AUTO_HIGH_BEAM_ON", "DAS_6"),
]
signals += CarState.get_cruise_signals()[0]
checks += CarState.get_cruise_signals()[1]
messages += CarState.get_cruise_messages()
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 2)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)

18
selfdrive/car/chrysler/radar_interface.py
View File

@@ -22,18 +22,12 @@ def _create_radar_can_parser(car_fingerprint):
# ('LONG_DIST', 1074),
# ('LONG_DIST', 1075),
signals = list(zip(['LONG_DIST'] * msg_n +
['LAT_DIST'] * msg_n +
['REL_SPEED'] * msg_n,
RADAR_MSGS_C * 2 + # LONG_DIST, LAT_DIST
RADAR_MSGS_D)) # REL_SPEED
messages = list(zip(RADAR_MSGS_C +
RADAR_MSGS_D,
[20] * msg_n + # 20Hz (0.05s)
[20] * msg_n)) # 20Hz (0.05s)
checks = list(zip(RADAR_MSGS_C +
RADAR_MSGS_D,
[20] * msg_n + # 20Hz (0.05s)
[20] * msg_n)) # 20Hz (0.05s)
return CANParser(DBC[car_fingerprint]['radar'], signals, checks, 1)
return CANParser(DBC[car_fingerprint]['radar'], messages, 1)
def _address_to_track(address):
if address in RADAR_MSGS_C:
@@ -89,4 +83,4 @@ class RadarInterface(RadarInterfaceBase):
ret.points = [x for x in self.pts.values() if x.dRel != 0]
self.updated_messages.clear()
return ret
return ret

147
selfdrive/car/ford/carstate.py
View File

@@ -111,70 +111,7 @@ class CarState(CarStateBase):
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("TrnAinTq_D_Qf", "VehicleOperatingModes"), # Used to detect hybrid or ICE platform variant
("Veh_V_ActlBrk", "BrakeSysFeatures"), # ABS vehicle speed (kph)
("VehYaw_W_Actl", "Yaw_Data_FD1"), # ABS vehicle yaw rate (rad/s)
("VehStop_D_Stat", "DesiredTorqBrk"), # ABS vehicle stopped
("PrkBrkStatus", "DesiredTorqBrk"), # ABS park brake status
("ApedPos_Pc_ActlArb", "EngVehicleSpThrottle"), # PCM throttle (pct)
("BrkTot_Tq_Actl", "BrakeSnData_4"), # ABS brake torque (Nm)
("BpedDrvAppl_D_Actl", "EngBrakeData"), # PCM driver brake pedal pressed
("Veh_V_DsplyCcSet", "EngBrakeData"), # PCM ACC set speed (mph)
# The units might change with IPC settings?
("CcStat_D_Actl", "EngBrakeData"), # PCM ACC status
("AccStopMde_D_Rq", "EngBrakeData"), # PCM ACC standstill
("AccEnbl_B_RqDrv", "Cluster_Info1_FD1"), # PCM ACC enable
("StePinComp_An_Est", "SteeringPinion_Data"), # PSCM estimated steering angle (deg)
("StePinCompAnEst_D_Qf", "SteeringPinion_Data"), # PSCM estimated steering angle (quality flag)
# Calculates steering angle (and offset) from pinion
# angle and driving measurements.
# StePinRelInit_An_Sns is the pinion angle, initialised
# to zero at the beginning of the drive.
("SteeringColumnTorque", "EPAS_INFO"), # PSCM steering column torque (Nm)
("EPAS_Failure", "EPAS_INFO"), # PSCM EPAS status
("TurnLghtSwtch_D_Stat", "Steering_Data_FD1"), # SCCM Turn signal switch
("TjaButtnOnOffPress", "Steering_Data_FD1"), # SCCM ACC button, lane-centering/traffic jam assist toggle
("DrStatDrv_B_Actl", "BodyInfo_3_FD1"), # BCM Door open, driver
("DrStatPsngr_B_Actl", "BodyInfo_3_FD1"), # BCM Door open, passenger
("DrStatRl_B_Actl", "BodyInfo_3_FD1"), # BCM Door open, rear left
("DrStatRr_B_Actl", "BodyInfo_3_FD1"), # BCM Door open, rear right
("FirstRowBuckleDriver", "RCMStatusMessage2_FD1"), # RCM Seatbelt status, driver
("HeadLghtHiFlash_D_Stat", "Steering_Data_FD1"), # SCCM Passthrough the remaining buttons
("WiprFront_D_Stat", "Steering_Data_FD1"),
("LghtAmb_D_Sns", "Steering_Data_FD1"),
("AccButtnGapDecPress", "Steering_Data_FD1"),
("AccButtnGapIncPress", "Steering_Data_FD1"),
("AslButtnOnOffCnclPress", "Steering_Data_FD1"),
("AslButtnOnOffPress", "Steering_Data_FD1"),
("LaSwtchPos_D_Stat", "Steering_Data_FD1"),
("CcAslButtnCnclResPress", "Steering_Data_FD1"),
("CcAslButtnDeny_B_Actl", "Steering_Data_FD1"),
("CcAslButtnIndxDecPress", "Steering_Data_FD1"),
("CcAslButtnIndxIncPress", "Steering_Data_FD1"),
("CcAslButtnOffCnclPress", "Steering_Data_FD1"),
("CcAslButtnOnOffCncl", "Steering_Data_FD1"),
("CcAslButtnOnPress", "Steering_Data_FD1"),
("CcAslButtnResDecPress", "Steering_Data_FD1"),
("CcAslButtnResIncPress", "Steering_Data_FD1"),
("CcAslButtnSetDecPress", "Steering_Data_FD1"),
("CcAslButtnSetIncPress", "Steering_Data_FD1"),
("CcAslButtnSetPress", "Steering_Data_FD1"),
("CcButtnOffPress", "Steering_Data_FD1"),
("CcButtnOnOffCnclPress", "Steering_Data_FD1"),
("CcButtnOnOffPress", "Steering_Data_FD1"),
("CcButtnOnPress", "Steering_Data_FD1"),
("HeadLghtHiFlash_D_Actl", "Steering_Data_FD1"),
("HeadLghtHiOn_B_StatAhb", "Steering_Data_FD1"),
("AhbStat_B_Dsply", "Steering_Data_FD1"),
("AccButtnGapTogglePress", "Steering_Data_FD1"),
("WiprFrontSwtch_D_Stat", "Steering_Data_FD1"),
("HeadLghtHiCtrl_D_RqAhb", "Steering_Data_FD1"),
]
checks = [
messages = [
# sig_address, frequency
("VehicleOperatingModes", 100),
("BrakeSysFeatures", 50),
@@ -192,93 +129,31 @@ class CarState(CarStateBase):
]
if CP.carFingerprint in CANFD_CAR:
signals += [
("LatCtlSte_D_Stat", "Lane_Assist_Data3_FD1"), # PSCM lateral control status
]
checks += [
messages += [
("Lane_Assist_Data3_FD1", 33),
]
if CP.transmissionType == TransmissionType.automatic:
signals += [
("TrnRng_D_RqGsm", "Gear_Shift_by_Wire_FD1"), # GWM transmission gear position
]
checks += [
messages += [
("Gear_Shift_by_Wire_FD1", 10),
]
elif CP.transmissionType == TransmissionType.manual:
signals += [
("CluPdlPos_Pc_Meas", "Engine_Clutch_Data"), # PCM clutch (pct)
("RvrseLghtOn_B_Stat", "BCM_Lamp_Stat_FD1"), # BCM reverse light
]
checks += [
messages += [
("Engine_Clutch_Data", 33),
("BCM_Lamp_Stat_FD1", 1),
]
if CP.enableBsm and CP.carFingerprint not in CANFD_CAR:
signals += [
("SodDetctLeft_D_Stat", "Side_Detect_L_Stat"), # Blindspot sensor, left
("SodDetctRight_D_Stat", "Side_Detect_R_Stat"), # Blindspot sensor, right
]
checks += [
messages += [
("Side_Detect_L_Stat", 5),
("Side_Detect_R_Stat", 5),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus(CP).main)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus(CP).main)
@staticmethod
def get_cam_can_parser(CP):
signals = [
# sig_name, sig_address
("CmbbDeny_B_Actl", "ACCDATA"), # ACC/AEB unavailable/lockout
("CmbbBrkDecel_B_Rq", "ACCDATA_2"), # AEB actuation request bit
("HaDsply_No_Cs", "ACCDATA_3"),
("HaDsply_No_Cnt", "ACCDATA_3"),
("AccStopStat_D_Dsply", "ACCDATA_3"), # ACC stopped status message
("AccTrgDist2_D_Dsply", "ACCDATA_3"), # ACC target distance
("AccStopRes_B_Dsply", "ACCDATA_3"),
("TjaWarn_D_Rq", "ACCDATA_3"), # TJA warning
("Tja_D_Stat", "ACCDATA_3"), # TJA status
("TjaMsgTxt_D_Dsply", "ACCDATA_3"), # TJA text
("IaccLamp_D_Rq", "ACCDATA_3"), # iACC status icon
("AccMsgTxt_D2_Rq", "ACCDATA_3"), # ACC text
("FcwDeny_B_Dsply", "ACCDATA_3"), # FCW disabled
("FcwMemStat_B_Actl", "ACCDATA_3"), # FCW enabled setting
("AccTGap_B_Dsply", "ACCDATA_3"), # ACC time gap display setting
("CadsAlignIncplt_B_Actl", "ACCDATA_3"),
("AccFllwMde_B_Dsply", "ACCDATA_3"), # ACC lead indicator
("CadsRadrBlck_B_Actl", "ACCDATA_3"),
("CmbbPostEvnt_B_Dsply", "ACCDATA_3"), # AEB event status
("AccStopMde_B_Dsply", "ACCDATA_3"), # ACC stop mode display setting
("FcwMemSens_D_Actl", "ACCDATA_3"), # FCW sensitivity setting
("FcwMsgTxt_D_Rq", "ACCDATA_3"), # FCW text
("AccWarn_D_Dsply", "ACCDATA_3"), # ACC warning
("FcwVisblWarn_B_Rq", "ACCDATA_3"), # FCW visible alert
("FcwAudioWarn_B_Rq", "ACCDATA_3"), # FCW audio alert
("AccTGap_D_Dsply", "ACCDATA_3"), # ACC time gap
("AccMemEnbl_B_RqDrv", "ACCDATA_3"), # ACC adaptive/normal setting
("FdaMem_B_Stat", "ACCDATA_3"), # FDA enabled setting
("FeatConfigIpmaActl", "IPMA_Data"),
("FeatNoIpmaActl", "IPMA_Data"),
("PersIndexIpma_D_Actl", "IPMA_Data"),
("AhbcRampingV_D_Rq", "IPMA_Data"), # AHB ramping
("LaDenyStats_B_Dsply", "IPMA_Data"), # LKAS error
("CamraDefog_B_Req", "IPMA_Data"), # Windshield heater?
("CamraStats_D_Dsply", "IPMA_Data"), # Camera status
("DasAlrtLvl_D_Dsply", "IPMA_Data"), # DAS alert level
("DasStats_D_Dsply", "IPMA_Data"), # DAS status
("DasWarn_D_Dsply", "IPMA_Data"), # DAS warning
("AhbHiBeam_D_Rq", "IPMA_Data"), # AHB status
("Passthru_63", "IPMA_Data"),
("Passthru_48", "IPMA_Data"),
]
checks = [
messages = [
# sig_address, frequency
("ACCDATA", 50),
("ACCDATA_2", 50),
@@ -287,13 +162,9 @@ class CarState(CarStateBase):
]
if CP.enableBsm and CP.carFingerprint in CANFD_CAR:
signals += [
("SodDetctLeft_D_Stat", "Side_Detect_L_Stat"), # Blindspot sensor, left
("SodDetctRight_D_Stat", "Side_Detect_R_Stat"), # Blindspot sensor, right
]
checks += [
messages += [
("Side_Detect_L_Stat", 5),
("Side_Detect_R_Stat", 5),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus(CP).camera)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus(CP).camera)

21
selfdrive/car/ford/radar_interface.py
View File

@@ -15,30 +15,19 @@ DELPHI_MRR_RADAR_MSG_COUNT = 64
def _create_delphi_esr_radar_can_parser(CP) -> CANParser:
msg_n = len(DELPHI_ESR_RADAR_MSGS)
signals = list(zip(['X_Rel'] * msg_n + ['Angle'] * msg_n + ['V_Rel'] * msg_n,
DELPHI_ESR_RADAR_MSGS * 3))
checks = list(zip(DELPHI_ESR_RADAR_MSGS, [20] * msg_n))
messages = list(zip(DELPHI_ESR_RADAR_MSGS, [20] * msg_n))
return CANParser(RADAR.DELPHI_ESR, signals, checks, CanBus(CP).radar)
return CANParser(RADAR.DELPHI_ESR, messages, CanBus(CP).radar)
def _create_delphi_mrr_radar_can_parser(CP) -> CANParser:
signals = []
checks = []
messages = []
for i in range(1, DELPHI_MRR_RADAR_MSG_COUNT + 1):
msg = f"MRR_Detection_{i:03d}"
signals += [
(f"CAN_DET_VALID_LEVEL_{i:02d}", msg),
(f"CAN_DET_AZIMUTH_{i:02d}", msg),
(f"CAN_DET_RANGE_{i:02d}", msg),
(f"CAN_DET_RANGE_RATE_{i:02d}", msg),
(f"CAN_DET_AMPLITUDE_{i:02d}", msg),
(f"CAN_SCAN_INDEX_2LSB_{i:02d}", msg),
]
checks += [(msg, 20)]
messages += [(msg, 20)]
return CANParser(RADAR.DELPHI_MRR, signals, checks, CanBus(CP).radar)
return CANParser(RADAR.DELPHI_MRR, messages, CanBus(CP).radar)
class RadarInterface(RadarInterfaceBase):

71
selfdrive/car/gm/carstate.py
View File

@@ -117,64 +117,19 @@ class CarState(CarStateBase):
@staticmethod
def get_cam_can_parser(CP):
signals = []
checks = []
messages = []
if CP.networkLocation == NetworkLocation.fwdCamera:
signals += [
("AEBCmdActive", "AEBCmd"),
("RollingCounter", "ASCMLKASteeringCmd"),
("ACCSpeedSetpoint", "ASCMActiveCruiseControlStatus"),
("ACCCruiseState", "ASCMActiveCruiseControlStatus"),
]
checks += [
messages += [
("AEBCmd", 10),
("ASCMLKASteeringCmd", 10),
("ASCMActiveCruiseControlStatus", 25),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus.CAMERA)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus.CAMERA)
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("BrakePedalPos", "ECMAcceleratorPos"),
("FrontLeftDoor", "BCMDoorBeltStatus"),
("FrontRightDoor", "BCMDoorBeltStatus"),
("RearLeftDoor", "BCMDoorBeltStatus"),
("RearRightDoor", "BCMDoorBeltStatus"),
("LeftSeatBelt", "BCMDoorBeltStatus"),
("RightSeatBelt", "BCMDoorBeltStatus"),
("TurnSignals", "BCMTurnSignals"),
("AcceleratorPedal2", "AcceleratorPedal2"),
("CruiseState", "AcceleratorPedal2"),
("ACCButtons", "ASCMSteeringButton"),
("RollingCounter", "ASCMSteeringButton"),
("SteeringWheelAngle", "PSCMSteeringAngle"),
("SteeringWheelRate", "PSCMSteeringAngle"),
("FLWheelSpd", "EBCMWheelSpdFront"),
("FRWheelSpd", "EBCMWheelSpdFront"),
("RLWheelSpd", "EBCMWheelSpdRear"),
("RRWheelSpd", "EBCMWheelSpdRear"),
("MovingBackward", "EBCMWheelSpdRear"),
("FrictionBrakeUnavailable", "EBCMFrictionBrakeStatus"),
("PRNDL2", "ECMPRDNL2"),
("ManualMode", "ECMPRDNL2"),
("LKADriverAppldTrq", "PSCMStatus"),
("LKATorqueDelivered", "PSCMStatus"),
("LKATorqueDeliveredStatus", "PSCMStatus"),
("HandsOffSWlDetectionStatus", "PSCMStatus"),
("HandsOffSWDetectionMode", "PSCMStatus"),
("LKATotalTorqueDelivered", "PSCMStatus"),
("PSCMStatusChecksum", "PSCMStatus"),
("RollingCounter", "PSCMStatus"),
("TractionControlOn", "ESPStatus"),
("ParkBrake", "VehicleIgnitionAlt"),
("CruiseMainOn", "ECMEngineStatus"),
("BrakePressed", "ECMEngineStatus"),
]
checks = [
messages = [
("BCMTurnSignals", 1),
("ECMPRDNL2", 10),
("PSCMStatus", 10),
@@ -193,27 +148,19 @@ class CarState(CarStateBase):
# Used to read back last counter sent to PT by camera
if CP.networkLocation == NetworkLocation.fwdCamera:
signals += [
("RollingCounter", "ASCMLKASteeringCmd"),
]
checks += [
messages += [
("ASCMLKASteeringCmd", 0),
]
if CP.transmissionType == TransmissionType.direct:
signals.append(("RegenPaddle", "EBCMRegenPaddle"))
checks.append(("EBCMRegenPaddle", 50))
messages.append(("EBCMRegenPaddle", 50))
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus.POWERTRAIN)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus.POWERTRAIN)
@staticmethod
def get_loopback_can_parser(CP):
signals = [
("RollingCounter", "ASCMLKASteeringCmd"),
]
checks = [
messages = [
("ASCMLKASteeringCmd", 0),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus.LOOPBACK)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus.LOOPBACK)

4
selfdrive/car/gm/radar_interface.py
View File

@@ -27,9 +27,9 @@ def create_radar_can_parser(car_fingerprint):
['TrkWidth'] * NUM_SLOTS + ['TrkObjectID'] * NUM_SLOTS,
[RADAR_HEADER_MSG] * 7 + radar_targets * 6))
checks = list({(s[1], 14) for s in signals})
messages = list({(s[1], 14) for s in signals})
return CANParser(DBC[car_fingerprint]['radar'], signals, checks, CanBus.OBSTACLE)
return CANParser(DBC[car_fingerprint]['radar'], messages, CanBus.OBSTACLE)
class RadarInterface(RadarInterfaceBase):

127
selfdrive/car/honda/carstate.py
View File

@@ -12,39 +12,8 @@ from selfdrive.car.interfaces import CarStateBase
TransmissionType = car.CarParams.TransmissionType
def get_can_signals(CP, gearbox_msg, main_on_sig_msg):
signals = [
("XMISSION_SPEED", "ENGINE_DATA"),
("WHEEL_SPEED_FL", "WHEEL_SPEEDS"),
("WHEEL_SPEED_FR", "WHEEL_SPEEDS"),
("WHEEL_SPEED_RL", "WHEEL_SPEEDS"),
("WHEEL_SPEED_RR", "WHEEL_SPEEDS"),
("STEER_ANGLE", "STEERING_SENSORS"),
("STEER_ANGLE_RATE", "STEERING_SENSORS"),
("MOTOR_TORQUE", "STEER_MOTOR_TORQUE"),
("STEER_TORQUE_SENSOR", "STEER_STATUS"),
("IMPERIAL_UNIT", "CAR_SPEED"),
("ROUGH_CAR_SPEED_2", "CAR_SPEED"),
("LEFT_BLINKER", "SCM_FEEDBACK"),
("RIGHT_BLINKER", "SCM_FEEDBACK"),
("SEATBELT_DRIVER_LAMP", "SEATBELT_STATUS"),
("SEATBELT_DRIVER_LATCHED", "SEATBELT_STATUS"),
("BRAKE_PRESSED", "POWERTRAIN_DATA"),
("BRAKE_SWITCH", "POWERTRAIN_DATA"),
("CRUISE_BUTTONS", "SCM_BUTTONS"),
("ESP_DISABLED", "VSA_STATUS"),
("USER_BRAKE", "VSA_STATUS"),
("BRAKE_HOLD_ACTIVE", "VSA_STATUS"),
("STEER_STATUS", "STEER_STATUS"),
("GEAR_SHIFTER", gearbox_msg),
("GEAR", gearbox_msg),
("PEDAL_GAS", "POWERTRAIN_DATA"),
("CRUISE_SETTING", "SCM_BUTTONS"),
("ACC_STATUS", "POWERTRAIN_DATA"),
("MAIN_ON", main_on_sig_msg),
]
checks = [
def get_can_messages(CP, gearbox_msg):
messages = [
("ENGINE_DATA", 100),
("WHEEL_SPEEDS", 50),
("STEERING_SENSORS", 100),
@@ -58,80 +27,59 @@ def get_can_signals(CP, gearbox_msg, main_on_sig_msg):
]
if CP.carFingerprint == CAR.ODYSSEY_CHN:
checks += [
messages += [
("SCM_FEEDBACK", 25),
("SCM_BUTTONS", 50),
]
else:
checks += [
messages += [
("SCM_FEEDBACK", 10),
("SCM_BUTTONS", 25),
]
if CP.carFingerprint in (CAR.CRV_HYBRID, CAR.CIVIC_BOSCH_DIESEL, CAR.ACURA_RDX_3G, CAR.HONDA_E):
checks.append((gearbox_msg, 50))
messages.append((gearbox_msg, 50))
else:
checks.append((gearbox_msg, 100))
messages.append((gearbox_msg, 100))
if CP.carFingerprint in HONDA_BOSCH_ALT_BRAKE_SIGNAL:
signals.append(("BRAKE_PRESSED", "BRAKE_MODULE"))
checks.append(("BRAKE_MODULE", 50))
messages.append(("BRAKE_MODULE", 50))
if CP.carFingerprint in (HONDA_BOSCH | {CAR.CIVIC, CAR.ODYSSEY, CAR.ODYSSEY_CHN}):
signals.append(("EPB_STATE", "EPB_STATUS"))
checks.append(("EPB_STATUS", 50))
messages.append(("EPB_STATUS", 50))
if CP.carFingerprint in HONDA_BOSCH:
# these messages are on camera bus on radarless cars
if not CP.openpilotLongitudinalControl and CP.carFingerprint not in HONDA_BOSCH_RADARLESS:
signals += [
("CRUISE_CONTROL_LABEL", "ACC_HUD"),
("CRUISE_SPEED", "ACC_HUD"),
("ACCEL_COMMAND", "ACC_CONTROL"),
("AEB_STATUS", "ACC_CONTROL"),
]
checks += [
messages += [
("ACC_HUD", 10),
("ACC_CONTROL", 50),
]
else: # Nidec signals
signals += [("CRUISE_SPEED_PCM", "CRUISE"),
("CRUISE_SPEED_OFFSET", "CRUISE_PARAMS")]
if CP.carFingerprint == CAR.ODYSSEY_CHN:
checks.append(("CRUISE_PARAMS", 10))
messages.append(("CRUISE_PARAMS", 10))
else:
checks.append(("CRUISE_PARAMS", 50))
messages.append(("CRUISE_PARAMS", 50))
# TODO: clean this up
if CP.carFingerprint in (CAR.ACCORD, CAR.ACCORDH, CAR.CIVIC_BOSCH, CAR.CIVIC_BOSCH_DIESEL, CAR.CRV_HYBRID, CAR.INSIGHT,
CAR.ACURA_RDX_3G, CAR.HONDA_E, CAR.CIVIC_2022, CAR.HRV_3G):
signals.append(("DRIVERS_DOOR_OPEN", "SCM_FEEDBACK"))
pass
elif CP.carFingerprint in (CAR.ODYSSEY_CHN, CAR.FREED, CAR.HRV):
signals.append(("DRIVERS_DOOR_OPEN", "SCM_BUTTONS"))
pass
else:
signals += [("DOOR_OPEN_FL", "DOORS_STATUS"),
("DOOR_OPEN_FR", "DOORS_STATUS"),
("DOOR_OPEN_RL", "DOORS_STATUS"),
("DOOR_OPEN_RR", "DOORS_STATUS")]
checks.append(("DOORS_STATUS", 3))
messages.append(("DOORS_STATUS", 3))
# add gas interceptor reading if we are using it
if CP.enableGasInterceptor:
signals.append(("INTERCEPTOR_GAS", "GAS_SENSOR"))
signals.append(("INTERCEPTOR_GAS2", "GAS_SENSOR"))
checks.append(("GAS_SENSOR", 50))
messages.append(("GAS_SENSOR", 50))
if CP.carFingerprint in HONDA_BOSCH_RADARLESS:
signals.append(("CRUISE_FAULT", "CRUISE_FAULT_STATUS"))
checks.append(("CRUISE_FAULT_STATUS", 50))
messages.append(("CRUISE_FAULT_STATUS", 50))
elif CP.openpilotLongitudinalControl:
signals += [
("BRAKE_ERROR_1", "STANDSTILL"),
("BRAKE_ERROR_2", "STANDSTILL")
]
checks.append(("STANDSTILL", 50))
messages.append(("STANDSTILL", 50))
return signals, checks
return messages
class CarState(CarStateBase):
@@ -316,55 +264,36 @@ class CarState(CarStateBase):
return ret
def get_can_parser(self, CP):
signals, checks = get_can_signals(CP, self.gearbox_msg, self.main_on_sig_msg)
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, get_pt_bus(CP.carFingerprint))
messages = get_can_messages(CP, self.gearbox_msg)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, get_pt_bus(CP.carFingerprint))
@staticmethod
def get_cam_can_parser(CP):
signals = []
checks = [
messages = [
("STEERING_CONTROL", 100),
]
if CP.carFingerprint in HONDA_BOSCH_RADARLESS:
signals.append(("LKAS_PROBLEM", "LKAS_HUD"))
checks.append(("LKAS_HUD", 10))
messages.append(("LKAS_HUD", 10))
if not CP.openpilotLongitudinalControl:
signals += [
("CRUISE_SPEED", "ACC_HUD"),
("CRUISE_CONTROL_LABEL", "ACC_HUD"),
]
checks.append(("ACC_HUD", 10))
messages.append(("ACC_HUD", 10))
elif CP.carFingerprint not in HONDA_BOSCH:
signals += [("COMPUTER_BRAKE", "BRAKE_COMMAND"),
("AEB_REQ_1", "BRAKE_COMMAND"),
("FCW", "BRAKE_COMMAND"),
("CHIME", "BRAKE_COMMAND"),
("LKAS_PROBLEM", "LKAS_HUD"),
("FCM_OFF", "ACC_HUD"),
("FCM_OFF_2", "ACC_HUD"),
("FCM_PROBLEM", "ACC_HUD"),
("ACC_PROBLEM", "ACC_HUD"),
("ICONS", "ACC_HUD")]
checks += [
messages += [
("ACC_HUD", 10),
("LKAS_HUD", 10),
("BRAKE_COMMAND", 50),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 2)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)
@staticmethod
def get_body_can_parser(CP):
if CP.enableBsm:
signals = [("BSM_ALERT", "BSM_STATUS_RIGHT"),
("BSM_ALERT", "BSM_STATUS_LEFT")]
checks = [
messages = [
("BSM_STATUS_LEFT", 3),
("BSM_STATUS_RIGHT", 3),
]
bus_body = 0 # B-CAN is forwarded to ACC-CAN radar side (CAN 0 on fake ethernet port)
return CANParser(DBC[CP.carFingerprint]["body"], signals, checks, bus_body)
return CANParser(DBC[CP.carFingerprint]["body"], messages, bus_body)
return None

8
selfdrive/car/honda/radar_interface.py
View File

@@ -7,12 +7,8 @@ from selfdrive.car.honda.values import DBC
def _create_nidec_can_parser(car_fingerprint):
radar_messages = [0x400] + list(range(0x430, 0x43A)) + list(range(0x440, 0x446))
signals = list(zip(['RADAR_STATE'] +
['LONG_DIST'] * 16 + ['NEW_TRACK'] * 16 + ['LAT_DIST'] * 16 +
['REL_SPEED'] * 16,
[0x400] + radar_messages[1:] * 4))
checks = [(s[1], 20) for s in signals]
return CANParser(DBC[car_fingerprint]['radar'], signals, checks, 1)
messages = [(m, 20) for m in radar_messages]
return CANParser(DBC[car_fingerprint]['radar'], messages, 1)
class RadarInterface(RadarInterfaceBase):

246
selfdrive/car/hyundai/carstate.py
View File

@@ -234,62 +234,7 @@ class CarState(CarStateBase):
if CP.carFingerprint in CANFD_CAR:
return CarState.get_can_parser_canfd(CP)
signals = [
# signal_name, signal_address
("WHL_SPD_FL", "WHL_SPD11"),
("WHL_SPD_FR", "WHL_SPD11"),
("WHL_SPD_RL", "WHL_SPD11"),
("WHL_SPD_RR", "WHL_SPD11"),
("YAW_RATE", "ESP12"),
("CF_Gway_DrvSeatBeltInd", "CGW4"),
("CF_Gway_DrvSeatBeltSw", "CGW1"),
("CF_Gway_DrvDrSw", "CGW1"), # Driver Door
("CF_Gway_AstDrSw", "CGW1"), # Passenger Door
("CF_Gway_RLDrSw", "CGW2"), # Rear left Door
("CF_Gway_RRDrSw", "CGW2"), # Rear right Door
("CF_Gway_TurnSigLh", "CGW1"),
("CF_Gway_TurnSigRh", "CGW1"),
("CF_Gway_ParkBrakeSw", "CGW1"),
("CYL_PRES", "ESP12"),
("CF_Clu_CruiseSwState", "CLU11"),
("CF_Clu_CruiseSwMain", "CLU11"),
("CF_Clu_SldMainSW", "CLU11"),
("CF_Clu_ParityBit1", "CLU11"),
("CF_Clu_VanzDecimal" , "CLU11"),
("CF_Clu_Vanz", "CLU11"),
("CF_Clu_SPEED_UNIT", "CLU11"),
("CF_Clu_DetentOut", "CLU11"),
("CF_Clu_RheostatLevel", "CLU11"),
("CF_Clu_CluInfo", "CLU11"),
("CF_Clu_AmpInfo", "CLU11"),
("CF_Clu_AliveCnt1", "CLU11"),
("CF_Clu_VehicleSpeed", "CLU15"),
("ACCEnable", "TCS13"),
("ACC_REQ", "TCS13"),
("DriverBraking", "TCS13"),
("StandStill", "TCS13"),
("PBRAKE_ACT", "TCS13"),
("ESC_Off_Step", "TCS15"),
("AVH_LAMP", "TCS15"),
("CR_Mdps_StrColTq", "MDPS12"),
("CF_Mdps_ToiActive", "MDPS12"),
("CF_Mdps_ToiUnavail", "MDPS12"),
("CF_Mdps_ToiFlt", "MDPS12"),
("CR_Mdps_OutTq", "MDPS12"),
("SAS_Angle", "SAS11"),
("SAS_Speed", "SAS11"),
]
checks = [
messages = [
# address, frequency
("MDPS12", 50),
("TCS13", 50),
@@ -305,163 +250,61 @@ class CarState(CarStateBase):
]
if not CP.openpilotLongitudinalControl and CP.carFingerprint not in CAMERA_SCC_CAR:
signals += [
("MainMode_ACC", "SCC11"),
("VSetDis", "SCC11"),
("SCCInfoDisplay", "SCC11"),
("ACC_ObjDist", "SCC11"),
("ACCMode", "SCC12"),
]
checks += [
messages += [
("SCC11", 50),
("SCC12", 50),
]
if CP.flags & HyundaiFlags.USE_FCA.value:
signals += [
("FCA_CmdAct", "FCA11"),
("CF_VSM_Warn", "FCA11"),
("CF_VSM_DecCmdAct", "FCA11"),
]
checks.append(("FCA11", 50))
else:
signals += [
("AEB_CmdAct", "SCC12"),
("CF_VSM_Warn", "SCC12"),
("CF_VSM_DecCmdAct", "SCC12"),
]
messages.append(("FCA11", 50))
if CP.enableBsm:
signals += [
("CF_Lca_IndLeft", "LCA11"),
("CF_Lca_IndRight", "LCA11"),
]
checks.append(("LCA11", 50))
messages.append(("LCA11", 50))
if CP.carFingerprint in (HYBRID_CAR | EV_CAR):
if CP.carFingerprint in HYBRID_CAR:
signals.append(("CR_Vcu_AccPedDep_Pos", "E_EMS11"))
else:
signals.append(("Accel_Pedal_Pos", "E_EMS11"))
checks.append(("E_EMS11", 50))
messages.append(("E_EMS11", 50))
else:
signals += [
("PV_AV_CAN", "EMS12"),
("CF_Ems_AclAct", "EMS16"),
]
checks += [
messages += [
("EMS12", 100),
("EMS16", 100),
]
if CP.carFingerprint in CAN_GEARS["use_cluster_gears"]:
signals.append(("CF_Clu_Gear", "CLU15"))
pass
elif CP.carFingerprint in CAN_GEARS["use_tcu_gears"]:
signals.append(("CUR_GR", "TCU12"))
checks.append(("TCU12", 100))
messages.append(("TCU12", 100))
elif CP.carFingerprint in CAN_GEARS["use_elect_gears"]:
signals.append(("Elect_Gear_Shifter", "ELECT_GEAR"))
checks.append(("ELECT_GEAR", 20))
messages.append(("ELECT_GEAR", 20))
else:
signals.append(("CF_Lvr_Gear", "LVR12"))
checks.append(("LVR12", 100))
messages.append(("LVR12", 100))
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 0)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
@staticmethod
def get_cam_can_parser(CP):
if CP.carFingerprint in CANFD_CAR:
return CarState.get_cam_can_parser_canfd(CP)
signals = [
# signal_name, signal_address
("CF_Lkas_LdwsActivemode", "LKAS11"),
("CF_Lkas_LdwsSysState", "LKAS11"),
("CF_Lkas_SysWarning", "LKAS11"),
("CF_Lkas_LdwsLHWarning", "LKAS11"),
("CF_Lkas_LdwsRHWarning", "LKAS11"),
("CF_Lkas_HbaLamp", "LKAS11"),
("CF_Lkas_FcwBasReq", "LKAS11"),
("CF_Lkas_HbaSysState", "LKAS11"),
("CF_Lkas_FcwOpt", "LKAS11"),
("CF_Lkas_HbaOpt", "LKAS11"),
("CF_Lkas_FcwSysState", "LKAS11"),
("CF_Lkas_FcwCollisionWarning", "LKAS11"),
("CF_Lkas_FusionState", "LKAS11"),
("CF_Lkas_FcwOpt_USM", "LKAS11"),
("CF_Lkas_LdwsOpt_USM", "LKAS11"),
]
checks = [
messages = [
("LKAS11", 100)
]
if not CP.openpilotLongitudinalControl and CP.carFingerprint in CAMERA_SCC_CAR:
signals += [
("MainMode_ACC", "SCC11"),
("VSetDis", "SCC11"),
("SCCInfoDisplay", "SCC11"),
("ACC_ObjDist", "SCC11"),
("ACCMode", "SCC12"),
]
checks += [
messages += [
("SCC11", 50),
("SCC12", 50),
]
if CP.flags & HyundaiFlags.USE_FCA.value:
signals += [
("FCA_CmdAct", "FCA11"),
("CF_VSM_Warn", "FCA11"),
("CF_VSM_DecCmdAct", "FCA11"),
]
checks.append(("FCA11", 50))
else:
signals += [
("AEB_CmdAct", "SCC12"),
("CF_VSM_Warn", "SCC12"),
("CF_VSM_DecCmdAct", "SCC12"),
]
messages.append(("FCA11", 50))
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 2)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)
@staticmethod
def get_can_parser_canfd(CP):
cruise_btn_msg = "CRUISE_BUTTONS_ALT" if CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS else "CRUISE_BUTTONS"
gear_msg = "GEAR_ALT_2" if CP.flags & HyundaiFlags.CANFD_ALT_GEARS_2 else \
"GEAR_ALT" if CP.flags & HyundaiFlags.CANFD_ALT_GEARS else \
"GEAR_SHIFTER"
signals = [
("WHEEL_SPEED_1", "WHEEL_SPEEDS"),
("WHEEL_SPEED_2", "WHEEL_SPEEDS"),
("WHEEL_SPEED_3", "WHEEL_SPEEDS"),
("WHEEL_SPEED_4", "WHEEL_SPEEDS"),
("GEAR", gear_msg),
("STEERING_RATE", "STEERING_SENSORS"),
("STEERING_ANGLE", "STEERING_SENSORS"),
("STEERING_COL_TORQUE", "MDPS"),
("STEERING_OUT_TORQUE", "MDPS"),
("LKA_FAULT", "MDPS"),
("DriverBraking", "TCS"),
("ACCEnable", "TCS"),
("ACC_REQ", "TCS"),
("COUNTER", cruise_btn_msg),
("CRUISE_BUTTONS", cruise_btn_msg),
("ADAPTIVE_CRUISE_MAIN_BTN", cruise_btn_msg),
("DISTANCE_UNIT", "CRUISE_BUTTONS_ALT"),
("LEFT_LAMP", "BLINKERS"),
("RIGHT_LAMP", "BLINKERS"),
("DRIVER_DOOR", "DOORS_SEATBELTS"),
("DRIVER_SEATBELT", "DOORS_SEATBELTS"),
]
checks = [
messages = [
("WHEEL_SPEEDS", 100),
(gear_msg, 100),
("STEERING_SENSORS", 100),
@@ -473,76 +316,41 @@ class CarState(CarStateBase):
]
if not (CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS):
checks.append(("CRUISE_BUTTONS", 50))
messages.append(("CRUISE_BUTTONS", 50))
if CP.enableBsm:
signals += [
("FL_INDICATOR", "BLINDSPOTS_REAR_CORNERS"),
("FR_INDICATOR", "BLINDSPOTS_REAR_CORNERS"),
]
checks += [
messages += [
("BLINDSPOTS_REAR_CORNERS", 20),
]
if not (CP.flags & HyundaiFlags.CANFD_CAMERA_SCC.value) and not CP.openpilotLongitudinalControl:
signals += [
("COUNTER", "SCC_CONTROL"),
("CHECKSUM", "SCC_CONTROL"),
("ACCMode", "SCC_CONTROL"),
("VSetDis", "SCC_CONTROL"),
("CRUISE_STANDSTILL", "SCC_CONTROL"),
]
checks += [
messages += [
("SCC_CONTROL", 50),
]
if CP.carFingerprint in EV_CAR:
signals += [
("ACCELERATOR_PEDAL", "ACCELERATOR"),
]
checks += [
messages += [
("ACCELERATOR", 100),
]
elif CP.carFingerprint in HYBRID_CAR:
signals += [
("ACCELERATOR_PEDAL", "ACCELERATOR_ALT"),
]
checks += [
messages += [
("ACCELERATOR_ALT", 100),
]
else:
signals += [
("ACCELERATOR_PEDAL_PRESSED", "ACCELERATOR_BRAKE_ALT"),
]
checks += [
messages += [
("ACCELERATOR_BRAKE_ALT", 100),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus(CP).ECAN)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus(CP).ECAN)
@staticmethod
def get_cam_can_parser_canfd(CP):
signals = []
checks = []
messages = []
if CP.flags & HyundaiFlags.CANFD_HDA2:
signals += [(f"BYTE{i}", "CAM_0x2a4") for i in range(3, 24)]
checks += [("CAM_0x2a4", 20)]
messages += [("CAM_0x2a4", 20)]
elif CP.flags & HyundaiFlags.CANFD_CAMERA_SCC:
signals += [
("COUNTER", "SCC_CONTROL"),
("CHECKSUM", "SCC_CONTROL"),
("NEW_SIGNAL_1", "SCC_CONTROL"),
("MainMode_ACC", "SCC_CONTROL"),
("ACCMode", "SCC_CONTROL"),
("ZEROS_9", "SCC_CONTROL"),
("CRUISE_STANDSTILL", "SCC_CONTROL"),
("ZEROS_5", "SCC_CONTROL"),
("DISTANCE_SETTING", "SCC_CONTROL"),
("VSetDis", "SCC_CONTROL"),
]
checks += [
messages += [
("SCC_CONTROL", 50),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus(CP).CAM)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus(CP).CAM)

16
selfdrive/car/hyundai/radar_interface.py
View File

@@ -14,20 +14,8 @@ def get_radar_can_parser(CP):
if DBC[CP.carFingerprint]['radar'] is None:
return None
signals = []
checks = []
for addr in range(RADAR_START_ADDR, RADAR_START_ADDR + RADAR_MSG_COUNT):
msg = f"RADAR_TRACK_{addr:x}"
signals += [
("STATE", msg),
("AZIMUTH", msg),
("LONG_DIST", msg),
("REL_ACCEL", msg),
("REL_SPEED", msg),
]
checks += [(msg, 50)]
return CANParser(DBC[CP.carFingerprint]['radar'], signals, checks, 1)
messages = [(f"RADAR_TRACK_{addr:x}", 50) for addr in range(RADAR_START_ADDR, RADAR_START_ADDR + RADAR_MSG_COUNT)]
return CANParser(DBC[CP.carFingerprint]['radar'], messages, 1)
class RadarInterface(RadarInterfaceBase):

74
selfdrive/car/mazda/carstate.py
View File

@@ -107,22 +107,7 @@ class CarState(CarStateBase):
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("LEFT_BLINK", "BLINK_INFO"),
("RIGHT_BLINK", "BLINK_INFO"),
("HIGH_BEAMS", "BLINK_INFO"),
("STEER_ANGLE", "STEER"),
("STEER_ANGLE_RATE", "STEER_RATE"),
("STEER_TORQUE_SENSOR", "STEER_TORQUE"),
("STEER_TORQUE_MOTOR", "STEER_TORQUE"),
("FL", "WHEEL_SPEEDS"),
("FR", "WHEEL_SPEEDS"),
("RL", "WHEEL_SPEEDS"),
("RR", "WHEEL_SPEEDS"),
]
checks = [
messages = [
# sig_address, frequency
("BLINK_INFO", 10),
("STEER", 67),
@@ -132,30 +117,7 @@ class CarState(CarStateBase):
]
if CP.carFingerprint in GEN1:
signals += [
("LKAS_BLOCK", "STEER_RATE"),
("LKAS_TRACK_STATE", "STEER_RATE"),
("HANDS_OFF_5_SECONDS", "STEER_RATE"),
("CRZ_ACTIVE", "CRZ_CTRL"),
("CRZ_AVAILABLE", "CRZ_CTRL"),
("CRZ_SPEED", "CRZ_EVENTS"),
("STANDSTILL", "PEDALS"),
("BRAKE_ON", "PEDALS"),
("BRAKE_PRESSURE", "BRAKE"),
("GEAR", "GEAR"),
("DRIVER_SEATBELT", "SEATBELT"),
("FL", "DOORS"),
("FR", "DOORS"),
("BL", "DOORS"),
("BR", "DOORS"),
("PEDAL_GAS", "ENGINE_DATA"),
("SPEED", "ENGINE_DATA"),
("CTR", "CRZ_BTNS"),
("LEFT_BS_STATUS", "BSM"),
("RIGHT_BS_STATUS", "BSM"),
]
checks += [
messages += [
("ENGINE_DATA", 100),
("CRZ_CTRL", 50),
("CRZ_EVENTS", 50),
@@ -168,41 +130,17 @@ class CarState(CarStateBase):
("BSM", 10),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 0)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
@staticmethod
def get_cam_can_parser(CP):
signals = []
checks = []
messages = []
if CP.carFingerprint in GEN1:
signals += [
# sig_name, sig_address
("LKAS_REQUEST", "CAM_LKAS"),
("CTR", "CAM_LKAS"),
("ERR_BIT_1", "CAM_LKAS"),
("LINE_NOT_VISIBLE", "CAM_LKAS"),
("BIT_1", "CAM_LKAS"),
("ERR_BIT_2", "CAM_LKAS"),
("STEERING_ANGLE", "CAM_LKAS"),
("ANGLE_ENABLED", "CAM_LKAS"),
("CHKSUM", "CAM_LKAS"),
("LINE_VISIBLE", "CAM_LANEINFO"),
("LINE_NOT_VISIBLE", "CAM_LANEINFO"),
("LANE_LINES", "CAM_LANEINFO"),
("BIT1", "CAM_LANEINFO"),
("BIT2", "CAM_LANEINFO"),
("BIT3", "CAM_LANEINFO"),
("NO_ERR_BIT", "CAM_LANEINFO"),
("S1", "CAM_LANEINFO"),
("S1_HBEAM", "CAM_LANEINFO"),
]
checks += [
messages += [
# sig_address, frequency
("CAM_LANEINFO", 2),
("CAM_LKAS", 16),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 2)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)

190
selfdrive/car/nissan/carstate.py
View File

@@ -119,29 +119,7 @@ class CarState(CarStateBase):
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("WHEEL_SPEED_FL", "WHEEL_SPEEDS_FRONT"),
("WHEEL_SPEED_FR", "WHEEL_SPEEDS_FRONT"),
("WHEEL_SPEED_RL", "WHEEL_SPEEDS_REAR"),
("WHEEL_SPEED_RR", "WHEEL_SPEEDS_REAR"),
("STEER_ANGLE", "STEER_ANGLE_SENSOR"),
("DOOR_OPEN_FR", "DOORS_LIGHTS"),
("DOOR_OPEN_FL", "DOORS_LIGHTS"),
("DOOR_OPEN_RR", "DOORS_LIGHTS"),
("DOOR_OPEN_RL", "DOORS_LIGHTS"),
("RIGHT_BLINKER", "LIGHTS"),
("LEFT_BLINKER", "LIGHTS"),
("ESP_DISABLED", "ESP"),
("GEAR_SHIFTER", "GEARBOX"),
]
checks = [
messages = [
# sig_address, frequency
("STEER_ANGLE_SENSOR", 100),
("WHEEL_SPEEDS_REAR", 50),
@@ -153,51 +131,14 @@ class CarState(CarStateBase):
]
if CP.carFingerprint in (CAR.ROGUE, CAR.XTRAIL, CAR.ALTIMA):
signals += [
("USER_BRAKE_PRESSED", "DOORS_LIGHTS"),
("GAS_PEDAL", "GAS_PEDAL"),
("SEATBELT_DRIVER_LATCHED", "HUD"),
("SPEED_MPH", "HUD"),
("PROPILOT_BUTTON", "CRUISE_THROTTLE"),
("CANCEL_BUTTON", "CRUISE_THROTTLE"),
("GAS_PEDAL_INVERTED", "CRUISE_THROTTLE"),
("SET_BUTTON", "CRUISE_THROTTLE"),
("RES_BUTTON", "CRUISE_THROTTLE"),
("FOLLOW_DISTANCE_BUTTON", "CRUISE_THROTTLE"),
("NO_BUTTON_PRESSED", "CRUISE_THROTTLE"),
("GAS_PEDAL", "CRUISE_THROTTLE"),
("USER_BRAKE_PRESSED", "CRUISE_THROTTLE"),
("NEW_SIGNAL_2", "CRUISE_THROTTLE"),
("GAS_PRESSED_INVERTED", "CRUISE_THROTTLE"),
("COUNTER", "CRUISE_THROTTLE"),
("unsure1", "CRUISE_THROTTLE"),
("unsure2", "CRUISE_THROTTLE"),
("unsure3", "CRUISE_THROTTLE"),
]
checks += [
messages += [
("GAS_PEDAL", 100),
("CRUISE_THROTTLE", 50),
("HUD", 25),
]
elif CP.carFingerprint in (CAR.LEAF, CAR.LEAF_IC):
signals += [
("USER_BRAKE_PRESSED", "CRUISE_THROTTLE"),
("GAS_PEDAL", "CRUISE_THROTTLE"),
("CRUISE_AVAILABLE", "CRUISE_THROTTLE"),
("SPEED_MPH", "HUD_SETTINGS"),
("SEATBELT_DRIVER_LATCHED", "SEATBELT"),
# Copy other values, we use this to cancel
("CANCEL_SEATBELT", "CANCEL_MSG"),
("NEW_SIGNAL_1", "CANCEL_MSG"),
("NEW_SIGNAL_2", "CANCEL_MSG"),
("NEW_SIGNAL_3", "CANCEL_MSG"),
]
checks += [
messages += [
("BRAKE_PEDAL", 100),
("CRUISE_THROTTLE", 50),
("CANCEL_MSG", 50),
@@ -206,126 +147,28 @@ class CarState(CarStateBase):
]
if CP.carFingerprint == CAR.ALTIMA:
signals += [
("LKAS_ENABLED", "LKAS_SETTINGS"),
("CRUISE_ENABLED", "CRUISE_STATE"),
("SET_SPEED", "PROPILOT_HUD"),
]
checks += [
messages += [
("CRUISE_STATE", 10),
("LKAS_SETTINGS", 10),
("PROPILOT_HUD", 50),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 1)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 1)
signals.append(("STEER_TORQUE_DRIVER", "STEER_TORQUE_SENSOR"))
checks.append(("STEER_TORQUE_SENSOR", 100))
messages.append(("STEER_TORQUE_SENSOR", 100))
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 0)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
@staticmethod
def get_adas_can_parser(CP):
# this function generates lists for signal, messages and initial values
if CP.carFingerprint == CAR.ALTIMA:
signals = [
("DESIRED_ANGLE", "LKAS"),
("SET_0x80_2", "LKAS"),
("MAX_TORQUE", "LKAS"),
("SET_0x80", "LKAS"),
("COUNTER", "LKAS"),
("LKA_ACTIVE", "LKAS"),
("CRUISE_ON", "PRO_PILOT"),
]
checks = [
messages = [
("LKAS", 100),
("PRO_PILOT", 100),
]
else:
signals = [
# sig_name, sig_address
("LKAS_ENABLED", "LKAS_SETTINGS"),
("CRUISE_ENABLED", "CRUISE_STATE"),
("DESIRED_ANGLE", "LKAS"),
("SET_0x80_2", "LKAS"),
("MAX_TORQUE", "LKAS"),
("SET_0x80", "LKAS"),
("COUNTER", "LKAS"),
("LKA_ACTIVE", "LKAS"),
# Below are the HUD messages. We copy the stock message and modify
("LARGE_WARNING_FLASHING", "PROPILOT_HUD"),
("SIDE_RADAR_ERROR_FLASHING1", "PROPILOT_HUD"),
("SIDE_RADAR_ERROR_FLASHING2", "PROPILOT_HUD"),
("LEAD_CAR", "PROPILOT_HUD"),
("LEAD_CAR_ERROR", "PROPILOT_HUD"),
("FRONT_RADAR_ERROR", "PROPILOT_HUD"),
("FRONT_RADAR_ERROR_FLASHING", "PROPILOT_HUD"),
("SIDE_RADAR_ERROR_FLASHING3", "PROPILOT_HUD"),
("LKAS_ERROR_FLASHING", "PROPILOT_HUD"),
("SAFETY_SHIELD_ACTIVE", "PROPILOT_HUD"),
("RIGHT_LANE_GREEN_FLASH", "PROPILOT_HUD"),
("LEFT_LANE_GREEN_FLASH", "PROPILOT_HUD"),
("FOLLOW_DISTANCE", "PROPILOT_HUD"),
("AUDIBLE_TONE", "PROPILOT_HUD"),
("SPEED_SET_ICON", "PROPILOT_HUD"),
("SMALL_STEERING_WHEEL_ICON", "PROPILOT_HUD"),
("unknown59", "PROPILOT_HUD"),
("unknown55", "PROPILOT_HUD"),
("unknown26", "PROPILOT_HUD"),
("unknown28", "PROPILOT_HUD"),
("unknown31", "PROPILOT_HUD"),
("SET_SPEED", "PROPILOT_HUD"),
("unknown43", "PROPILOT_HUD"),
("unknown08", "PROPILOT_HUD"),
("unknown05", "PROPILOT_HUD"),
("unknown02", "PROPILOT_HUD"),
("NA_HIGH_ACCEL_TEMP", "PROPILOT_HUD_INFO_MSG"),
("SIDE_RADAR_NA_HIGH_CABIN_TEMP", "PROPILOT_HUD_INFO_MSG"),
("SIDE_RADAR_MALFUNCTION", "PROPILOT_HUD_INFO_MSG"),
("LKAS_MALFUNCTION", "PROPILOT_HUD_INFO_MSG"),
("FRONT_RADAR_MALFUNCTION", "PROPILOT_HUD_INFO_MSG"),
("SIDE_RADAR_NA_CLEAN_REAR_CAMERA", "PROPILOT_HUD_INFO_MSG"),
("NA_POOR_ROAD_CONDITIONS", "PROPILOT_HUD_INFO_MSG"),
("CURRENTLY_UNAVAILABLE", "PROPILOT_HUD_INFO_MSG"),
("SAFETY_SHIELD_OFF", "PROPILOT_HUD_INFO_MSG"),
("FRONT_COLLISION_NA_FRONT_RADAR_OBSTRUCTION", "PROPILOT_HUD_INFO_MSG"),
("PEDAL_MISSAPPLICATION_SYSTEM_ACTIVATED", "PROPILOT_HUD_INFO_MSG"),
("SIDE_IMPACT_NA_RADAR_OBSTRUCTION", "PROPILOT_HUD_INFO_MSG"),
("WARNING_DO_NOT_ENTER", "PROPILOT_HUD_INFO_MSG"),
("SIDE_IMPACT_SYSTEM_OFF", "PROPILOT_HUD_INFO_MSG"),
("SIDE_IMPACT_MALFUNCTION", "PROPILOT_HUD_INFO_MSG"),
("FRONT_COLLISION_MALFUNCTION", "PROPILOT_HUD_INFO_MSG"),
("SIDE_RADAR_MALFUNCTION2", "PROPILOT_HUD_INFO_MSG"),
("LKAS_MALFUNCTION2", "PROPILOT_HUD_INFO_MSG"),
("FRONT_RADAR_MALFUNCTION2", "PROPILOT_HUD_INFO_MSG"),
("PROPILOT_NA_MSGS", "PROPILOT_HUD_INFO_MSG"),
("BOTTOM_MSG", "PROPILOT_HUD_INFO_MSG"),
("HANDS_ON_WHEEL_WARNING", "PROPILOT_HUD_INFO_MSG"),
("WARNING_STEP_ON_BRAKE_NOW", "PROPILOT_HUD_INFO_MSG"),
("PROPILOT_NA_FRONT_CAMERA_OBSTRUCTED", "PROPILOT_HUD_INFO_MSG"),
("PROPILOT_NA_HIGH_CABIN_TEMP", "PROPILOT_HUD_INFO_MSG"),
("WARNING_PROPILOT_MALFUNCTION", "PROPILOT_HUD_INFO_MSG"),
("ACC_UNAVAILABLE_HIGH_CABIN_TEMP", "PROPILOT_HUD_INFO_MSG"),
("ACC_NA_FRONT_CAMERA_IMPARED", "PROPILOT_HUD_INFO_MSG"),
("unknown07", "PROPILOT_HUD_INFO_MSG"),
("unknown10", "PROPILOT_HUD_INFO_MSG"),
("unknown15", "PROPILOT_HUD_INFO_MSG"),
("unknown23", "PROPILOT_HUD_INFO_MSG"),
("unknown19", "PROPILOT_HUD_INFO_MSG"),
("unknown31", "PROPILOT_HUD_INFO_MSG"),
("unknown32", "PROPILOT_HUD_INFO_MSG"),
("unknown46", "PROPILOT_HUD_INFO_MSG"),
("unknown61", "PROPILOT_HUD_INFO_MSG"),
("unknown55", "PROPILOT_HUD_INFO_MSG"),
("unknown50", "PROPILOT_HUD_INFO_MSG"),
]
checks = [
messages = [
("PROPILOT_HUD_INFO_MSG", 2),
("LKAS_SETTINGS", 10),
("CRUISE_STATE", 50),
@@ -333,19 +176,16 @@ class CarState(CarStateBase):
("LKAS", 100),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 2)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)
@staticmethod
def get_cam_can_parser(CP):
signals = []
checks = []
messages = []
if CP.carFingerprint in (CAR.ROGUE, CAR.XTRAIL):
signals.append(("CRUISE_ON", "PRO_PILOT"))
checks.append(("PRO_PILOT", 100))
messages.append(("PRO_PILOT", 100))
elif CP.carFingerprint == CAR.ALTIMA:
signals.append(("STEER_TORQUE_DRIVER", "STEER_TORQUE_SENSOR"))
checks.append(("STEER_TORQUE_SENSOR", 100))
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 0)
messages.append(("STEER_TORQUE_SENSOR", 100))
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 1)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 1)

197
selfdrive/car/subaru/carstate.py
View File

@@ -92,79 +92,27 @@ class CarState(CarStateBase):
return ret
@staticmethod
def get_common_global_body_signals():
signals = [
("Cruise_On", "CruiseControl"),
("Cruise_Activated", "CruiseControl"),
("FL", "Wheel_Speeds"),
("FR", "Wheel_Speeds"),
("RL", "Wheel_Speeds"),
("RR", "Wheel_Speeds"),
("Brake", "Brake_Status"),
]
checks = [
def get_common_global_body_messages():
messages = [
("CruiseControl", 20),
("Wheel_Speeds", 50),
("Brake_Status", 50),
]
return signals, checks
return messages
@staticmethod
def get_common_global_es_signals():
signals = [
("AEB_Status", "ES_Brake"),
("Brake_Pressure", "ES_Brake"),
("COUNTER", "ES_Distance"),
("CHECKSUM", "ES_Distance"),
("Signal1", "ES_Distance"),
("Cruise_Fault", "ES_Distance"),
("Cruise_Throttle", "ES_Distance"),
("Signal2", "ES_Distance"),
("Car_Follow", "ES_Distance"),
("Signal3", "ES_Distance"),
("Cruise_Soft_Disable", "ES_Distance"),
("Signal7", "ES_Distance"),
("Cruise_Brake_Active", "ES_Distance"),
("Distance_Swap", "ES_Distance"),
("Cruise_EPB", "ES_Distance"),
("Signal4", "ES_Distance"),
("Close_Distance", "ES_Distance"),
("Signal5", "ES_Distance"),
("Cruise_Cancel", "ES_Distance"),
("Cruise_Set", "ES_Distance"),
("Cruise_Resume", "ES_Distance"),
("Signal6", "ES_Distance"),
]
checks = [
def get_common_global_es_messages():
messages = [
("ES_Brake", 20),
("ES_Distance", 20),
]
return signals, checks
return messages
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("Steer_Torque_Sensor", "Steering_Torque"),
("Steer_Torque_Output", "Steering_Torque"),
("Steering_Angle", "Steering_Torque"),
("Steer_Error_1", "Steering_Torque"),
("Brake_Pedal", "Brake_Pedal"),
("Throttle_Pedal", "Throttle"),
("LEFT_BLINKER", "Dashlights"),
("RIGHT_BLINKER", "Dashlights"),
("SEATBELT_FL", "Dashlights"),
("DOOR_OPEN_FR", "BodyInfo"),
("DOOR_OPEN_FL", "BodyInfo"),
("DOOR_OPEN_RR", "BodyInfo"),
("DOOR_OPEN_RL", "BodyInfo"),
("Gear", "Transmission"),
]
checks = [
messages = [
# sig_address, frequency
("Throttle", 100),
("Dashlights", 10),
@@ -175,164 +123,63 @@ class CarState(CarStateBase):
]
if CP.enableBsm:
signals += [
("L_ADJACENT", "BSD_RCTA"),
("R_ADJACENT", "BSD_RCTA"),
("L_APPROACHING", "BSD_RCTA"),
("R_APPROACHING", "BSD_RCTA"),
]
checks.append(("BSD_RCTA", 17))
messages.append(("BSD_RCTA", 17))
if CP.carFingerprint not in PREGLOBAL_CARS:
if CP.carFingerprint not in GLOBAL_GEN2:
signals += CarState.get_common_global_body_signals()[0]
checks += CarState.get_common_global_body_signals()[1]
messages += CarState.get_common_global_body_messages()
signals += [
("Steer_Warning", "Steering_Torque"),
("UNITS", "Dashlights"),
]
checks += [
messages += [
("Dashlights", 10),
("BodyInfo", 10),
]
else:
signals += [
("FL", "Wheel_Speeds"),
("FR", "Wheel_Speeds"),
("RL", "Wheel_Speeds"),
("RR", "Wheel_Speeds"),
("UNITS", "Dash_State2"),
("Cruise_On", "CruiseControl"),
("Cruise_Activated", "CruiseControl"),
]
checks += [
messages += [
("Wheel_Speeds", 50),
("Dash_State2", 1),
]
if CP.carFingerprint == CAR.FORESTER_PREGLOBAL:
checks += [
messages += [
("Dashlights", 20),
("BodyInfo", 1),
("CruiseControl", 50),
]
if CP.carFingerprint in (CAR.LEGACY_PREGLOBAL, CAR.OUTBACK_PREGLOBAL, CAR.OUTBACK_PREGLOBAL_2018):
checks += [
messages += [
("Dashlights", 10),
("CruiseControl", 50),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus.main)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus.main)
@staticmethod
def get_cam_can_parser(CP):
if CP.carFingerprint in PREGLOBAL_CARS:
signals = [
("Cruise_Set_Speed", "ES_DashStatus"),
("Not_Ready_Startup", "ES_DashStatus"),
("Cruise_Throttle", "ES_Distance"),
("Signal1", "ES_Distance"),
("Car_Follow", "ES_Distance"),
("Signal2", "ES_Distance"),
("Brake_On", "ES_Distance"),
("Distance_Swap", "ES_Distance"),
("Standstill", "ES_Distance"),
("Signal3", "ES_Distance"),
("Close_Distance", "ES_Distance"),
("Signal4", "ES_Distance"),
("Standstill_2", "ES_Distance"),
("Cruise_Fault", "ES_Distance"),
("Signal5", "ES_Distance"),
("COUNTER", "ES_Distance"),
("Signal6", "ES_Distance"),
("Cruise_Button", "ES_Distance"),
("Signal7", "ES_Distance"),
]
checks = [
messages = [
("ES_DashStatus", 20),
("ES_Distance", 20),
]
else:
signals = [
("COUNTER", "ES_DashStatus"),
("CHECKSUM", "ES_DashStatus"),
("PCB_Off", "ES_DashStatus"),
("LDW_Off", "ES_DashStatus"),
("Signal1", "ES_DashStatus"),
("Cruise_State_Msg", "ES_DashStatus"),
("LKAS_State_Msg", "ES_DashStatus"),
("Signal2", "ES_DashStatus"),
("Cruise_Soft_Disable", "ES_DashStatus"),
("Cruise_Status_Msg", "ES_DashStatus"),
("Signal3", "ES_DashStatus"),
("Cruise_Distance", "ES_DashStatus"),
("Signal4", "ES_DashStatus"),
("Conventional_Cruise", "ES_DashStatus"),
("Signal5", "ES_DashStatus"),
("Cruise_Disengaged", "ES_DashStatus"),
("Cruise_Activated", "ES_DashStatus"),
("Signal6", "ES_DashStatus"),
("Cruise_Set_Speed", "ES_DashStatus"),
("Cruise_Fault", "ES_DashStatus"),
("Cruise_On", "ES_DashStatus"),
("Display_Own_Car", "ES_DashStatus"),
("Brake_Lights", "ES_DashStatus"),
("Car_Follow", "ES_DashStatus"),
("Signal7", "ES_DashStatus"),
("Far_Distance", "ES_DashStatus"),
("Cruise_State", "ES_DashStatus"),
("COUNTER", "ES_LKAS_State"),
("CHECKSUM", "ES_LKAS_State"),
("LKAS_Alert_Msg", "ES_LKAS_State"),
("Signal1", "ES_LKAS_State"),
("LKAS_ACTIVE", "ES_LKAS_State"),
("LKAS_Dash_State", "ES_LKAS_State"),
("Signal2", "ES_LKAS_State"),
("Backward_Speed_Limit_Menu", "ES_LKAS_State"),
("LKAS_Left_Line_Enable", "ES_LKAS_State"),
("LKAS_Left_Line_Light_Blink", "ES_LKAS_State"),
("LKAS_Right_Line_Enable", "ES_LKAS_State"),
("LKAS_Right_Line_Light_Blink", "ES_LKAS_State"),
("LKAS_Left_Line_Visible", "ES_LKAS_State"),
("LKAS_Right_Line_Visible", "ES_LKAS_State"),
("LKAS_Alert", "ES_LKAS_State"),
("Signal3", "ES_LKAS_State"),
]
checks = [
messages = [
("ES_DashStatus", 10),
("ES_LKAS_State", 10),
]
if CP.carFingerprint not in GLOBAL_GEN2:
signals += CarState.get_common_global_es_signals()[0]
checks += CarState.get_common_global_es_signals()[1]
messages += CarState.get_common_global_es_messages()
if CP.flags & SubaruFlags.SEND_INFOTAINMENT:
signals += [
("COUNTER", "ES_Infotainment"),
("CHECKSUM", "ES_Infotainment"),
("LKAS_State_Infotainment", "ES_Infotainment"),
("LKAS_Blue_Lines", "ES_Infotainment"),
("Signal1", "ES_Infotainment"),
("Signal2", "ES_Infotainment"),
]
checks.append(("ES_Infotainment", 10))
messages.append(("ES_Infotainment", 10))
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus.camera)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus.camera)
@staticmethod
def get_body_can_parser(CP):
if CP.carFingerprint in GLOBAL_GEN2:
signals, checks = CarState.get_common_global_body_signals()
signals += CarState.get_common_global_es_signals()[0]
checks += CarState.get_common_global_es_signals()[1]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CanBus.alt)
messages = CarState.get_common_global_body_messages()
messages += CarState.get_common_global_es_messages()
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CanBus.alt)
return None

76
selfdrive/car/tesla/carstate.py
View File

@@ -101,68 +101,7 @@ class CarState(CarStateBase):
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("ESP_vehicleSpeed", "ESP_B"),
("DI_pedalPos", "DI_torque1"),
("DI_brakePedal", "DI_torque2"),
("StW_AnglHP", "STW_ANGLHP_STAT"),
("StW_AnglHP_Spd", "STW_ANGLHP_STAT"),
("EPAS_handsOnLevel", "EPAS_sysStatus"),
("EPAS_torsionBarTorque", "EPAS_sysStatus"),
("EPAS_internalSAS", "EPAS_sysStatus"),
("EPAS_eacStatus", "EPAS_sysStatus"),
("EPAS_eacErrorCode", "EPAS_sysStatus"),
("DI_cruiseState", "DI_state"),
("DI_digitalSpeed", "DI_state"),
("DI_speedUnits", "DI_state"),
("DI_gear", "DI_torque2"),
("DOOR_STATE_FL", "GTW_carState"),
("DOOR_STATE_FR", "GTW_carState"),
("DOOR_STATE_RL", "GTW_carState"),
("DOOR_STATE_RR", "GTW_carState"),
("DOOR_STATE_FrontTrunk", "GTW_carState"),
("BOOT_STATE", "GTW_carState"),
("BC_indicatorLStatus", "GTW_carState"),
("BC_indicatorRStatus", "GTW_carState"),
("SDM_bcklDrivStatus", "SDM1"),
("driverBrakeStatus", "BrakeMessage"),
# We copy this whole message when spamming cancel
("SpdCtrlLvr_Stat", "STW_ACTN_RQ"),
("VSL_Enbl_Rq", "STW_ACTN_RQ"),
("SpdCtrlLvrStat_Inv", "STW_ACTN_RQ"),
("DTR_Dist_Rq", "STW_ACTN_RQ"),
("TurnIndLvr_Stat", "STW_ACTN_RQ"),
("HiBmLvr_Stat", "STW_ACTN_RQ"),
("WprWashSw_Psd", "STW_ACTN_RQ"),
("WprWash_R_Sw_Posn_V2", "STW_ACTN_RQ"),
("StW_Lvr_Stat", "STW_ACTN_RQ"),
("StW_Cond_Flt", "STW_ACTN_RQ"),
("StW_Cond_Psd", "STW_ACTN_RQ"),
("HrnSw_Psd", "STW_ACTN_RQ"),
("StW_Sw00_Psd", "STW_ACTN_RQ"),
("StW_Sw01_Psd", "STW_ACTN_RQ"),
("StW_Sw02_Psd", "STW_ACTN_RQ"),
("StW_Sw03_Psd", "STW_ACTN_RQ"),
("StW_Sw04_Psd", "STW_ACTN_RQ"),
("StW_Sw05_Psd", "STW_ACTN_RQ"),
("StW_Sw06_Psd", "STW_ACTN_RQ"),
("StW_Sw07_Psd", "STW_ACTN_RQ"),
("StW_Sw08_Psd", "STW_ACTN_RQ"),
("StW_Sw09_Psd", "STW_ACTN_RQ"),
("StW_Sw10_Psd", "STW_ACTN_RQ"),
("StW_Sw11_Psd", "STW_ACTN_RQ"),
("StW_Sw12_Psd", "STW_ACTN_RQ"),
("StW_Sw13_Psd", "STW_ACTN_RQ"),
("StW_Sw14_Psd", "STW_ACTN_RQ"),
("StW_Sw15_Psd", "STW_ACTN_RQ"),
("WprSw6Posn", "STW_ACTN_RQ"),
("MC_STW_ACTN_RQ", "STW_ACTN_RQ"),
("CRC_STW_ACTN_RQ", "STW_ACTN_RQ"),
]
checks = [
messages = [
# sig_address, frequency
("ESP_B", 50),
("DI_torque1", 100),
@@ -175,19 +114,12 @@ class CarState(CarStateBase):
("SDM1", 10),
("BrakeMessage", 50),
]
return CANParser(DBC[CP.carFingerprint]['chassis'], signals, checks, CANBUS.chassis)
return CANParser(DBC[CP.carFingerprint]['chassis'], messages, CANBUS.chassis)
@staticmethod
def get_cam_can_parser(CP):
signals = [
# sig_name, sig_address
("DAS_accState", "DAS_control"),
("DAS_aebEvent", "DAS_control"),
("DAS_controlCounter", "DAS_control"),
]
checks = [
messages = [
# sig_address, frequency
("DAS_control", 40),
]
return CANParser(DBC[CP.carFingerprint]['chassis'], signals, checks, CANBUS.autopilot_chassis)
return CANParser(DBC[CP.carFingerprint]['chassis'], messages, CANBUS.autopilot_chassis)

28
selfdrive/car/tesla/radar_interface.py
View File

@@ -10,13 +10,7 @@ NUM_POINTS = len(RADAR_MSGS_A)
def get_radar_can_parser(CP):
# Status messages
signals = [
('RADC_HWFail', 'TeslaRadarSguInfo'),
('RADC_SGUFail', 'TeslaRadarSguInfo'),
('RADC_SensorDirty', 'TeslaRadarSguInfo'),
]
checks = [
messages = [
('TeslaRadarSguInfo', 10),
]
@@ -25,28 +19,12 @@ def get_radar_can_parser(CP):
for i in range(NUM_POINTS):
msg_id_a = RADAR_MSGS_A[i]
msg_id_b = RADAR_MSGS_B[i]
# There is a bunch more info in the messages,
# but these are the only things actually used in openpilot
signals.extend([
('LongDist', msg_id_a),
('LongSpeed', msg_id_a),
('LatDist', msg_id_a),
('LongAccel', msg_id_a),
('Meas', msg_id_a),
('Tracked', msg_id_a),
('Index', msg_id_a),
('LatSpeed', msg_id_b),
('Index2', msg_id_b),
])
checks.extend([
messages.extend([
(msg_id_a, 8),
(msg_id_b, 8),
])
return CANParser(DBC[CP.carFingerprint]['radar'], signals, checks, CANBUS.radar)
return CANParser(DBC[CP.carFingerprint]['radar'], messages, CANBUS.radar)
class RadarInterface(RadarInterfaceBase):
def __init__(self, CP):

110
selfdrive/car/toyota/carstate.py
View File

@@ -166,44 +166,7 @@ class CarState(CarStateBase):
@staticmethod
def get_can_parser(CP):
signals = [
# sig_name, sig_address
("STEER_ANGLE", "STEER_ANGLE_SENSOR"),
("GEAR", "GEAR_PACKET"),
("BRAKE_PRESSED", "BRAKE_MODULE"),
("WHEEL_SPEED_FL", "WHEEL_SPEEDS"),
("WHEEL_SPEED_FR", "WHEEL_SPEEDS"),
("WHEEL_SPEED_RL", "WHEEL_SPEEDS"),
("WHEEL_SPEED_RR", "WHEEL_SPEEDS"),
("DOOR_OPEN_FL", "BODY_CONTROL_STATE"),
("DOOR_OPEN_FR", "BODY_CONTROL_STATE"),
("DOOR_OPEN_RL", "BODY_CONTROL_STATE"),
("DOOR_OPEN_RR", "BODY_CONTROL_STATE"),
("SEATBELT_DRIVER_UNLATCHED", "BODY_CONTROL_STATE"),
("PARKING_BRAKE", "BODY_CONTROL_STATE"),
("UNITS", "BODY_CONTROL_STATE_2"),
("TC_DISABLED", "ESP_CONTROL"),
("BRAKE_HOLD_ACTIVE", "ESP_CONTROL"),
("STEER_FRACTION", "STEER_ANGLE_SENSOR"),
("STEER_RATE", "STEER_ANGLE_SENSOR"),
("CRUISE_ACTIVE", "PCM_CRUISE"),
("CRUISE_STATE", "PCM_CRUISE"),
("GAS_RELEASED", "PCM_CRUISE"),
("UI_SET_SPEED", "PCM_CRUISE_SM"),
("STEER_TORQUE_DRIVER", "STEER_TORQUE_SENSOR"),
("STEER_TORQUE_EPS", "STEER_TORQUE_SENSOR"),
("STEER_ANGLE", "STEER_TORQUE_SENSOR"),
("STEER_ANGLE_INITIALIZING", "STEER_TORQUE_SENSOR"),
("TURN_SIGNALS", "BLINKERS_STATE"),
("LKA_STATE", "EPS_STATUS"),
("AUTO_HIGH_BEAM", "LIGHT_STALK"),
]
# Check LTA state if using LTA angle control
if CP.steerControlType == SteerControlType.angle:
signals.append(("LTA_STATE", "EPS_STATUS"))
checks = [
messages = [
("GEAR_PACKET", 1),
("LIGHT_STALK", 1),
("BLINKERS_STATE", 0.15),
@@ -220,94 +183,53 @@ class CarState(CarStateBase):
]
if CP.flags & ToyotaFlags.HYBRID:
signals.append(("GAS_PEDAL", "GAS_PEDAL_HYBRID"))
checks.append(("GAS_PEDAL_HYBRID", 33))
messages.append(("GAS_PEDAL_HYBRID", 33))
else:
signals.append(("GAS_PEDAL", "GAS_PEDAL"))
checks.append(("GAS_PEDAL", 33))
messages.append(("GAS_PEDAL", 33))
if CP.carFingerprint in UNSUPPORTED_DSU_CAR:
signals.append(("MAIN_ON", "DSU_CRUISE"))
signals.append(("SET_SPEED", "DSU_CRUISE"))
signals.append(("UI_SET_SPEED", "PCM_CRUISE_ALT"))
checks.append(("DSU_CRUISE", 5))
checks.append(("PCM_CRUISE_ALT", 1))
messages.append(("DSU_CRUISE", 5))
messages.append(("PCM_CRUISE_ALT", 1))
else:
signals.append(("MAIN_ON", "PCM_CRUISE_2"))
signals.append(("SET_SPEED", "PCM_CRUISE_2"))
signals.append(("ACC_FAULTED", "PCM_CRUISE_2"))
signals.append(("LOW_SPEED_LOCKOUT", "PCM_CRUISE_2"))
checks.append(("PCM_CRUISE_2", 33))
messages.append(("PCM_CRUISE_2", 33))
# add gas interceptor reading if we are using it
if CP.enableGasInterceptor:
signals.append(("INTERCEPTOR_GAS", "GAS_SENSOR"))
signals.append(("INTERCEPTOR_GAS2", "GAS_SENSOR"))
checks.append(("GAS_SENSOR", 50))
messages.append(("GAS_SENSOR", 50))
if CP.enableBsm:
signals += [
("L_ADJACENT", "BSM"),
("L_APPROACHING", "BSM"),
("R_ADJACENT", "BSM"),
("R_APPROACHING", "BSM"),
]
checks.append(("BSM", 1))
messages.append(("BSM", 1))
if CP.carFingerprint in RADAR_ACC_CAR:
if not CP.flags & ToyotaFlags.SMART_DSU.value:
signals += [
("ACC_TYPE", "ACC_CONTROL"),
]
checks += [
messages += [
("ACC_CONTROL", 33),
]
signals += [
("FCW", "PCS_HUD"),
]
checks += [
messages += [
("PCS_HUD", 1),
]
if CP.carFingerprint not in (TSS2_CAR - RADAR_ACC_CAR) and not CP.enableDsu:
signals += [
("FORCE", "PRE_COLLISION"),
("PRECOLLISION_ACTIVE", "PRE_COLLISION"),
]
checks += [
messages += [
("PRE_COLLISION", 33),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 0)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 0)
@staticmethod
def get_cam_can_parser(CP):
signals = []
checks = []
messages = []
if CP.carFingerprint != CAR.PRIUS_V:
signals += [
("LANE_SWAY_FLD", "LKAS_HUD"),
("LANE_SWAY_BUZZER", "LKAS_HUD"),
("LANE_SWAY_WARNING", "LKAS_HUD"),
("LANE_SWAY_SENSITIVITY", "LKAS_HUD"),
("LANE_SWAY_TOGGLE", "LKAS_HUD"),
]
checks += [
messages += [
("LKAS_HUD", 1),
]
if CP.carFingerprint in (TSS2_CAR - RADAR_ACC_CAR):
signals += [
("PRECOLLISION_ACTIVE", "PRE_COLLISION"),
("FORCE", "PRE_COLLISION"),
("ACC_TYPE", "ACC_CONTROL"),
("FCW", "PCS_HUD"),
]
checks += [
messages += [
("PRE_COLLISION", 33),
("ACC_CONTROL", 33),
("PCS_HUD", 1),
]
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, 2)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, 2)

9
selfdrive/car/toyota/radar_interface.py
View File

@@ -15,14 +15,9 @@ def _create_radar_can_parser(car_fingerprint):
msg_a_n = len(RADAR_A_MSGS)
msg_b_n = len(RADAR_B_MSGS)
messages = list(zip(RADAR_A_MSGS + RADAR_B_MSGS, [20] * (msg_a_n + msg_b_n)))
signals = list(zip(['LONG_DIST'] * msg_a_n + ['NEW_TRACK'] * msg_a_n + ['LAT_DIST'] * msg_a_n +
['REL_SPEED'] * msg_a_n + ['VALID'] * msg_a_n + ['SCORE'] * msg_b_n,
RADAR_A_MSGS * 5 + RADAR_B_MSGS))
checks = list(zip(RADAR_A_MSGS + RADAR_B_MSGS, [20] * (msg_a_n + msg_b_n)))
return CANParser(DBC[car_fingerprint]['radar'], signals, checks, 1)
return CANParser(DBC[car_fingerprint]['radar'], messages, 1)
class RadarInterface(RadarInterfaceBase):
def __init__(self, CP):

206
selfdrive/car/volkswagen/carstate.py
View File

@@ -254,54 +254,7 @@ class CarState(CarStateBase):
if CP.carFingerprint in PQ_CARS:
return CarState.get_can_parser_pq(CP)
signals = [
# sig_name, sig_address
("LWI_Lenkradwinkel", "LWI_01"), # Absolute steering angle
("LWI_VZ_Lenkradwinkel", "LWI_01"), # Steering angle sign
("LWI_Lenkradw_Geschw", "LWI_01"), # Absolute steering rate
("LWI_VZ_Lenkradw_Geschw", "LWI_01"), # Steering rate sign
("ESP_VL_Radgeschw_02", "ESP_19"), # ABS wheel speed, front left
("ESP_VR_Radgeschw_02", "ESP_19"), # ABS wheel speed, front right
("ESP_HL_Radgeschw_02", "ESP_19"), # ABS wheel speed, rear left
("ESP_HR_Radgeschw_02", "ESP_19"), # ABS wheel speed, rear right
("ESP_Gierrate", "ESP_02"), # Absolute yaw rate
("ESP_VZ_Gierrate", "ESP_02"), # Yaw rate sign
("ZV_FT_offen", "Gateway_72"), # Door open, driver
("ZV_BT_offen", "Gateway_72"), # Door open, passenger
("ZV_HFS_offen", "Gateway_72"), # Door open, rear left
("ZV_HBFS_offen", "Gateway_72"), # Door open, rear right
("ZV_HD_offen", "Gateway_72"), # Trunk or hatch open
("Comfort_Signal_Left", "Blinkmodi_02"), # Left turn signal including comfort blink interval
("Comfort_Signal_Right", "Blinkmodi_02"), # Right turn signal including comfort blink interval
("AB_Gurtschloss_FA", "Airbag_02"), # Seatbelt status, driver
("AB_Gurtschloss_BF", "Airbag_02"), # Seatbelt status, passenger
("ESP_Fahrer_bremst", "ESP_05"), # Driver applied brake pressure over threshold
("MO_Fahrer_bremst", "Motor_14"), # Brake pedal switch
("ESP_Bremsdruck", "ESP_05"), # Brake pressure
("MO_Fahrpedalrohwert_01", "Motor_20"), # Accelerator pedal value
("EPS_Lenkmoment", "LH_EPS_03"), # Absolute driver torque input
("EPS_VZ_Lenkmoment", "LH_EPS_03"), # Driver torque input sign
("EPS_HCA_Status", "LH_EPS_03"), # EPS HCA control status
("ESP_Tastung_passiv", "ESP_21"), # Stability control disabled
("ESP_Haltebestaetigung", "ESP_21"), # ESP hold confirmation
("KBI_Handbremse", "Kombi_01"), # Manual handbrake applied
("KBI_Variante", "Kombi_03"), # Digital/full-screen instrument cluster installed
("TSK_Status", "TSK_06"), # ACC engagement status from drivetrain coordinator
("GRA_Hauptschalter", "GRA_ACC_01"), # ACC button, on/off
("GRA_Abbrechen", "GRA_ACC_01"), # ACC button, cancel
("GRA_Tip_Setzen", "GRA_ACC_01"), # ACC button, set
("GRA_Tip_Hoch", "GRA_ACC_01"), # ACC button, increase or accel
("GRA_Tip_Runter", "GRA_ACC_01"), # ACC button, decrease or decel
("GRA_Tip_Wiederaufnahme", "GRA_ACC_01"), # ACC button, resume
("GRA_Verstellung_Zeitluecke", "GRA_ACC_01"), # ACC button, time gap adj
("GRA_Typ_Hauptschalter", "GRA_ACC_01"), # ACC main button type
("GRA_Codierung", "GRA_ACC_01"), # ACC button configuration/coding
("GRA_Tip_Stufe_2", "GRA_ACC_01"), # unknown related to stalk type
("GRA_ButtonTypeInfo", "GRA_ACC_01"), # unknown related to stalk type
("COUNTER", "GRA_ACC_01"), # GRA_ACC_01 CAN message counter
]
checks = [
messages = [
# sig_address, frequency
("LWI_01", 100), # From J500 Steering Assist with integrated sensors
("LH_EPS_03", 100), # From J500 Steering Assist with integrated sensors
@@ -321,108 +274,41 @@ class CarState(CarStateBase):
]
if CP.transmissionType == TransmissionType.automatic:
signals.append(("GE_Fahrstufe", "Getriebe_11")) # Auto trans gear selector position
checks.append(("Getriebe_11", 20)) # From J743 Auto transmission control module
messages.append(("Getriebe_11", 20)) # From J743 Auto transmission control module
elif CP.transmissionType == TransmissionType.direct:
signals.append(("GearPosition", "EV_Gearshift")) # EV gear selector position
checks.append(("EV_Gearshift", 10)) # From J??? unknown EV control module
elif CP.transmissionType == TransmissionType.manual:
signals += [("MO_Kuppl_schalter", "Motor_14"), # Clutch switch
("BCM1_Rueckfahrlicht_Schalter", "Gateway_72")] # Reverse light from BCM
messages.append(("EV_Gearshift", 10)) # From J??? unknown EV control module
if CP.networkLocation == NetworkLocation.fwdCamera:
# Radars are here on CANBUS.pt
signals += MqbExtraSignals.fwd_radar_signals
checks += MqbExtraSignals.fwd_radar_checks
messages += MqbExtraSignals.fwd_radar_messages
if CP.enableBsm:
signals += MqbExtraSignals.bsm_radar_signals
checks += MqbExtraSignals.bsm_radar_checks
messages += MqbExtraSignals.bsm_radar_messages
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CANBUS.pt)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CANBUS.pt)
@staticmethod
def get_cam_can_parser(CP):
if CP.carFingerprint in PQ_CARS:
return CarState.get_cam_can_parser_pq(CP)
signals = []
checks = []
messages = []
if CP.networkLocation == NetworkLocation.fwdCamera:
signals += [
# sig_name, sig_address
("LDW_SW_Warnung_links", "LDW_02"), # Blind spot in warning mode on left side due to lane departure
("LDW_SW_Warnung_rechts", "LDW_02"), # Blind spot in warning mode on right side due to lane departure
("LDW_Seite_DLCTLC", "LDW_02"), # Direction of most likely lane departure (left or right)
("LDW_DLC", "LDW_02"), # Lane departure, distance to line crossing
("LDW_TLC", "LDW_02"), # Lane departure, time to line crossing
]
checks += [
messages += [
# sig_address, frequency
("LDW_02", 10) # From R242 Driver assistance camera
]
else:
# Radars are here on CANBUS.cam
signals += MqbExtraSignals.fwd_radar_signals
checks += MqbExtraSignals.fwd_radar_checks
messages += MqbExtraSignals.fwd_radar_messages
if CP.enableBsm:
signals += MqbExtraSignals.bsm_radar_signals
checks += MqbExtraSignals.bsm_radar_checks
messages += MqbExtraSignals.bsm_radar_messages
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CANBUS.cam)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CANBUS.cam)
@staticmethod
def get_can_parser_pq(CP):
signals = [
# sig_name, sig_address, default
("LH3_BLW", "Lenkhilfe_3"), # Absolute steering angle
("LH3_BLWSign", "Lenkhilfe_3"), # Steering angle sign
("LH3_LM", "Lenkhilfe_3"), # Absolute driver torque input
("LH3_LMSign", "Lenkhilfe_3"), # Driver torque input sign
("LH2_Sta_HCA", "Lenkhilfe_2"), # Steering rack HCA status
("Lenkradwinkel_Geschwindigkeit", "Lenkwinkel_1"), # Absolute steering rate
("Lenkradwinkel_Geschwindigkeit_S", "Lenkwinkel_1"), # Steering rate sign
("Geschwindigkeit_neu__Bremse_1_", "Bremse_1"), # Vehicle speed from ABS
("Radgeschw__VL_4_1", "Bremse_3"), # ABS wheel speed, front left
("Radgeschw__VR_4_1", "Bremse_3"), # ABS wheel speed, front right
("Radgeschw__HL_4_1", "Bremse_3"), # ABS wheel speed, rear left
("Radgeschw__HR_4_1", "Bremse_3"), # ABS wheel speed, rear right
("Giergeschwindigkeit", "Bremse_5"), # Absolute yaw rate
("Vorzeichen_der_Giergeschwindigk", "Bremse_5"), # Yaw rate sign
("Gurtschalter_Fahrer", "Airbag_1"), # Seatbelt status, driver
("Gurtschalter_Beifahrer", "Airbag_1"), # Seatbelt status, passenger
("Bremstestschalter", "Motor_2"), # Brake pedal pressed (brake light test switch)
("Bremslichtschalter", "Motor_2"), # Brakes applied (brake light switch)
("Bremsdruck", "Bremse_5"), # Brake pressure applied
("Vorzeichen_Bremsdruck", "Bremse_5"), # Brake pressure applied sign (???)
("Fahrpedal_Rohsignal", "Motor_3"), # Accelerator pedal value
("ESP_Passiv_getastet", "Bremse_1"), # Stability control disabled
("GRA_Hauptschalter", "Motor_5"), # ACC main switch
("GRA_Status", "Motor_2"), # ACC engagement status
("GK1_Fa_Tuerkont", "Gate_Komf_1"), # Door open, driver
("BSK_BT_geoeffnet", "Gate_Komf_1"), # Door open, passenger
("BSK_HL_geoeffnet", "Gate_Komf_1"), # Door open, rear left
("BSK_HR_geoeffnet", "Gate_Komf_1"), # Door open, rear right
("BSK_HD_Hauptraste", "Gate_Komf_1"), # Trunk or hatch open
("GK1_Blinker_li", "Gate_Komf_1"), # Left turn signal on
("GK1_Blinker_re", "Gate_Komf_1"), # Right turn signal on
("Bremsinfo", "Kombi_1"), # Manual handbrake applied
("GRA_Hauptschalt", "GRA_Neu"), # ACC button, on/off
("GRA_Typ_Hauptschalt", "GRA_Neu"), # ACC button, momentary vs latching
("GRA_Kodierinfo", "GRA_Neu"), # ACC button, configuration
("GRA_Abbrechen", "GRA_Neu"), # ACC button, cancel
("GRA_Neu_Setzen", "GRA_Neu"), # ACC button, set
("GRA_Up_lang", "GRA_Neu"), # ACC button, increase or accel, long press
("GRA_Down_lang", "GRA_Neu"), # ACC button, decrease or decel, long press
("GRA_Up_kurz", "GRA_Neu"), # ACC button, increase or accel, short press
("GRA_Down_kurz", "GRA_Neu"), # ACC button, decrease or decel, short press
("GRA_Recall", "GRA_Neu"), # ACC button, resume
("GRA_Zeitluecke", "GRA_Neu"), # ACC button, time gap adj
("COUNTER", "GRA_Neu"), # ACC button, message counter
("GRA_Sender", "GRA_Neu"), # ACC button, CAN message originator
]
checks = [
messages = [
# sig_address, frequency
("Bremse_1", 100), # From J104 ABS/ESP controller
("Bremse_3", 100), # From J104 ABS/ESP controller
@@ -440,95 +326,55 @@ class CarState(CarStateBase):
]
if CP.transmissionType == TransmissionType.automatic:
signals += [("Waehlhebelposition__Getriebe_1_", "Getriebe_1", 0)] # Auto trans gear selector position
checks += [("Getriebe_1", 100)] # From J743 Auto transmission control module
messages += [("Getriebe_1", 100)] # From J743 Auto transmission control module
elif CP.transmissionType == TransmissionType.manual:
signals += [("Kupplungsschalter", "Motor_1", 0), # Clutch switch
("GK1_Rueckfahr", "Gate_Komf_1", 0)] # Reverse light from BCM
checks += [("Motor_1", 100)] # From J623 Engine control module
messages += [("Motor_1", 100)] # From J623 Engine control module
if CP.networkLocation == NetworkLocation.fwdCamera:
# Extended CAN devices other than the camera are here on CANBUS.pt
signals += PqExtraSignals.fwd_radar_signals
checks += PqExtraSignals.fwd_radar_checks
messages += PqExtraSignals.fwd_radar_messages
if CP.enableBsm:
signals += PqExtraSignals.bsm_radar_signals
checks += PqExtraSignals.bsm_radar_checks
messages += PqExtraSignals.bsm_radar_messages
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CANBUS.pt)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CANBUS.pt)
@staticmethod
def get_cam_can_parser_pq(CP):
signals = []
checks = []
messages = []
if CP.networkLocation == NetworkLocation.fwdCamera:
signals += [
# sig_name, sig_address
("LDW_SW_Warnung_links", "LDW_Status"), # Blind spot in warning mode on left side due to lane departure
("LDW_SW_Warnung_rechts", "LDW_Status"), # Blind spot in warning mode on right side due to lane departure
("LDW_Seite_DLCTLC", "LDW_Status"), # Direction of most likely lane departure (left or right)
("LDW_DLC", "LDW_Status"), # Lane departure, distance to line crossing
("LDW_TLC", "LDW_Status"), # Lane departure, time to line crossing
]
checks += [
messages += [
# sig_address, frequency
("LDW_Status", 10) # From R242 Driver assistance camera
]
if CP.networkLocation == NetworkLocation.gateway:
# Radars are here on CANBUS.cam
signals += PqExtraSignals.fwd_radar_signals
checks += PqExtraSignals.fwd_radar_checks
messages += PqExtraSignals.fwd_radar_messages
if CP.enableBsm:
signals += PqExtraSignals.bsm_radar_signals
checks += PqExtraSignals.bsm_radar_checks
messages += PqExtraSignals.bsm_radar_messages
return CANParser(DBC[CP.carFingerprint]["pt"], signals, checks, CANBUS.cam)
return CANParser(DBC[CP.carFingerprint]["pt"], messages, CANBUS.cam)
class MqbExtraSignals:
# Additional signal and message lists for optional or bus-portable controllers
fwd_radar_signals = [
("ACC_Wunschgeschw_02", "ACC_02"), # ACC set speed
("ACC_Typ", "ACC_06"), # Basic vs FtS vs SnG
("AWV2_Freigabe", "ACC_10"), # FCW brake jerk release
("ANB_Teilbremsung_Freigabe", "ACC_10"), # AEB partial braking release
("ANB_Zielbremsung_Freigabe", "ACC_10"), # AEB target braking release
]
fwd_radar_checks = [
fwd_radar_messages = [
("ACC_06", 50), # From J428 ACC radar control module
("ACC_10", 50), # From J428 ACC radar control module
("ACC_02", 17), # From J428 ACC radar control module
]
bsm_radar_signals = [
("SWA_Infostufe_SWA_li", "SWA_01"), # Blind spot object info, left
("SWA_Warnung_SWA_li", "SWA_01"), # Blind spot object warning, left
("SWA_Infostufe_SWA_re", "SWA_01"), # Blind spot object info, right
("SWA_Warnung_SWA_re", "SWA_01"), # Blind spot object warning, right
]
bsm_radar_checks = [
bsm_radar_messages = [
("SWA_01", 20), # From J1086 Lane Change Assist
]
class PqExtraSignals:
# Additional signal and message lists for optional or bus-portable controllers
fwd_radar_signals = [
("ACS_Typ_ACC", "ACC_System"), # Basic vs FtS (no SnG support on PQ)
("ACA_StaACC", "ACC_GRA_Anzeige"), # ACC drivetrain coordinator status
("ACA_V_Wunsch", "ACC_GRA_Anzeige"), # ACC set speed
]
fwd_radar_checks = [
fwd_radar_messages = [
("ACC_System", 50), # From J428 ACC radar control module
("ACC_GRA_Anzeige", 25), # From J428 ACC radar control module
]
bsm_radar_signals = [
("SWA_Infostufe_SWA_li", "SWA_1"), # Blind spot object info, left
("SWA_Warnung_SWA_li", "SWA_1"), # Blind spot object warning, left
("SWA_Infostufe_SWA_re", "SWA_1"), # Blind spot object info, right
("SWA_Warnung_SWA_re", "SWA_1"), # Blind spot object warning, right
]
bsm_radar_checks = [
bsm_radar_messages = [
("SWA_1", 20), # From J1086 Lane Change Assist
]