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

@@ -34,6 +34,7 @@
#define SAFETY_PSA 31U
#define SAFETY_RIVIAN 33U
#define SAFETY_VOLKSWAGEN_MEB 34U
#define SAFETY_BYD 35U
#define GET_BIT(msg, b) ((bool)!!(((msg)->data[((b) / 8U)] >> ((b) % 8U)) & 0x1U))
#define GET_FLAG(value, mask) (((value) & (mask)) == (mask))
@@ -368,3 +369,4 @@ extern const safety_hooks volkswagen_meb_hooks;
extern const safety_hooks volkswagen_pq_hooks;
extern const safety_hooks rivian_hooks;
extern const safety_hooks psa_hooks;
extern const safety_hooks byd_hooks;
+145
View File
@@ -0,0 +1,145 @@
#include "opendbc/safety/declarations.h"
// MPC_LKAS_CMD (790), little endian
#define BYD_GET_LKAS_OUTPUT(msg) (to_signed((((msg)->data[3] & 0x7U) << 8U) | (msg)->data[2], 11))
#define BYD_LKAS_ACTIVE_BIT 28U
// STEERING_TORQUE (792), little endian
#define BYD_GET_MAIN_TORQUE(msg) (to_signed((((msg)->data[2] & 0xFU) << 8U) | (msg)->data[1], 12))
#define BYD_GET_DRIVER_TORQUE(msg) (to_signed((((msg)->data[4] & 0xFU) << 8U) | (msg)->data[3], 12))
// PCM_BUTTONS (944)
#define BYD_LKAS_ON_BTN_BIT 14U
static bool byd_tx_hook(const CANPacket_t *msg) {
const TorqueSteeringLimits BYD_STEERING_LIMITS = {
.max_torque = 300,
.max_rate_up = 6,
.max_rate_down = 6,
.max_rt_delta = 112, // 75 per 250ms at 50Hz steer rate, plus 50% buffer
.type = TorqueMotorLimited,
.driver_torque_allowance = 46,
.driver_torque_multiplier = 1,
.max_torque_error = 46,
};
const LongitudinalLimits BYD_LONG_LIMITS = {
.max_accel = 140, // 2.0 m/s^2 (raw = (m/s^2 + 5) / 0.05)
.min_accel = 20, // -4.0 m/s^2
.inactive_accel = 100, // 0 m/s^2, sent when longitudinal control is inactive
};
bool tx = true;
// MPC_LKAS_CMD: steering actuation towards the EPS
if (msg->addr == 790U) {
int desired_torque = BYD_GET_LKAS_OUTPUT(msg);
bool steer_req = GET_BIT(msg, BYD_LKAS_ACTIVE_BIT);
if (steer_torque_cmd_checks(desired_torque, steer_req, BYD_STEERING_LIMITS)) {
tx = false;
}
}
// STEERING_TORQUE: feedback message towards the camera, torque echoes the
// camera's own request. Only sanity-check the absolute limit so stock LKAS
// requests don't fault when openpilot is inactive.
if (msg->addr == 792U) {
int main_torque = BYD_GET_MAIN_TORQUE(msg);
if (safety_max_limit_check(main_torque, BYD_STEERING_LIMITS.max_torque, -BYD_STEERING_LIMITS.max_torque)) {
tx = false;
}
}
// ACC_CMD: longitudinal actuation
if (msg->addr == 814U) {
int desired_accel = msg->data[0];
if (longitudinal_accel_checks(desired_accel, BYD_LONG_LIMITS)) {
tx = false;
}
}
return tx;
}
static void byd_rx_hook(const CANPacket_t *msg) {
// Main Bus
if (msg->bus == 0U) {
// PEDAL
if (msg->addr == 834U) {
gas_pressed = msg->data[0] != 0U;
brake_pressed = msg->data[1] != 0U;
}
// ESC
if (msg->addr == 289U) {
vehicle_moving = (((msg->data[1] & 0x0FU) << 8U) | msg->data[0]) != 0U;
}
// STEERING_TORQUE: sample EPS output torque and driver torque
if (msg->addr == 792U) {
int torque_meas_new = BYD_GET_MAIN_TORQUE(msg);
update_sample(&torque_meas, torque_meas_new);
torque_meas.min--;
torque_meas.max++;
int torque_driver_new = BYD_GET_DRIVER_TORQUE(msg);
update_sample(&torque_driver, torque_driver_new);
}
// PCM_BUTTONS: dedicated LKAS steering wheel button for MADS
if (msg->addr == 944U) {
mads_button_press = GET_BIT(msg, BYD_LKAS_ON_BTN_BIT) ? MADS_BUTTON_PRESSED : MADS_BUTTON_NOT_PRESSED;
}
}
// Cam Bus
else if (msg->bus == 2U) {
// ACC_HUD_ADAS
if (msg->addr == 813U) {
// CRUISE_STATE in (3, 5) == (Active, Override)
uint8_t cruise_state = (msg->data[5] >> 4U) & 0x0FU;
pcm_cruise_check((cruise_state == 3U) || (cruise_state == 5U));
}
} else {
}
}
static safety_config byd_init(uint16_t param) {
static const CanMsg BYD_TX_MSGS[] = {
{790, 0, 8, .check_relay = true}, // MPC_LKAS_CMD
{792, 2, 8, .check_relay = true}, // STEERING_TORQUE
};
static const CanMsg BYD_TX_LONG_MSGS[] = {
{790, 0, 8, .check_relay = true}, // MPC_LKAS_CMD
{792, 2, 8, .check_relay = true}, // STEERING_TORQUE
{814, 0, 8, .check_relay = true}, // ACC_CMD
};
static RxCheck byd_rx_checks[] = {
{.msg = {{578, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // DRIVE_STATE
{.msg = {{544, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // BRAKE_APPLIED
{.msg = {{834, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // PEDAL
{.msg = {{289, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // ESC
{.msg = {{287, 0, 5, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // STEER_MODULE
{.msg = {{792, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // STEERING_TORQUE
{.msg = {{944, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // PCM_BUTTONS
{.msg = {{813, 2, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // ACC_HUD_ADAS
{.msg = {{307, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // STALKS
{.msg = {{660, 0, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // METER_CLUSTER
{.msg = {{790, 2, 8, .ignore_checksum = true, .ignore_counter = true, .ignore_quality_flag = true}, { 0 }, { 0 }}}, // MPC_LKAS_CMD
};
const uint16_t BYD_FLAG_LONG_CONTROL = 1;
const bool byd_longitudinal = GET_FLAG(param, BYD_FLAG_LONG_CONTROL);
safety_config ret;
if (byd_longitudinal) {
ret = BUILD_SAFETY_CFG(byd_rx_checks, BYD_TX_LONG_MSGS);
} else {
ret = BUILD_SAFETY_CFG(byd_rx_checks, BYD_TX_MSGS);
}
return ret;
}
const safety_hooks byd_hooks = {
.init = byd_init,
.rx = byd_rx_hook,
.tx = byd_tx_hook,
};
+2
View File
@@ -29,6 +29,7 @@
#include "opendbc/safety/modes/body.h"
#include "opendbc/safety/modes/psa.h"
#include "opendbc/safety/modes/hyundai_canfd.h"
#include "opendbc/safety/modes/byd.h"
uint32_t GET_BYTES(const CANPacket_t *msg, int start, int len) {
uint32_t ret = 0U;
@@ -419,6 +420,7 @@ int set_safety_hooks(uint16_t mode, uint16_t param) {
{SAFETY_RIVIAN, &rivian_hooks},
{SAFETY_TESLA, &tesla_hooks},
{SAFETY_HYUNDAI_CANFD, &hyundai_canfd_hooks},
{SAFETY_BYD, &byd_hooks},
#ifdef ALLOW_DEBUG
{SAFETY_CHRYSLER_CUSW, &chrysler_cusw_hooks},
{SAFETY_PSA, &psa_hooks},
@@ -1017,6 +1017,8 @@ class SafetyTest(SafetyTestBase):
continue
if attr.startswith('TestFord') and current_test.startswith('TestFord'):
continue
if attr.startswith('TestByd') and current_test.startswith('TestByd'):
continue
if attr.startswith('TestHyundaiCanfd') and current_test.startswith('TestHyundaiCanfd'):
continue
if {attr, current_test}.issubset({'TestHyundaiLongitudinalSafety', 'TestHyundaiLongitudinalSafetyCameraSCC', 'TestHyundaiSafetyFCEVLong'}):
@@ -0,0 +1,140 @@
#!/usr/bin/env python3
import unittest
from opendbc.car.structs import CarParams
from opendbc.safety.tests.libsafety import libsafety_py
import opendbc.safety.tests.common as common
from opendbc.safety.tests.common import CANPackerSafety
MSG_MPC_LKAS_CMD = 790 # TX by OP, lateral actuation towards EPS
MSG_STEERING_TORQUE = 792 # RX from EPS / TX by OP, torque feedback towards camera
MSG_ACC_HUD_ADAS = 813 # RX from camera, ACC state
MSG_ACC_CMD = 814 # TX by OP, longitudinal actuation
MSG_PCM_BUTTONS = 944 # RX from PCM, steering wheel buttons
def byd_checksum(msg):
addr, dat, bus = msg
ret = bytearray(dat)
if addr in (MSG_MPC_LKAS_CMD, MSG_STEERING_TORQUE, MSG_ACC_CMD):
byte_key = 0xAF
sum_first = sum(byte >> 4 for byte in ret) # upper nibbles
sum_second = sum(byte & 0xF for byte in ret) # lower nibbles
remainder = sum_second >> 4
sum_first += (byte_key & 0xF)
sum_second += (byte_key >> 4)
inv_first = ((-sum_first + 0x9) & 0xF)
inv_second = ((-sum_second + 0x9) & 0xF)
ret[7] = (((inv_first + (5 - remainder)) << 4) + inv_second) & 0xFF
return addr, ret, bus
class TestBydSafetyBase(common.CarSafetyTest, common.MotorTorqueSteeringSafetyTest):
TX_MSGS = [[MSG_MPC_LKAS_CMD, 0], [MSG_STEERING_TORQUE, 2]]
STANDSTILL_THRESHOLD = 0
RELAY_MALFUNCTION_ADDRS = {0: (MSG_MPC_LKAS_CMD,), 2: (MSG_STEERING_TORQUE,)}
FWD_BLACKLISTED_ADDRS = {0: [MSG_STEERING_TORQUE], 2: [MSG_MPC_LKAS_CMD]}
MAX_TORQUE_LOOKUP = ([0], [300])
MAX_RATE_UP = 6
MAX_RATE_DOWN = 6
MAX_RT_DELTA = 112
MAX_TORQUE_ERROR = 46
TORQUE_MEAS_TOLERANCE = 1
def setUp(self):
self.packer = CANPackerSafety("byd_common")
self.safety = libsafety_py.libsafety
self.safety.set_safety_hooks(CarParams.SafetyModel.byd, 0)
self.safety.init_tests()
def _torque_cmd_msg(self, torque, steer_req=1):
values = {"LKAS_Output": torque, "LKAS_ACTIVE": steer_req}
return self.packer.make_can_msg_safety("MPC_LKAS_CMD", 0, values, byd_checksum)
def _torque_meas_msg(self, torque):
values = {"MAIN_TORQUE": torque}
return self.packer.make_can_msg_safety("STEERING_TORQUE", 0, values)
def _torque_driver_msg(self, torque):
values = {"Steer_Torque_Sensor": torque}
return self.packer.make_can_msg_safety("STEERING_TORQUE", 0, values)
def _speed_msg(self, speed):
values = {"VEHICLE_SPEED": speed}
return self.packer.make_can_msg_safety("ESC", 0, values)
def _user_brake_msg(self, brake):
values = {"BRAKE_PEDAL": brake}
return self.packer.make_can_msg_safety("PEDAL", 0, values)
def _user_gas_msg(self, gas):
values = {"GAS_PEDAL": gas}
return self.packer.make_can_msg_safety("PEDAL", 0, values)
def _pcm_status_msg(self, enable):
# CRUISE_STATE: 3 == Active, 0 == Off
values = {"CRUISE_STATE": 3 if enable else 0}
return self.packer.make_can_msg_safety("ACC_HUD_ADAS", 2, values)
def _lkas_button_msg(self, enabled):
values = {"LKAS_ON_BTN": enabled}
return self.packer.make_can_msg_safety("PCM_BUTTONS", 0, values)
def _acc_state_msg(self, enable):
# BYD has no separate ACC main switch state in panda; MADS is toggled
# with the dedicated LKAS steering wheel button instead
raise NotImplementedError
class TestBydStockSafety(TestBydSafetyBase):
pass
class TestBydLongitudinalSafety(TestBydSafetyBase):
TX_MSGS = [[MSG_MPC_LKAS_CMD, 0], [MSG_STEERING_TORQUE, 2], [MSG_ACC_CMD, 0]]
RELAY_MALFUNCTION_ADDRS = {0: (MSG_MPC_LKAS_CMD, MSG_ACC_CMD), 2: (MSG_STEERING_TORQUE,)}
FWD_BLACKLISTED_ADDRS = {0: [MSG_STEERING_TORQUE], 2: [MSG_MPC_LKAS_CMD, MSG_ACC_CMD]}
MIN_ACCEL = 20 # -4.0 m/s^2, raw = (m/s^2 + 5) / 0.05
MAX_ACCEL = 140 # 2.0 m/s^2
INACTIVE_ACCEL = 100 # 0 m/s^2
def setUp(self):
self.packer = CANPackerSafety("byd_common")
self.safety = libsafety_py.libsafety
self.safety.set_safety_hooks(CarParams.SafetyModel.byd, 1) # BydSafetyFlags.LONG_CONTROL
self.safety.init_tests()
def _accel_msg(self, accel: float):
# accel in m/s^2, ACCEL_CMD raw = (m/s^2 + 5) / 0.05
values = {"ACCEL_CMD": accel}
return self.packer.make_can_msg_safety("ACC_CMD", 0, values, byd_checksum)
def test_accel_actuation_limits(self):
self.safety.set_controls_allowed(True)
for accel in [self.MIN_ACCEL - 1, self.MIN_ACCEL, 100, self.MAX_ACCEL, self.MAX_ACCEL + 1]:
send = self.MIN_ACCEL <= accel <= self.MAX_ACCEL
self.assertEqual(send, self._tx(self._accel_raw_msg(accel)), f"{accel=}")
def _accel_raw_msg(self, raw: int):
msg = self._accel_msg(0)
msg[0].data[0] = raw & 0xFF
return msg
def test_accel_when_not_allowed(self):
# when controls are not allowed, only 0 m/s^2 (inactive) may be sent
self.safety.set_controls_allowed(False)
self.assertTrue(self._tx(self._accel_raw_msg(self.INACTIVE_ACCEL)))
self.assertFalse(self._tx(self._accel_raw_msg(self.INACTIVE_ACCEL + 5)))
self.assertFalse(self._tx(self._accel_raw_msg(self.INACTIVE_ACCEL - 5)))
if __name__ == "__main__":
unittest.main()