自动驾驶系统的车辆动力学建模：自行车模型与汽车模型的对比分析

在自动驾驶系统的车辆动力学建模中，自行车模型（Bicycle Model）和更复杂的汽车模型（如双轨模型或多体动力学模型）各有其适用场景和优缺点。以下是两者的详细对比及选择原因解析：

1. 模型定义与核心差异

2. 为什么自动驾驶常用自行车模型？

2.1 计算效率优势

自行车模型的核心运动学方程为：
$$\delta =\arctan \left(\frac{L}{R}\right)$$
其中，( L )为轴距，( R )为转弯半径。其计算仅涉及简单的三角函数，可在1ms内完成，满足控制系统的实时性要求（通常需10-100Hz更新频率）。

相比之下，双轨模型需解算非线性方程组：
$$\{\begin{array}{l}{F}_{yf}=C_{\alpha f}{\alpha }_f\\ F_{yr}=C_{\alpha r}{\alpha }_r\\ {\alpha }_f=\delta -\frac{v_y+a\dot{\psi }}{v_x}\\ {\alpha }_r=\frac{b\dot{\psi }-v_y}{v_x}\end{array}$$
计算耗时可能达到10ms以上，难以满足实时控制需求。

2.2 参数易获取性

自行车模型仅需轴距（L）和转向传动比等少量参数，而复杂模型需要详细的车辆参数（如轮胎侧偏刚度( C_{\alpha} )、悬架刚度等），这些数据可能因车型不同而难以获取。

2.3 适用场景匹配

在低速城市道路（<50km/h）和中等曲率转弯场景下，自行车模型的预测误差通常小于5%，足以满足控制精度要求。而高速或极限工况（如漂移）则需要更精确的模型。

3. 复杂汽车模型的应用场景

尽管自行车模型广泛使用，但在以下场景中需切换至复杂模型：

1. 高速稳定性控制（>80km/h）：需考虑横向载荷转移对轮胎抓地力的影响。
2. 极限工况仿真：如紧急避障时车辆进入非线性区域的动力学行为。
3. 车辆动力学测试：评估ESP（电子稳定程序）等系统时需精确建模。

示例代码（双轨模型片段）：

def double_track_model(state, delta, Fx):
    # 状态变量: [vx, vy, omega, X, Y, psi]
    # 输入: 前轮转角delta, 驱动力Fx
    m = 1500  # 质量 (kg)
    Iz = 2500  # 绕Z轴转动惯量 (kg·m²)
    lf, lr = 1.2, 1.5  # 前后轴到质心距离 (m)
    C_alpha_f, C_alpha_r = 80000, 80000  # 前后轮胎侧偏刚度 (N/rad)
    
    alpha_f = delta - (state[1] + lf * state[2]) / state[0]
    alpha_r = (state[1] - lr * state[2]) / state[0]
    
    Fyf = C_alpha_f * alpha_f
    Fyr = C_alpha_r * alpha_r
    
    dvx = (Fx - Fyf * np.sin(delta)) / m + state[1] * state[2]
    dvy = (Fyf * np.cos(delta) + Fyr) / m - state[0] * state[2]
    domega = (lf * Fyf * np.cos(delta) - lr * Fyr) / Iz
    
    return [dvx, dvy, domega, state[0]*np.cos(state[4]) - state[1]*np.sin(state[4]),
            state[0]*np.sin(state[4]) + state[1]*np.cos(state[4]), state[2]]

4. 自行车模型代码实现及应用举例

import numpy as np
import matplotlib.pyplot as plt

class BicycleModel:
    def __init__(self, L=2.0, max_steer=30.0):  # L:轴距，max_steer:最大转向角
        self.L = L
        self.max_steer = np.deg2rad(max_steer)  # 转换为弧度

    def kinematic_model(self, x, y, theta, v, delta):  # x,y:位置，theta:航向角，v:速度，delta:前轮转角
        delta = np.clip(delta, -self.max_steer, self.max_steer)  # 限制转向角在最大值内
        beta = np.arctan(1 / (2 * self.L * np.tan(delta) / v))  # 滑移角计算
        x_dot = v * np.cos(theta + beta)  # x方向速度
        y_dot = v * np.sin(theta + beta)  # y方向速度
        theta_dot = v / self.L * np.tan(delta) * np.cos(beta)  # 航向角变化率
        return x_dot, y_dot, theta_dot

    def simulate(self, initial_state, v, delta, dt, steps):  # 初始状态，速度，转向角，时间步长，步数
        x_traj = [initial_state[0]]  # x轨迹
        y_traj = [initial_state[1]]  # y轨迹
        theta_traj = [initial_state[2]]  # 航向角轨迹
        current_state = initial_state
        for _ in range(steps):
            x_dot, y_dot, theta_dot = self.kinematic_model(*current_state, v, delta)
            current_state = (
                current_state[0] + x_dot * dt,
                current_state[1] + y_dot * dt,
                current_state[2] + theta_dot * dt
            )
            x_traj.append(current_state[0])
            y_traj.append(current_state[1])
            theta_traj.append(current_state[2])
        return x_traj, y_traj, theta_traj

# 应用举例：低速园区物流车路径跟踪
if __name__ == "__main__":
    # 初始化自行车模型，轴距2米，最大转向角30度
    bike_model = BicycleModel(L=2.0, max_steer=30.0)
    # 初始状态：位置(0,0)，航向角0弧度
    initial_state = (0.0, 0.0, 0.0)
    # 设置速度为5m/s，转向角为0.5弧度（约28.6度）
    v = 5.0
    delta = 0.5
    # 模拟时间步长0.1s，共100步
    dt = 0.1
    steps = 100
    # 进行模拟
    x_traj, y_traj, theta_traj = bike_model.simulate(initial_state, v, delta, dt, steps)
    # 绘制轨迹
    plt.figure(figsize=(10, 6))
    plt.plot(x_traj, y_traj, label="Vehicle Trajectory")
    plt.scatter([x_traj[0]], [y_traj[0]], c='r', label="Start Point")
    plt.scatter([x_traj[-1]], [y_traj[-1]], c='g', label="End Point")
    plt.xlabel("X (m)")
    plt.ylabel("Y (m)")
    plt.title("Bicycle Model Simulation for Low-speed Park Logistics Vehicle")
    plt.legend()
    plt.grid()
    plt.show()

应用举例说明：
在低速园区物流车场景中，自行车模型能够快速生成车辆的行驶轨迹。通过设置车辆的初始位置、速度和转向角，模拟出车辆在园区道路上的行驶路径。从模拟结果可以看出，车辆按照设定的参数稳定地沿着一定曲率的路径行驶，验证了自行车模型在低速场景下的有效性和计算效率。

5. 双轨模型代码实现及应用举例

class DoubleTrackModel:
    def __init__(self, m=1500, Iz=2500, lf=1.2, lr=1.5, C_alpha_f=80000, C_alpha_r=80000):
        self.m = m  # 车辆质量
        self.Iz = Iz  # 绕Z轴转动惯量
        self.lf = lf  # 前轴到质心距离
        self.lr = lr  # 后轴到质心距离
        self.C_alpha_f = C_alpha_f  # 前轮胎侧偏刚度
        self.C_alpha_r = C_alpha_r  # 后轮胎侧偏刚度

    def dynamic_model(self, state, delta, Fx):
        vx, vy, omega, X, Y, psi = state
        # 计算前后轮胎的侧偏角
        alpha_f = delta - (vy + self.lf * omega) / vx
        alpha_r = (vy - self.lr * omega) / vx
        # 计算前后轮胎的侧向力
        Fyf = self.C_alpha_f * alpha_f
        Fyr = self.C_alpha_r * alpha_r
        # 计算车辆的加速度和角加速度
        dvx = (Fx - Fyf * np.sin(delta)) / self.m + vy * omega
        dvy = (Fyf * np.cos(delta) + Fyr) / self.m - vx * omega
        domega = (self.lf * Fyf * np.cos(delta) - self.lr * Fyr) / self.Iz
        # 计算位置和航向角的变化
        dX = vx * np.cos(psi) - vy * np.sin(psi)
        dY = vx * np.sin(psi) + vy * np.cos(psi)
        dpsi = omega
        return [dvx, dvy, domega, dX, dY, dpsi]

    def simulate(self, initial_state, delta, Fx, dt, steps):
        vx_traj = [initial_state[0]]
        vy_traj = [initial_state[1]]
        omega_traj = [initial_state[2]]
        X_traj = [initial_state[3]]
        Y_traj = [initial_state[4]]
        psi_traj = [initial_state[5]]
        current_state = initial_state
        for _ in range(steps):
            state_dot = self.dynamic_model(current_state, delta, Fx)
            current_state = [
                current_state[0] + state_dot[0] * dt,
                current_state[1] + state_dot[1] * dt,
                current_state[2] + state_dot[2] * dt,
                current_state[3] + state_dot[3] * dt,
                current_state[4] + state_dot[4] * dt,
                current_state[5] + state_dot[5] * dt
            ]
            vx_traj.append(current_state[0])
            vy_traj.append(current_state[1])
            omega_traj.append(current_state[2])
            X_traj.append(current_state[3])
            Y_traj.append(current_state[4])
            psi_traj.append(current_state[5])
        return vx_traj, vy_traj, omega_traj, X_traj, Y_traj, psi_traj

# 应用举例：高速公路L3级自动驾驶车辆稳定性分析
if __name__ == "__main__":
    # 初始化双轨模型
    double_track = DoubleTrackModel()
    # 初始状态：纵向速度20m/s，侧向速度0，角速度0，位置(0,0)，航向角0弧度
    initial_state = [20.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    # 设置前轮转角0.1弧度，驱动力1000N
    delta = 0.1
    Fx = 1000.0
    # 模拟时间步长0.01s，共200步
    dt = 0.01
    steps = 200
    # 进行模拟
    vx_traj, vy_traj, omega_traj, X_traj, Y_traj, psi_traj = double_track.simulate(initial_state, delta, Fx, dt, steps)
    # 绘制纵向速度、侧向速度和角速度的变化
    time = np.arange(0, steps*dt, dt)
    plt.figure(figsize=(12, 8))
    plt.subplot(3, 1, 1)
    plt.plot(time, vx_traj)
    plt.xlabel("Time (s)")
    plt.ylabel("Longitudinal Speed (m/s)")
    plt.title("Longitudinal Speed Variation")
    plt.grid()
    plt.subplot(3, 1, 2)
    plt.plot(time, vy_traj)
    plt.xlabel("Time (s)")
    plt.ylabel("Lateral Speed (m/s)")
    plt.title("Lateral Speed Variation")
    plt.grid()
    plt.subplot(3, 1, 3)
    plt.plot(time, omega_traj)
    plt.xlabel("Time (s)")
    plt.ylabel("Yaw Rate (rad/s)")
    plt.title("Yaw Rate Variation")
    plt.grid()
    plt.tight_layout()
    plt.show()
    # 绘制车辆行驶轨迹
    plt.figure(figsize=(10, 6))
    plt.plot(X_traj, Y_traj, label="Vehicle Trajectory")
    plt.scatter([X_traj[0]], [Y_traj[0]], c='r', label="Start Point")
    plt.scatter([X_traj[-1]], [Y_traj[-1]], c='g', label="End Point")
    plt.xlabel("X (m)")
    plt.ylabel("Y (m)")
    plt.title("Double Track Model Simulation for Highway L3 Autonomous Vehicle")
    plt.legend()
    plt.grid()
    plt.show()

应用举例说明：
在高速公路L3级自动驾驶场景中，双轨模型能够更精确地分析车辆在高速行驶时的稳定性。通过设置车辆的初始状态、前轮转角和驱动力，模拟出车辆在高速公路上的行驶动态。从模拟结果可以看出，车辆的纵向速度、侧向速度和角速度随时间的变化趋势，以及车辆的行驶轨迹。这有助于评估车辆在高速行驶时的稳定性和安全性，验证了双轨模型在高速场景下的必要性和精确性。

通过以上代码实现和应用举例，可以更深入地理解自行车模型和双轨模型在不同自动驾驶场景下的应用和特点。

6. 实际工程中的混合策略

在自动驾驶系统中，常采用分层建模策略：

• 上层路径规划：使用自行车模型快速生成参考轨迹。
• 底层控制：根据车速动态切换模型：

  def select_vehicle_model(speed):
      if speed < 15:  # m/s (约54km/h)
          return BicycleModel()
      else:
          return DoubleTrackModel()
  

• 仿真验证：在PreScan/CarSim等工具中使用高精度模型验证算法。

7. 关键结论

8. 总结

自行车模型因其简洁性和实时性成为自动驾驶控制算法的首选，而复杂模型则用于特定场景验证和车辆动力学深度分析。实际工程中需根据车速、控制频率和可用参数动态选择模型，以平衡精度与计算效率。

下一篇将讲解混合策略的应用示例以及可视化验证代码，欢迎关注！