1. 引言

在自动驾驶技术的发展过程中，对车辆运动的理解和建模至关重要。车辆运动学模型用于描述车辆的运动特性，尤其是在低速条件下，通过控制输入来预测车辆的未来状态。本文将详细介绍几种常见的车辆运动学模型，并提供Python和C++的代码实现。

好的，我们将详细推导并更新其他模型中的侧滑角 $\beta$。以下是每个模型的详细推导和代码实现。

2. 以车辆重心为中心的单车模型

2.1 模型介绍

在自动驾驶领域，通常采用单车模型来简化实际车辆的复杂性。此模型将车辆视为具有两个转动轴的刚体，即前轮和后轮，每个轴上的左右轮合并为一个轮子来考虑。模型的关键参数包括：

• 车辆重心：点C，代表车辆的质量中心。
• 前后轮距离：$l_f$ 和 $l_r$ 分别从前轮中心到重心的距离和从后轮中心到重心的距离。
• 轴距：$L=l_f+l_r$。
• 速度：$V$，表示车辆重心的速度。
• 滑移角：$\beta$，车辆速度矢量与车辆纵向轴之间的夹角。
• 航向角：$\psi$，车身与X轴的夹角。
• 转向角：${\delta }_f$ 和 ${\delta }_r$，分别表示前轮和后轮的转向角。对于大多数车辆，${\delta }_r$ 可以设置为0。

2.2 滑移角 $\beta$ 的推导

1. 几何关系：
   • 假设车辆的重心位于点C，前轮中心位于点F，后轮中心位于点R。
   • 前轮的转向角 ${\delta }_f$ 导致前轮的行驶方向与车辆纵向轴之间有一个夹角。
   • 后轮的转向角 ${\delta }_r$ 导致后轮的行驶方向与车辆纵向轴之间有一个夹角。

2.2 航向角$\psi$推导过程：

• 如上图所示，在三角形$OCA$中，根据正弦定理，有：
  $$\frac{sin({\delta }_f-\beta )}{l_f}=\frac{sin(\frac{\pi }{2}-{\delta }_f)}{R}\text{\hspace{1em}(1)}$$
• 在三角形$OBC$中，根据正弦定理，有：
  $$\frac{sin(\beta -{\delta }_r)}{l_r}=\frac{sin(\frac{\pi }{2}+{\delta }_r)}{R}\text{\hspace{1em}(2)}$$
• 化简：
  $$\frac{sin({\delta }_f)cos(\beta )-sin(\beta )cos({\delta }_f)}{l_f}=\frac{cos({\delta }_f)}{R}\text{\hspace{1em}(3)}$$
  $$\frac{sin(\beta )cos({\delta }_r)-sin({\delta }_r)cos(\beta )}{l_r}=\frac{cos({\delta }_r)}{R}\text{\hspace{1em}(4)}$$
  等式（3）两边同乘以$\frac{l_f}{cos({\delta }_f)}$:
  $$sin({\delta }_f)cos(\beta )-sin(\beta )cos({\delta }_f)=\frac{l_{f}cos({\delta }_f)}{R}\text{\hspace{1em}(5)}$$
  同理等式（4）两边同乘以$l_r$:
  $$sin(\beta )cos({\delta }_r)-sin({\delta }_r)cos(\beta )=\frac{l_{r}cos({\delta }_r)}{R}\text{\hspace{1em}(6)}$$
  （5）（6）两式相加：
  $$cos(\beta )(sin({\delta }_f)-sin({\delta }_r))=\frac{l_r+l_f}{R}\text{\hspace{1em}(7)}$$
  根据条件假设，低速环境下，车辆行驶路径的转弯半径变化缓慢，此时我们可以假设车辆偏航角的变化率$\dot{\psi }$
  可近似等于车辆的角速度$\omega$。根据车辆角速度$\omega =\frac{V}{R}$得：
  $$\dot{\psi }=\omega =\frac{V}{R}\text{\hspace{1em}(8)}$$
  将（8）带入（7）中，消除$R$得：
  $$\dot{\psi }=\frac{Vcos(\beta )}{l_r+l_f}(tan({\delta }_f)-tan({\delta }_r))\text{\hspace{1em}(9)}$$

2.3 滑移角 $\beta$

• 滑移角 $\beta$ 定义为车辆速度矢量与车辆纵向轴之间的夹角。
• 当车辆转弯时，前轮和后轮的速度矢量会有所不同，导致车辆重心的速度矢量与车辆纵向轴之间有一个夹角。
  等式（5）两边同乘以$l_r$:
  $$l_r(tan({\delta }_f)cos(\beta )-sin(\beta )-\frac{l_f{l}_r}{R}\text{\hspace{1em}(10)}$$
  同理等式（6）两边同乘以$l_f$:
  $$l_f(sin(\beta )-tan({\delta }_r)cos(\beta ))=\frac{l_f{l}_r}{R}\text{\hspace{1em}(11)}$$
  （10）（11）两式相等：
  $$cos(\beta )(l_{r}tan({\delta }_f)+l_{f}tan({\delta }_r))=sin(\beta )(l_r+l_f)\text{\hspace{1em}(12)}$$
  合并$tan(\beta )$:
  $$tan(\beta )=\frac{l_{r}tan({\delta }_f)+l_{f}tan({\delta }_r)}{l_r+l_f}\text{\hspace{1em}(13)}$$

车辆运动学模型
$$\{\begin{array}{l}\dot{x}=V\cos (\psi +\beta )\\ \dot{y}=V\sin (\psi +\beta )\\ \dot{\psi }=\frac{Vcos(\beta )}{l_r+l_f}(tan({\delta }_f)-tan({\delta }_r))\end{array}\text{\hspace{1em}(14)}$$
其中
$$\beta =arctan(\frac{l_{r}tan({\delta }_f)+l_{f}tan({\delta }_r)}{l_r+l_f})\text{\hspace{1em}(15)}$$

2.3 Python代码实现

import math

class KinematicModel_1:
    def __init__(self, x, y, psi, v, l_r, l_f, dt):
        self.x = x
        self.y = y
        self.psi = psi
        self.v = v
        self.l_f = l_f
        self.l_r = l_r
        self.dt = dt
    
    def update_state(self, a, delta_f, delta_r=0):
        # 计算滑移角 β
        beta = math.atan2(self.l_r * math.sin(delta_f) + self.l_f * math.sin(delta_r),
                          self.l_r * math.cos(delta_f) + self.l_f * math.cos(delta_r))
        
        # 更新状态
        self.x += self.v * math.cos(self.psi + beta) * self.dt
        self.y += self.v * math.sin(self.psi + beta) * self.dt
        self.psi += (self.v / (self.l_f + self.l_r)) * (math.tan(delta_f) - math.tan(delta_r)) * math.cos(beta) * self.dt
        self.v += a * self.dt
    
    def get_state(self):
        return self.x, self.y, self.psi, self.v

2.4 C++代码实现

#include <cmath>
#include <iostream>

class KinematicModel_1 {
public:
    KinematicModel_1(double x, double y, double psi, double v, double l_r, double l_f, double dt) :
        x(x), y(y), psi(psi), v(v), l_f(l_f), l_r(l_r), dt(dt) {}

    void update_state(double a, double delta_f, double delta_r = 0) {
        // 计算滑移角 β
        double beta = atan2(l_r * sin(delta_f) + l_f * sin(delta_r),
                            l_r  + l_f );
        
        // 更新状态
        x += v * cos(psi + beta) * dt;
        y += v * sin(psi + beta) * dt;
        psi += (v / (l_f + l_r)) * (tan(delta_f) - tan(delta_r)) * cos(beta) * dt;
        v += a * dt;
    }

    void get_state() const {
        std::cout << "x: " << x << ", y: " << y << ", psi: " << psi << ", v: " << v << std::endl;
    }

private:
    double x, y, psi, v, l_f, l_r, dt;
};

3. 前轮驱动的单车模型

3.1 模型介绍

当仅考虑前轮转向时，模型可以简化为：

车辆运动学模型
$$\{\begin{array}{l}\dot{x}=V\cos (\psi +\beta )\\ \dot{y}=V\sin (\psi +\beta )\\ \dot{\psi }=\frac{V\sin \beta }{l_r}\end{array}\text{\hspace{1em}(16)}$$

其中${\delta }_r=0$，滑移角 $\beta$ 可以表示为：
$$\beta =\arctan \left(\frac{l_r}{l_f+l_r}\tan ({\delta }_f)\right)\text{\hspace{1em}(17)}$$

3.3 Python代码实现

class KinematicModel_2:
    def __init__(self, x, y, psi, v, l_r, l_f, dt):
        self.x = x
        self.y = y
        self.psi = psi
        self.v = v
        self.l_f = l_f
        self.l_r = l_r
        self.dt = dt
    
    def update_state(self, a, delta_f):
        # 计算滑移角 β
        beta = math.atan((self.l_r / (self.l_f + self.l_r)) * math.tan(delta_f))
        
        # 更新状态
        self.x += self.v * math.cos(self.psi + beta) * self.dt
        self.y += self.v * math.sin(self.psi + beta) * self.dt
        self.psi += (self.v * math.sin(beta) / self.l_r) * self.dt
        self.v += a * self.dt
    
    def get_state(self):
        return self.x, self.y, self.psi, self.v

3.4 C++代码实现

class KinematicModel_2 {
public:
    KinematicModel_2(double x, double y, double psi, double v, double l_r, double l_f, double dt) :
        x(x), y(y), psi(psi), v(v), l_f(l_f), l_r(l_r), dt(dt) {}

    void update_state(double a, double delta_f) {
        // 计算滑移角 β
        double beta = atan((l_r / (l_f + l_r)) * tan(delta_f));
        
        // 更新状态
        x += v * cos(psi + beta) * dt;
        y += v * sin(psi + beta) * dt;
        psi += (v * sin(beta) / l_r) * dt;
        v += a * dt;
    }

    void get_state() const {
        std::cout << "x: " << x << ", y: " << y << ", psi: " << psi << ", v: " << v << std::endl;
    }

private:
    double x, y, psi, v, l_f, l_r, dt;
};

4. 以后轴中心为车辆中心的单车模型

4.1 模型介绍

当以车辆后轴中心为参考点时，模型可以进一步简化。假设后轮没有转向角（${\delta }_r=0$），模型可以表示为：

$$\{\begin{array}{l}\dot{x}=V\cos (\psi )\\ \dot{y}=V\sin (\psi )\\ \dot{\psi }=\frac{V}{L}\tan {\delta }_f\end{array}\text{\hspace{1em}(18)}$$

其中，$L$ 是轴距，${\delta }_f$ 是前轮转向角。

• 在这种模型中，滑移角 $\beta$ 可以近似为0，因为重心位于后轴中心，且后轮没有转向角。
• 因此，滑移角 $\beta$ 可以表示为：
  $$\beta \approx 0$$

4.3 Python代码实现

class KinematicModel_3:
    def __init__(self, x, y, psi, v, L, dt):
        self.x = x
        self.y = y
        self.psi = psi
        self.v = v
        self.L = L
        self.dt = dt
    
    def update_state(self, a, delta_f):
        # 更新状态
        self.x += self.v * math.cos(self.psi) * self.dt
        self.y += self.v * math.sin(self.psi) * self.dt
        self.psi += (self.v / self.L) * math.tan(delta_f) * self.dt
        self.v += a * self.dt
    
    def get_state(self):
        return self.x, self.y, self.psi, self.v

4.4 C++代码实现

class KinematicModel_3 {
public:
    KinematicModel_3(double x, double y, double psi, double v, double L, double dt) :
        x(x), y(y), psi(psi), v(v), L(L), dt(dt) {}

    void update_state(double a, double delta_f) {
        // 更新状态
        x += v * cos(psi) * dt;
        y += v * sin(psi) * dt;
        psi += (v / L) * tan(delta_f) * dt;
        v += a * dt;
    }

    void get_state() const {
        std::cout << "x: " << x << ", y: " << y << ", psi: " << psi << ", v: " << v << std::endl;
    }

private:
    double x, y, psi, v, L, dt;
};

5. 阿克曼转向几何

5.1 模型介绍

阿克曼转向几何（Ackerman Turning Geometry）是一种为了解决交通工具转弯时，内外转向轮路径指向的圆心不同的几何学。在单车模型中，将转向时左、右前轮偏角假设为同一角度 ${\delta }_f$，虽然通常两个角度大致相等，但实际并不是，通常情况下，内侧轮胎转角更大。

• 外轮转角：${\delta }_o=\frac{L}{R+\frac{l_w}{2}}$
• 内轮转角：${\delta }_i=\frac{L}{R-\frac{l_w}{2}}$

其中，$l_w$ 为轮距，$R$ 为轨迹半径。

5.2 滑移角 $\beta$ 的推导

1. 几何关系：

   • 车辆转弯时，内外轮的轨迹半径不同。
   • 外轮的轨迹半径为 $R+\frac{l_w}{2}$。
   • 内轮的轨迹半径为 $R-\frac{l_w}{2}$。

2. 转向角计算：

   • 外轮转角 ${\delta }_o$ 可以表示为：
     $${\delta }_o=\frac{L}{R+\frac{l_w}{2}}\text{\hspace{1em}(19)}$$
   • 内轮转角 ${\delta }_i$ 可以表示为：
     $${\delta }_i=\frac{L}{R-\frac{l_w}{2}}\text{\hspace{1em}(20)}$$

3. 滑移角 $\beta$ 的计算：

   • 在阿克曼转向几何中，滑移角 $\beta$ 主要取决于车辆的几何参数和转向角。
   • 通常情况下，滑移角 $\beta$ 可以近似为0，因为阿克曼转向几何设计使得内外轮的转向角能够很好地匹配车辆的转弯半径。

5.3 Python代码实现

class AckermannSteering:
    def __init__(self, L, l_w, R):
        self.L = L
        self.l_w = l_w
        self.R = R
    
    def calculate_steering_angles(self, delta_f):
        delta_o = self.L / (self.R + self.l_w / 2)
        delta_i = self.L / (self.R - self.l_w / 2)
        return delta_o, delta_i

5.4 C++代码实现

#include <cmath>
#include <iostream>

class AckermannSteering {
public:
    AckermannSteering(double L, double l_w, double R) : L(L), l_w(l_w), R(R) {}

    std::pair<double, double> calculate_steering_angles(double delta_f) {
        double delta_o = L / (R + l_w / 2);
        double delta_i = L / (R - l_w / 2);
        return {delta_o, delta_i};
    }

private:
    double L, l_w, R;
};

6. 总结

本文详细介绍了车辆运动学模型的基本概念，并提供了Python和C++的实现代码。通过这些模型，我们可以更好地理解车辆在不同控制输入下的运动行为，这对于开发自动驾驶系统的控制策略至关重要。希望本文能够为自动驾驶领域的研究者和开发者提供有价值的参考。

参考资料

• 【自动驾驶】车辆运动学模型 - CSDN博客

---

以上就是《【自动驾驶】车辆运动学模型》的全部内容，希望能够帮助到你。如果你有任何疑问或者建议，欢迎留言交流！