byd: add BYD car port (HAN EV 23 / Seal Performance 2025) with MADS support

Car port adapted from HotIce0/openpilot develop_byd_comma4 to sunnypilot's
opendbc API (CP_SP signatures, (ret, ret_sp) carstate returns):

- opendbc/car/byd/: interface, carstate, carcontroller, bydcan, values,
  fingerprints (BYD_SEAL_PERFORMANCE_25 with full 91-msg fingerprint)
- opendbc/dbc/byd_common.dbc
- Brand registration: car/values.py, car/fingerprints.py (+MIGRATION),
  car.capnp SafetyModel byd @35, torque_data/params.toml
- safety/modes/byd.h: SAFETY_BYD 35U with real TX checks (steer torque
  cmd checks, longitudinal accel checks), MADS LKAS button from
  PCM_BUTTONS (944), pcm_cruise_check, ESC vehicle_moving. MISRA clean.
- safety/tests/test_byd.py: 120 tests (stock + longitudinal variants)
- opendbc/sunnypilot/car/byd/mads.py: MadsCarState tracking the
  dedicated LKAS steering wheel button
- sunnypilot/mads/mads.py: allow_always for byd (dedicated LKAS button)
- panda: restore SConstruct/SConscript build system, rebuild
  panda_h7.bin.signed (TIZI) with SAFETY_BYD + MADS lateral gating

Known limitation: BYD_HAN_EV_23 fingerprint is a subset of the Seal's,
so HAN requires FINGERPRINT=BYD_HAN_EV_23 env var (live fingerprint
cannot distinguish it; Seal fingerprints natively).
This commit is contained in:
Quintine committed 2026-07-25 15:09:00 +10:00
1 parent de77c89cf6
commit c8903e592c
44 files changed
+1480 -5

No files matched your search

+1
View File
@@ -0,0 +1 @@
# byd
Whitespace-only changes.
+161
View File
@@ -0,0 +1,161 @@
from opendbc.car.byd.values import CANBUS
def byd_checksum(data: bytearray) -> int:
byte_key = 0xAF
sum_first = sum(byte >> 4 for byte in data) # Extract upper nibble.
sum_second = sum(byte & 0xF for byte in data) # Extract lower nibble.
remainder = sum_second >> 4
sum_first += (byte_key & 0xF) # Low nibble of byte_key.
sum_second += (byte_key >> 4) # High nibble of byte_key.
# Inline inverse computation for each sum:
# inv = (-sum + 0x9) & 0xF
inv_first = ((-sum_first + 0x9) & 0xF)
inv_second = ((-sum_second + 0x9) & 0xF)
return (((inv_first + (5 - remainder)) << 4) + inv_second) & 0xFF
def byd_checksum_short(data: bytearray) -> int:
# checksum for CHECKSUM_S 4byte
pass
class BydCAN:
LKAS_MODE_ACTIVE2 = 3
LKAS_MODE_PASSIVE = 1
def __init__(self, packer):
self.packer = packer
self.mpc_lkas_counter = 0
self.eps_steering_torque_counter = 0
self.mpc_acc_cmd_counter = 0
def update_mpc_lkas_counter(self, val):
self.mpc_lkas_counter = val
def _generate_mpc_lkas_new_counter(self):
counter = self.mpc_lkas_counter
self.mpc_lkas_counter = int(self.mpc_lkas_counter + 1) & 0xF
return counter
def update_eps_steering_torque_counter(self, val):
self.eps_steering_torque_counter = val
def _generate_eps_steering_torque_new_counter(self):
counter = self.eps_steering_torque_counter
self.eps_steering_torque_counter = int(
self.eps_steering_torque_counter + 1) & 0xF
return counter
def update_acc_cmd_counter(self, val):
self.mpc_acc_cmd_counter = val
def _generate_acc_cmd_new_counter(self):
counter = self.mpc_acc_cmd_counter
self.mpc_acc_cmd_counter = int(self.mpc_acc_cmd_counter + 1) & 0xF
return counter
# MPC -> Panda -> EPS
def create_steering_control_torque(self, mpc_lkas_cmd_msg, torque,
request_prepare, active, mode,
eps_active):
lkas_output = torque if active and eps_active else 0
lkas_prepare = request_prepare
lkas_active = active
lkas_mode = mode
left_lane = mpc_lkas_cmd_msg["LeftLane"]
right_lane = mpc_lkas_cmd_msg["RightLane"]
if active or request_prepare:
left_lane = 1
right_lane = 1
values = {
"SETME_0x1": mpc_lkas_cmd_msg["SETME_0x1"],
"LeftLane": left_lane,
"Config": mpc_lkas_cmd_msg["Config"],
"SETME2_0x1": mpc_lkas_cmd_msg["SETME2_0x1"],
"Keep_Hands_On_Wheel": 0,
"MPCErr": mpc_lkas_cmd_msg["MPCErr"],
"SETME3_0x1": mpc_lkas_cmd_msg["SETME3_0x1"],
"LKAS_Output": lkas_output,
"LKASPrepare": lkas_prepare,
"LKAS_ACTIVE": lkas_active,
"TSRStatus": mpc_lkas_cmd_msg["TSRStatus"],
"SETME4_0x1": mpc_lkas_cmd_msg["SETME4_0x1"],
"RightLane": right_lane,
"LKAS_Mode": lkas_mode,
"SETME_0x0": mpc_lkas_cmd_msg["SETME_0x0"],
"TSRResult": mpc_lkas_cmd_msg["TSRResult"],
"Unknow1": mpc_lkas_cmd_msg["Unknow1"],
"COUNTER": self._generate_mpc_lkas_new_counter(),
}
data = self.packer.make_can_msg("MPC_LKAS_CMD", CANBUS.main_bus, values)[1]
values["CHECKSUM"] = byd_checksum(data)
return self.packer.make_can_msg("MPC_LKAS_CMD", CANBUS.main_bus, values)
def create_steering_torque(self, eps_steering_torque_msg, mpc_lkas_output,
mpc_lkas_request_prepare, mpc_lkas_active):
lks_prepared = eps_steering_torque_msg["LKSPrepare"]
cruise_activated = eps_steering_torque_msg["Cruise_Activated"]
main_torque = eps_steering_torque_msg["MAIN_TORQUE"]
if mpc_lkas_active:
lks_prepared = 0
cruise_activated = 1
main_torque = mpc_lkas_output
elif mpc_lkas_request_prepare:
lks_prepared = 1
cruise_activated = 0
main_torque = 0
else:
lks_prepared = 0
cruise_activated = 0
main_torque = 0
values = {
"LKSPrepare": lks_prepared,
"Cruise_Activated": cruise_activated,
"TORQUE_FAILED": eps_steering_torque_msg["TORQUE_FAILED"],
"SET_ME_1_1": eps_steering_torque_msg["SET_ME_1_1"],
"Steer_Warning": eps_steering_torque_msg["Steer_Warning"],
"Steer_Error_1": eps_steering_torque_msg["Steer_Error_1"],
"Steer_Error_2": eps_steering_torque_msg["Steer_Error_2"],
"SET_ME_1": eps_steering_torque_msg["SET_ME_1"],
"MAIN_TORQUE": main_torque,
"SET_ME_1_2": eps_steering_torque_msg["SET_ME_1_2"],
"Keep_Hands_On_Wheel": 0,
"SET_ME_3": eps_steering_torque_msg["SET_ME_3"],
"Steer_Torque_Sensor": eps_steering_torque_msg["Steer_Torque_Sensor"],
"SET_ME_XF_1": eps_steering_torque_msg["SET_ME_XF_1"],
"SET_ME_XFFF": eps_steering_torque_msg["SET_ME_XFFF"],
"COUNTER": self._generate_eps_steering_torque_new_counter(),
}
data = self.packer.make_can_msg("STEERING_TORQUE", CANBUS.cam_bus, values)[1]
values["CHECKSUM"] = byd_checksum(data)
return self.packer.make_can_msg("STEERING_TORQUE", CANBUS.cam_bus, values)
def create_acc_cmd(self, acc_cmd_msg, accel):
values = {
"ACCEL_CMD": accel,
"ComfortBandUpper": acc_cmd_msg["ComfortBandUpper"],
"ComfortBandLower": acc_cmd_msg["ComfortBandLower"],
"JerkUpperLimit": 1,
"SET_ME_1": acc_cmd_msg["SET_ME_1"],
"JerkLowerLimit": -1,
"STANDSTILL_RESUME": 0,
"STANDSTILL_STATE": 0,
"BRAKE_BEHAVIOR": acc_cmd_msg["BRAKE_BEHAVIOR"],
"ACC_REQ_NOT_STANDSTILL": acc_cmd_msg["ACC_REQ_NOT_STANDSTILL"],
"ACC_CONTROLLABLE_AND_ON": acc_cmd_msg["ACC_CONTROLLABLE_AND_ON"],
"ACC_OVERRIDE_OR_STANDSTILL": acc_cmd_msg["ACC_OVERRIDE_OR_STANDSTILL"],
"ESP_BEHAVIOR": acc_cmd_msg["ESP_BEHAVIOR"],
"COUNTER": self._generate_acc_cmd_new_counter(),
"SET_ME_XF": acc_cmd_msg["SET_ME_XF"],
}
data = self.packer.make_can_msg("ACC_CMD", CANBUS.main_bus, values)[1]
values["CHECKSUM"] = byd_checksum(data)
return self.packer.make_can_msg("ACC_CMD", CANBUS.main_bus, values)
@@ -0,0 +1,104 @@
import numpy as np
from opendbc.can.packer import CANPacker
from opendbc.car import Bus, structs
from opendbc.car.lateral import apply_meas_steer_torque_limits
from opendbc.car.interfaces import CarControllerBase
from opendbc.car.byd.bydcan import BydCAN
from opendbc.car.byd.values import CarControllerParams
VisualAlert = structs.CarControl.HUDControl.VisualAlert
ButtonType = structs.CarState.ButtonEvent.Type
LongCtrlState = structs.CarControl.Actuators.LongControlState
class LKASState:
INACTIVE = 0
PREPARING = 1
ACTIVE = 2
class CarController(CarControllerBase):
def __init__(self, dbc_names, CP, CP_SP):
super().__init__(dbc_names, CP, CP_SP)
self.params = CarControllerParams(CP)
self.packer = CANPacker(dbc_names[Bus.pt])
self.can = BydCAN(self.packer)
self.apply_torque_last = 0
self.lkas_state = LKASState.INACTIVE
self.lkas_counter_updated = False
self.apply_accel_last = 0
def update(self, CC, CC_SP, CS, now_nanos):
# car control running in 100Hz
actuators = CC.actuators
can_sends = []
if (self.frame % self.params.STEER_STEP) == 0:
# steering control running in 50Hz
if not self.lkas_counter_updated:
self.lkas_counter_updated = True
self.can.update_mpc_lkas_counter(
int(CS.mpc_lkas_cmd_msg["COUNTER"] + 1) & 0xF)
self.can.update_eps_steering_torque_counter(
int(CS.eps_steering_torque_msg["COUNTER"] + 1) & 0xF)
self.can.update_acc_cmd_counter(
int(CS.acc_cmd_msg["COUNTER"] + 1) & 0xF)
# update lkas state
if self.lkas_state == LKASState.INACTIVE:
if CC.latActive:
self.lkas_state = LKASState.PREPARING
elif self.lkas_state == LKASState.PREPARING:
if CS.eps_prepared:
self.lkas_state = LKASState.ACTIVE
elif self.lkas_state == LKASState.ACTIVE:
if not CC.latActive:
self.lkas_state = LKASState.INACTIVE
lkas_request_prepare = int(self.lkas_state == LKASState.PREPARING)
lkas_active = int(self.lkas_state == LKASState.ACTIVE)
if self.lkas_state in (LKASState.PREPARING, LKASState.ACTIVE):
lkas_mode = BydCAN.LKAS_MODE_ACTIVE2
else:
lkas_mode = BydCAN.LKAS_MODE_PASSIVE
# calc apply torque
apply_torque = 0
if self.lkas_state == LKASState.ACTIVE:
apply_torque = int(round(actuators.torque * self.params.STEER_MAX))
apply_torque = apply_meas_steer_torque_limits(apply_torque, self.apply_torque_last,
CS.out.steeringTorqueEps, self.params)
pack = self.can.create_steering_control_torque(CS.mpc_lkas_cmd_msg, apply_torque,
lkas_request_prepare, lkas_active,
lkas_mode, CS.eps_activated)
can_sends.append(pack)
pack = self.can.create_steering_torque(CS.eps_steering_torque_msg,
CS.mpc_lkas_output,
CS.mpc_lkas_request_prepare,
CS.mpc_lkas_active)
can_sends.append(pack)
self.apply_torque_last = apply_torque
# Longitudinal control
if self.CP.openpilotLongitudinalControl:
if (self.frame % self.params.ACC_SETP) == 0:
accel = 0
if CC.longActive:
accel = float(np.clip(actuators.accel, self.params.ACCEL_MIN, self.params.ACCEL_MAX))
pack = self.can.create_acc_cmd(CS.acc_cmd_msg, accel)
can_sends.append(pack)
self.apply_accel_last = accel
new_actuators = actuators.as_builder()
new_actuators.torque = self.apply_torque_last / self.params.STEER_MAX
new_actuators.torqueOutputCan = self.apply_torque_last
new_actuators.accel = self.apply_accel_last
self.frame += 1
return new_actuators, can_sends
+125
View File
@@ -0,0 +1,125 @@
import copy
from opendbc.car import Bus, create_button_events, structs
from opendbc.can.parser import CANParser
from opendbc.car.common.conversions import Conversions as CV
from opendbc.car.interfaces import CarStateBase
from opendbc.car.byd.values import DBC, CANBUS, STEER_THRESHOLD, GEAR_MAP
from opendbc.sunnypilot.car.byd.mads import MadsCarState
GearShifter = structs.CarState.GearShifter
ButtonType = structs.CarState.ButtonEvent.Type
class CarState(CarStateBase, MadsCarState):
def __init__(self, CP, CP_SP):
CarStateBase.__init__(self, CP, CP_SP)
MadsCarState.__init__(self, CP, CP_SP)
self.mpc_lkas_cmd_msg = None
self.eps_steering_torque_msg = None
self.eps_prepared = False
self.eps_activated = False
self.acc_cmd_msg = None
self.mpc_lkas_output = 0
self.mpc_lkas_active = False
self.mpc_lkas_request_prepare = False
def update(self, can_parsers) -> tuple[structs.CarState, structs.CarStateSP]:
cp = can_parsers[Bus.pt]
cp_cam = can_parsers[Bus.cam]
ret = structs.CarState()
ret_sp = structs.CarStateSP()
# car Speed
ret.vEgoRaw = cp.vl["ESC"]["VEHICLE_SPEED"] * CV.KPH_TO_MS
ret.vEgo, ret.aEgo = self.update_speed_kf(ret.vEgoRaw)
ret.standstill = cp.vl["BRAKE_APPLIED"]["STANDSTILL"] == 1
# Gas pedal
ret.gasPressed = cp.vl["PEDAL"]["GAS_PEDAL"] > 0
# Brake pedal
ret.brakePressed = cp.vl["PEDAL"]["BRAKE_PEDAL"] > 0
# Steering wheel
ret.steeringAngleDeg = cp.vl["STEER_MODULE"]["STEER_ANGLE"]
ret.steeringRateDeg = cp.vl["STEER_MODULE"]["STEERING_RATE"]
ret.steeringTorque = cp.vl["STEERING_TORQUE"]["Steer_Torque_Sensor"]
ret.steeringTorqueEps = cp.vl["STEERING_TORQUE"]["MAIN_TORQUE"]
# TODO: looks like STEER_THRESHOLD is too small
ret.steeringPressed = self.update_steering_pressed(abs(ret.steeringTorque) > STEER_THRESHOLD, 5)
ret.steerFaultPermanent = cp.vl["STEERING_TORQUE"]["TORQUE_FAILED"] != 0
ret.steerFaultTemporary = cp.vl["STEERING_TORQUE"]["TORQUE_FAILED"] != 0
ret.stockAeb = cp_cam.vl["ACC_HUD_ADAS"]["AEB"] == 1
ret.stockFcw = cp_cam.vl["ACC_HUD_ADAS"]["FCW"] == 1 # Forward Collision Warning
# Cruise state
ret.cruiseState.enabled = cp_cam.vl["ACC_HUD_ADAS"]["CRUISE_STATE"] in (3, 5) # (Active, Override)
ret.cruiseState.speed = cp_cam.vl["ACC_HUD_ADAS"]["SET_SPEED"] * 10 * CV.KPH_TO_MS
ret.cruiseState.available = cp_cam.vl["ACC_HUD_ADAS"]["CRUISE_STATE"] not in (8, 9) # (Failure, PermanentFailure)
ret.cruiseState.standstill = False # This needs to be false, since we can resume from stop without sending anything special
# Gear
ret.gearShifter = GEAR_MAP.get(int(cp.vl["DRIVE_STATE"]["GEAR"]), GearShifter.unknown)
# MADS: track the dedicated LKAS steering wheel button
MadsCarState.update_mads(self, ret, can_parsers)
# button presses
ret.leftBlinker = cp.vl["STALKS"]["TURN_SIGNAL_SWITCH"] == 3 # LeftSteeringLongLift
ret.rightBlinker = cp.vl["STALKS"]["TURN_SIGNAL_SWITCH"] == 5 # RightSteeringLongLift
ret.buttonEvents = [*create_button_events(self.lkas_button, self.prev_lkas_button, {1: ButtonType.lkas})]
# lock info
ret.doorOpen = any([cp.vl["METER_CLUSTER"]["FRONT_LEFT_DOOR"],
cp.vl["METER_CLUSTER"]["FRONT_RIGHT_DOOR"],
cp.vl["METER_CLUSTER"]["BACK_LEFT_DOOR"],
cp.vl["METER_CLUSTER"]["BACK_RIGHT_DOOR"]])
ret.seatbeltUnlatched = cp.vl["METER_CLUSTER"]["SEATBELT_DRIVER"] != 1
# blindspot sensors
# ret.leftBlindspot = False
# ret.rightBlindspot = False
# Messages needed by carcontroller
# for generate MPC_LKAS_CMD
self.mpc_lkas_cmd_msg = copy.copy(cp_cam.vl["MPC_LKAS_CMD"])
self.eps_prepared = cp.vl["STEERING_TORQUE"]["LKSPrepare"] != 0
self.eps_activated = cp.vl["STEERING_TORQUE"]["Cruise_Activated"] != 0
# for generate STEERING_TORQUE
self.eps_steering_torque_msg = copy.copy(cp.vl["STEERING_TORQUE"])
self.mpc_lkas_output = cp_cam.vl["MPC_LKAS_CMD"]["LKAS_Output"]
self.mpc_lkas_active = cp_cam.vl["MPC_LKAS_CMD"]["LKAS_ACTIVE"] != 0
self.mpc_lkas_request_prepare = cp_cam.vl["MPC_LKAS_CMD"]["LKASPrepare"] != 0
# for generate ACC_CMD
self.acc_cmd_msg = copy.copy(cp_cam.vl["ACC_CMD"])
return ret, ret_sp
@staticmethod
def get_can_parsers(CP, CP_SP):
pt_messages = [
# sig_address, frequency
("ESC", 50),
("BRAKE_APPLIED", 50),
("PEDAL", 50),
("STEER_MODULE", 100),
("STEERING_TORQUE", 50),
("DRIVE_STATE", 50),
("STALKS", 20),
("METER_CLUSTER", 20),
("PCM_BUTTONS", 20),
]
cam_messages = [
("ACC_HUD_ADAS", 50),
("MPC_LKAS_CMD", 50),
("ACC_CMD", 25),
]
return {
Bus.pt: CANParser(DBC[CP.carFingerprint][Bus.pt], pt_messages, CANBUS.main_bus),
Bus.cam: CANParser(DBC[CP.carFingerprint][Bus.pt], cam_messages, CANBUS.cam_bus),
}
@@ -0,0 +1,22 @@
from opendbc.car.structs import CarParams
from opendbc.car.byd.values import CAR
Ecu = CarParams.Ecu
FINGERPRINTS = {
# NOTE: the HAN EV 23 fingerprint is a minimal subset of the SEAL fingerprint,
# so a HAN cannot be uniquely identified by live CAN fingerprinting.
# Set FINGERPRINT=BYD_HAN_EV_23 (and SKIP_FW_QUERY) to force it.
CAR.BYD_HAN_EV_23: [{
140: 8, 213: 8, 287: 5, 289: 8, 291: 8, 301: 8, 307: 8, 337: 8, 496: 8, 536: 8, 544: 8, 546: 8, 547: 8, 575: 8, 576: 8
}],
CAR.BYD_SEAL_PERFORMANCE_25: [{
140: 8, 213: 8, 287: 5, 289: 8, 291: 8, 301: 8, 307: 8, 311: 8, 312: 8, 337: 8, 359: 8, 482: 8, 493: 8, 496: 8, 508: 8,
511: 8, 536: 8, 544: 8, 546: 8, 547: 8, 567: 8, 575: 8, 576: 8, 578: 8, 588: 8, 604: 8, 612: 8, 626: 8, 657: 8, 660: 8,
661: 8, 663: 8, 668: 8, 692: 8, 694: 8, 714: 8, 724: 8, 748: 8, 758: 8, 790: 8, 797: 8, 798: 8, 801: 8, 802: 8, 803: 8,
813: 8, 814: 8, 815: 8, 833: 8, 834: 8, 836: 8, 837: 8, 854: 8, 860: 8, 868: 8, 877: 8, 904: 8, 906: 8, 944: 8, 948: 8,
951: 8, 965: 8, 973: 8, 985: 8, 1023: 8, 1028: 8, 1031: 8, 1033: 8, 1040: 8, 1048: 8, 1058: 8, 1074: 8, 1092: 8, 1093: 8,
1107: 8, 1108: 8, 1141: 8, 1166: 8, 1168: 8, 1178: 8, 1189: 8, 1193: 8, 1203: 64, 1204: 64, 1226: 16, 1246: 8, 1297: 8,
1319: 8, 1322: 8, 1365: 8, 1366: 8
}],
}
+49
View File
@@ -0,0 +1,49 @@
from opendbc.car import get_safety_config, structs
from opendbc.car.common.conversions import Conversions as CV
from opendbc.car.interfaces import CarInterfaceBase
from opendbc.car.byd.carcontroller import CarController
from opendbc.car.byd.carstate import CarState
from opendbc.car.byd.values import CAR, BydFlags, BydSafetyFlags
class CarInterface(CarInterfaceBase):
CarState = CarState
CarController = CarController
@staticmethod
def _get_params(ret: structs.CarParams, candidate, fingerprint, car_fw, alpha_long, is_release, docs) -> structs.CarParams:
ret.brand = "byd"
ret.dashcamOnly = False
ret.safetyConfigs = [get_safety_config(structs.CarParams.SafetyModel.byd)]
# lateral control parameters
ret.steerActuatorDelay = 0.3
ret.steerLimitTimer = 0.5
if candidate in (CAR.BYD_HAN_EV_23, CAR.BYD_SEAL_PERFORMANCE_25):
ret.steerControlType = structs.CarParams.SteerControlType.torque
ret.minEnableSpeed = -1.
ret.minSteerSpeed = 0.1 * CV.KPH_TO_MS
ret.steerLimitTimer = 0.5
if ret.steerControlType == structs.CarParams.SteerControlType.torque:
CarInterfaceBase.configure_torque_tune(candidate, ret.lateralTuning)
# longitudinal control parameters
ret.alphaLongitudinalAvailable = True
if alpha_long:
ret.openpilotLongitudinalControl = True
ret.startingState = True
ret.startAccel = 0.1
ret.flags |= BydFlags.LONG_CONTROL.value
ret.safetyConfigs[0].safetyParam |= BydSafetyFlags.LONG_CONTROL.value
ret.vEgoStopping = 0.1
ret.vEgoStarting = 0.1
ret.stoppingDecelRate = 0.3
# TODO: add radar support
ret.radarUnavailable = True
return ret
+78
View File
@@ -0,0 +1,78 @@
from dataclasses import dataclass, field
from enum import IntFlag
from opendbc.car import Bus, DbcDict, PlatformConfig, Platforms, CarSpecs, STD_CARGO_KG
from opendbc.car.structs import CarParams, CarState
from opendbc.car.docs_definitions import CarHarness, CarDocs, CarParts
Ecu = CarParams.Ecu
class CANBUS:
main_bus = 0
radar_bus = 1
cam_bus = 2
class BydSafetyFlags(IntFlag):
LONG_CONTROL = 1
class BydFlags(IntFlag):
LONG_CONTROL = 1
@dataclass
class BydCarDocs(CarDocs):
package: str = "All"
car_parts: CarParts = field(default_factory=CarParts.common([CarHarness.custom]))
#todo add docs and harness info
@dataclass
class BydPlatformConfig(PlatformConfig):
dbc_dict: DbcDict = field(default_factory=lambda: {Bus.pt: "byd_common"})
class CAR(Platforms):
BYD_HAN_EV_23 = BydPlatformConfig(
[BydCarDocs("BYD HAN EV 2023")],
CarSpecs(mass=1940 + STD_CARGO_KG, wheelbase=2.92, steerRatio=16.5,
centerToFrontRatio=0.44, tireStiffnessFactor=1.0)
)
BYD_SEAL_PERFORMANCE_25 = BydPlatformConfig(
[BydCarDocs("BYD SEAL PERFORMANCE 2025")],
# TODO: verify steerRatio and centerToFrontRatio on a real car
CarSpecs(mass=2100 + STD_CARGO_KG, wheelbase=2.92, steerRatio=16.0,
centerToFrontRatio=0.44, tireStiffnessFactor=1.0)
)
class CarControllerParams:
def __init__(self, CP):
self.STEER_STEP = 2 # 50Hz
self.ACC_SETP = 4 # 25Hz
self.STEER_ERROR_MAX = 46
if CP.carFingerprint in (CAR.BYD_HAN_EV_23, CAR.BYD_SEAL_PERFORMANCE_25):
self.STEER_MAX = 300
self.STEER_DELTA_UP = 6
self.STEER_DELTA_DOWN = 6
self.ACCEL_MAX = 2.0 # m/s^2
self.ACCEL_MIN = -4.0 # m/s^2
self.JERK_LIMIT_MAX = 4.0 # m/s^3
self.JERK_LIMIT_MIN = -4.0 # m/s^3
STEER_THRESHOLD = 1
GEAR_MAP = {
4: CarState.GearShifter.drive,
2: CarState.GearShifter.reverse,
3: CarState.GearShifter.neutral,
1: CarState.GearShifter.park,
}
# TODO: Get a BYD VDS to see how firmware could be queried. Until then BYD is
# identified by legacy CAN fingerprinting only.
DBC = CAR.create_dbc_map()