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()
+1
View File
@@ -634,6 +634,7 @@ struct CarParams {
fcaGiorgio @32;
rivian @33;
volkswagenMeb @34;
byd @35;
}
enum SteerControlType {
+3
View File
@@ -1,5 +1,6 @@
from opendbc.car.interfaces import get_interface_attr
from opendbc.car.body.values import CAR as BODY
from opendbc.car.byd.values import CAR as BYD
from opendbc.car.chrysler.values import CAR as CHRYSLER
from opendbc.car.ford.values import CAR as FORD
from opendbc.car.gm.values import CAR as GM
@@ -56,6 +57,8 @@ def all_legacy_fingerprint_cars():
# A dict that maps old platform strings to their latest representations
MIGRATION = {
"BYD HAN EV 23": BYD.BYD_HAN_EV_23,
"BYD SEAL PERFORMANCE 2025": BYD.BYD_SEAL_PERFORMANCE_25,
"ACURA ILX 2016 ACURAWATCH PLUS": HONDA.ACURA_ILX,
"ACURA RDX 2018 ACURAWATCH PLUS": HONDA.ACURA_RDX,
"ACURA RDX 2020 TECH": HONDA.ACURA_RDX_3G,
@@ -1,4 +1,6 @@
legend = ["LAT_ACCEL_FACTOR", "MAX_LAT_ACCEL_MEASURED", "FRICTION"]
"BYD_HAN_EV_23" = [1.807, 1.674, 0.04]
"BYD_SEAL_PERFORMANCE_25" = [1.807, 1.674, 0.04]
"ACURA_ILX" = [1.524988973896102, 0.519011053086259, 0.34236219253028]
"ACURA_RDX" = [0.9987728568686902, 0.5323765166196301, 0.303218805715844]
"ACURA_RDX_3G" = [1.4314459806646749, 0.33874701282109954, 0.18048847083897598]
+2 -1
View File
@@ -1,5 +1,6 @@
from typing import get_args
from opendbc.car.body.values import CAR as BODY
from opendbc.car.byd.values import CAR as BYD
from opendbc.car.chrysler.values import CAR as CHRYSLER
from opendbc.car.ford.values import CAR as FORD
from opendbc.car.gm.values import CAR as GM
@@ -15,7 +16,7 @@ from opendbc.car.tesla.values import CAR as TESLA
from opendbc.car.toyota.values import CAR as TOYOTA
from opendbc.car.volkswagen.values import CAR as VOLKSWAGEN
Platform = BODY | CHRYSLER | FORD | GM | HONDA | HYUNDAI | MAZDA | MOCK | NISSAN | PSA | RIVIAN | SUBARU | TESLA | TOYOTA | VOLKSWAGEN
Platform = BODY | BYD | CHRYSLER | FORD | GM | HONDA | HYUNDAI | MAZDA | MOCK | NISSAN | PSA | RIVIAN | SUBARU | TESLA | TOYOTA | VOLKSWAGEN
BRANDS = get_args(Platform)
PLATFORMS: dict[str, Platform] = {str(platform): platform for brand in BRANDS for platform in brand}