简易PID算法的快速扫盲（超详细+过程推导+C语言程序）
网上关于
PID算法的文章很多，但是感觉有必要自己再进行一次总结，抽丝剥茧地重新认识了一下PID；
文章目录
-
- 1 前言
- 2 开环控制
- 3 闭环控制
- 4 PID
-
- 4.1 系统架构
- 4.2 理论基础
- 4.3 离散化
- 4.4 伪算法
- 5 C++实现
- 6 总结
相关阅读
离散增量式PID算法快速扫盲（过程推导+C语言程序）
PID算法优化之积分器抗饱和处理
1 前言
控制系统通常根据有没有反馈会分为开环系统和闭环系统，在闭环系统的控制中，PID算法非常强大，其三个部分分别为；
P：比例环节；I：积分环节；D：微分环节；
PID算法可以自动对控制系统进行准确且迅速的校正，因此被广泛地应用于工业控制系统。
2 开环控制
首先来看开环控制系统，如下图所示，隆哥蒙着眼，需要走到虚线旗帜所表示的目标位置，由于缺少反馈（眼睛可以感知当前距离和位置，由于眼睛被蒙上没有反馈，所以这也是一个开环系统），最终隆哥会较大概率偏离预期的目标，可能会运行到途中实线旗帜所表示的位置。
开环系统的整体结构如下所示；
这里做一个不是很恰当的比喻；
Input：告诉隆哥目标距离的直线位置（10米）；Controller：隆哥大脑中计算出到达目标所需要走多少步；Process：双腿作为执行机构，输出了相应的步数，但是最终仍然偏离了目标；
看来没有反馈的存在，很难准确到达目标位置。
3 闭环控制
所以为了准确到达目标位置，这里就需要引入反馈，具体如下图所示；
在这里继续举个不怎么恰当的比喻；隆哥重获光明之后，基本可以看到目标位置了；
- 第一步
Input：告诉隆哥目标距离的直线位置（10米）； - 第二步
Controller：隆哥大脑中计算出到达目标所需要走多少步； - 第三步
Process：双腿作为执行机构，输出了相应的步数，但是最终仍然偏离了目标； - 第四步
Feedback：通过视觉获取到目前已经前进的距离，（比如前进了2米，那么还有8米的偏差）； - 第五步
err：根据偏差重新计算所需要的步数，然后重复上述四个步骤，最终隆哥达到最终的目标位置。
4 PID
4.1 系统架构
虽然在反馈系统下，隆哥最终到达目标位置，但是现在又来了新的任务，就是又快又准地到达目标位置。所以这里隆哥开始采用PID Controller，只要适当调整P，I和D的参数，就可以到达目标位置，具体如下图所示；
隆哥为了最短时间内到达目标位置，进行了不断的尝试，分别出现了以下几种情况；
- 跑得太快，最终导致冲过了目标位置还得往回跑；
- 跑得太慢，最终导致到达目标位置所用时间太长；
经过不断的尝试，终于找到了最佳的方式，其过程大概如下图所示；
这里依然举一个不是很恰当的比喻；
- 第一步：得到与目标位置的距离偏差（比如最开始是10米，后面会逐渐变小）；
- 第二步：根据误差，预估需要多少速度，如何估算呢，看下面几步；
P比例则是给定一个速度的大致范围，满足下面这个公式；
K
p
∗
e
(
t
)
K_p*e(t)
Kp∗e(t)
因此比例作用相当于某一时刻的偏差（err）与比例系数
K
p
K_p
Kp的乘积，具体如下所示；
绿色线为上述例子中从初始位置到目标位置的距离变化；
红色线为上述例子中从初始位置到目标位置的偏差变化，两者为互补的关系；
I积分则是误差在一定时间内的和，满足以下公式；
K
i
∫
0
t
e
(
τ
)
d
τ
K_iint_{_0}^te( au)d au
Ki∫0te(τ)dτ
如下图所示；
红色曲线阴影部分面积即为积分作用的结果，其不断累积的误差，最终乘以积分系数
K
i
K_i
Ki就得到了积分部分的输出；
D微分则是误差变化曲线某处的导数，或者说是某一点的斜率，因此这里需要引入微分；
K
d
d
e
(
t
)
d
t
K_d cfrac{de(t)}{dt}
Kddtde(t)
从图中可知，当偏差变化过快，微分环节会输出较大的负数，作为抑制输出继续上升，从而抑制过冲。
综上， K p ， K i ， K d K_p，K_i，K_d Kp，Ki，Kd，分别增加其中一项参数会对系统造成的影响总结如下表所示；
| 参数 | 上升时间 | 超调量 | 响应时间 | 稳态误差 | 稳定性 |
|---|---|---|---|---|---|
| K p K_p Kp | 减少 | 增加 | 小变化 | 减少 | 降级 |
| K i K_i Ki | 减少 | 增加 | 增加 | 消除 | 降级 |
| K d K_d Kd | 微小的变化 | 减少 | 减少 | 理论上没有影响 | K d K_d Kd小，稳定性会提升 |
4.2 理论基础
上面扯了这么多，无非是为了初步理解PID在负反馈系统中的调节作用，下面开始推导一下算法实现的具体过程；PID控制器的系统框图如下所示；
因此不难得出输入 e ( t ) e(t) e(t)和输出 u ( t ) u(t) u(t)的关系；
u ( t ) = K p e ( t ) + K i ∫ 0 t e ( τ ) d τ + K d d e ( t ) d t u(t) = K_pe(t)+K_iint_0^te( au)d au+K_dcfrac{de(t)}{dt} u(t)=Kpe(t)+Ki∫0te(τ)dτ+Kddtde(t)
K p K_p Kp是比例增益；
K i K_i Ki是积分增益；
K d K_d Kd是微分增益；
4.3 离散化
在数字系统中进行PID算法控制，需要对上述算法进行离散化；假设系统采样时间为
Δ
t
Delta t
Δt
则将输入
e
(
t
)
e(t)
e(t)序列化得到；
( e 0 , e 1 , e 2 , ⋯ , e n − 2 , , e n − 1 , e n ) (e_0,e_1,e_2,cdots,e_{n-2},,e_{n-1},e_{n}) (e0,e1,e2,⋯,en−2,,en−1,en)
将输出
u
(
t
)
u(t)
u(t)序列化得到；
(
u
0
,
u
1
,
u
2
,
⋯
,
u
n
−
2
,
,
u
n
−
1
,
u
n
)
(u_0,u_1,u_2,cdots,u_{n-2},,u_{n-1},u_{n})
(u0,u1,u2,⋯,un−2,,un−1,un)
- 比例项： K p e ( t ) → 离 散 化 K p e k K_pe(t)xrightarrow{离散化}K_pe_k Kpe(t)离散化
- 积分项： K i ∫ 0 t k e ( τ ) d τ → 离 散 化 K i ∑ i = 1 k e ( i ) Δ t K_iint_0^{t_k}e( au)d auxrightarrow{离散化}K_idisplaystylesum_{i=1}^ke(i)Delta t Ki∫0tke(τ)dτ离散化
- 微分项： K d d e ( t k ) d t → 离 散 化 K d e ( k ) − e ( k − 1 ) Δ t K_dcfrac{de(t_k)}{dt}xrightarrow{离散化}K_dcfrac{e(k) -e(k-1)}{Delta t} Kddtde(tk)离散化
所以最终可以得到式①，也就是网上所说的位置式PID：
u
(
k
)
=
K
p
e
k
+
K
i
∑
i
=
1
k
e
(
i
)
Δ
t
+
K
d
e
(
k
)
−
e
(
k
−
1
)
Δ
t
color{#0000FF} u(k)=K_pe_k+K_idisplaystylesum_{i=1}^ke(i)Delta t+K_dcfrac{e(k) -e(k-1)}{Delta t}
u(k)=Kpek+Kii=1∑ke(i)Δt+KdΔte(k)−e(k−1)
将式①再做一下简化；
Δ
u
(
k
)
=
u
(
k
)
−
u
(
k
−
1
)
Delta u(k) = u(k) - u(k-1)
Δu(k)=u(k)−u(k−1)
最终得到增量式PID的离散公式如下：
Δ u ( k ) = K p ( e ( k ) − e ( k − 1 ) ) + K i e ( k ) + K d ( e ( k ) − 2 e ( k − 1 ) + e ( k − 2 ) ) Delta u(k)=K_p(e(k)-e(k-1))+K_ie(k)+K_d Big( e(k)-2e(k-1)+e(k-2) Big) Δu(k)=Kp(e(k)−e(k−1))+Kie(k)+Kd(e(k)−2e(k−1)+e(k−2))
4.4 伪算法
这里简单总结一下增量式PID实现的伪算法；
previous_error := 0 //上一次偏差
integral := 0 //积分和
//循环
//采样周期为dt
loop:
//setpoint 设定值
//measured_value 反馈值
error := setpoint − measured_value //计算得到偏差
integral := integral + error × dt //计算得到积分累加和
derivative := (error − previous_error) / dt //计算得到微分
output := Kp × error + Ki × integral + Kd × derivative //计算得到PID输出
previous_error := error //保存当前偏差为下一次采样时所需要的历史偏差
wait(dt) //等待下一次采用
goto loop
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
5 C++实现
这里是增量式PID算法的C语言实现；
pid.cpp
#ifndef _PID_SOURCE_
#define _PID_SOURCE_
#include <iostream>
#include <cmath>
#include "pid.h"
using namespace std;
class PIDImpl
{
public:
PIDImpl( double dt, double max, double min, double Kp, double Kd, double Ki );
~PIDImpl();
double calculate( double setpoint, double pv );
private:
double _dt;
double _max;
double _min;
double _Kp;
double _Kd;
double _Ki;
double _pre_error;
double _integral;
};
PID::PID( double dt, double max, double min, double Kp, double Kd, double Ki )
{
pimpl = new PIDImpl(dt,max,min,Kp,Kd,Ki);
}
double PID::calculate( double setpoint, double pv )
{
return pimpl->calculate(setpoint,pv);
}
PID::~PID()
{
delete pimpl;
}
/**
* Implementation
*/
PIDImpl::PIDImpl( double dt, double max, double min, double Kp, double Kd, double Ki ) :
_dt(dt),
_max(max),
_min(min),
_Kp(Kp),
_Kd(Kd),
_Ki(Ki),
_pre_error(0),
_integral(0)
{
}
double PIDImpl::calculate( double setpoint, double pv )
{
// Calculate error
double error = setpoint - pv;
// Proportional term
double Pout = _Kp * error;
// Integral term
_integral += error * _dt;
double Iout = _Ki * _integral;
// Derivative term
double derivative = (error - _pre_error) / _dt;
double Dout = _Kd * derivative;
// Calculate total output
double output = Pout + Iout + Dout;
// Restrict to max/min
if( output > _max )
output = _max;
else if( output < _min )
output = _min;
// Save error to previous error
_pre_error = error;
return output