PID简介

PID（Proportion-Integral-Differential），即比例-积分-微分，是一种常用的闭环控制器。

控制系统结构图：

传递函数：
$$\begin{gathered} G(s)=K_p\left(1+\frac{1}{T_{i}s}+T_{d}s\right) \\ 或 \\ G(s)=K_p+\frac{K_i}{s}+K_{d}s \end{gathered}$$

模拟量公式：
$$\begin{gathered} u(t)=K_p\left[e(t)+\frac{1}{T_i}{\int }_0^{t}e(\tau )d\tau +T_d\frac{de(t)}{dt}\right] \\ 或 \\ u(t)=K_{p}e(t)+K_i{\int }_0^{t}e(\tau )d\tau +K_d\frac{de(t)}{dt} \end{gathered}$$

PID在计算机程序（数字量）中，有传统（位置式）PID和增量式PID两种实现形式。

传统（位置式）PID

数字量公式：
$$u(n)=K_{p}e(n)+K_i\sum _{i=0}^{n}e(i)+K_d[e(n)-e(n-1)]$$

示例代码：

typedef struct {  
    float kp;                // 比例系数
    float ki;                // 积分系数
    float kd;                // 微分系数
    float err;               // 误差
    float last_err;          // 上次误差
    float proportion;        // 比例项
    float integral;          // 积分项
    float differential;      // 微分项
    float integral_limit;    // 积分限幅
} PID;
PID pid = {
    .kp = 1,
    .ki = 1,
    .kd = 1,
    .integral_limit = 1023,
};

void pid_controler(float target, float feedback, float *output)
{
    // 更新误差
    pid.last_err = pid.err;
    pid.err = target - feedback;

    // 计算比例项
    pid.proportion = pid.kp * pid.err;

    // 计算积分项、积分限幅
    pid.integral += pid.ki * pid.err;
    if(pid.integral > pid.integral_limit)   pid.integral = pid.integral_limit;
    if(pid.integral < -pid.integral_limit)  pid.integral = -pid.integral_limit;

    // 计算微分项
    pid.differential = pid.kd * (pid.err - pid.last_err);

    // 计算输出量
    *output = pid.proportion + pid.integral + pid.differential;
}

增量式PID

数字量公式：
$$\begin{gathered} \Delta u(n)=K_p[e(n)-e(n-1)]+K_{i}e(n)+K_d[e(n)-2e(n-1)+e(n-2)] \\ u(n)=u(n-1)+\Delta u(n) \end{gathered}$$

从公式上可以看出，增量式PID和传统（位置式）PID可以互相推导，也就意味着增量式PID和传统（位置式）PID只是数据的计算顺序不同，数据的计算结果和控制效果是相同的。增量式PID的优点就是不需要考虑积分饱和问题，也不再需要积分限幅。

示例代码：

typedef struct {  
    float kp;                // 比例系数
    float ki;                // 积分系数
    float kd;                // 微分系数
    float err;               // 误差
    float last_err;          // 上次误差
    float last_last_err;     // 上上次误差
    float proportion;        // 比例项
    float integral;          // 积分项
    float differential;      // 微分项
} PID;
PID pid = {
    .kp = 1,
    .ki = 1,
    .kd = 1,
};

void pid_controler(float target, float feedback, float *output)
{
    // 更新误差
    pid.last_last_err = pid.last_err;
    pid.last_err = pid.err;
    pid.err = target - feedback;

    // 计算比例项
    pid.proportion = pid.kp * (pid.err - pid.last_err);

    // 计算积分项
    pid.integral = pid.ki * pid.err;

    // 计算微分项
    pid.differential = pid.kd * (pid.err - 2 * pid.last_err + pid.last_last_err);

    // 计算输出量
    *output += pid.proportion + pid.integral + pid.differential;
}

PID的变种

前馈PID

前馈PID能够让控制系统更快速的达到稳态，减少积分环节消耗的时间。

控制系统结构图：

数字量公式：
$$u(n)=r(n)+K_{p}e(n)+K_i\sum _{i=0}^{n}e(i)+K_d[e(n)-e(n-1)]$$

积分分离PID

积分分离PID的核心思想是，在系统误差较大时暂停积分作用，当误差减小到一定程度时再重新启用积分作用。这样做的目的是，避免因为在误差较大时积分项累积过多而导致的系统超调。

数字量公式：
$$\begin{gathered} u(n)=K_{p}e(n)+K_i\alpha \sum _{i=0}^{n}e(i)+K_d[e(n)-e(n-1)] \\ \alpha =\{\begin{array}{ll}1& |e(n)|\le A\\ 0& |e(n)|>A\end{array} \end{gathered}$$

变速积分PID

变速积分PID的核心思想是，在系统误差较大时减小积分累积的速度，而在误差较小时增大积分累积的速度。这样做的目的是，避免因为在误差较大时积分项累积过多而导致的系统超调。变速积分PID可以看成是积分分离PID的升级版。

数字量公式：
$$\begin{gathered} u(n)=K_{p}e(n)+K_i\sum _{i=0}^{n}f[e(i)]e(i)+K_d[e(n)-e(n-1)] \\ f[e(i)]=\{\begin{array}{ll}1& |e(i)|\le B\\ \frac{A-|e(i)|+B}{A}& B<|e(i)|\le A+B\\ 0& |e(i)|>A+B\end{array} \end{gathered}$$

不完全微分PID

不完全微分PID通过引入一个低通滤波器来平滑微分项的计算结果，从而减少对高频噪声的敏感性。这样做的目的是，防止微分项因为对高频噪声敏感而产生过度调节的问题。

数字量公式：
$$\begin{gathered} u(n)=K_{p}e(n)+K_i\sum _{i=0}^{n}e(i)+u_d(n) \\ {u}_d(n)=(1-\alpha )u_d(n-1)+\alpha K_d[e(n)-e(n-1)] \end{gathered}$$

微分先行PID

在传统PID控制器中，微分项是基于误差（即目标量与反馈量之差）的变化率来计算的，而在微分先行PID控制器中，微分项是基于反馈量的变化率来计算的。

数字量公式：
$$u(n)=K_{p}e(n)+K_i\sum _{i=0}^{n}e(i)-K_d[y(n)-y(n-1)]$$