您的位置：首页 > 编程语言 > C语言/C++

简易PID算法的快速扫盲（超详细+过程推导+C语言程序）

2020-08-02 13:09 127 查看

网上关于

PID
算法的文章很多，但是感觉有必要自己再进行一次总结，抽丝剥茧地重新认识了一下
PID
；

文章目录

  • 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 系统架构< 20000 /h3>

    虽然在反馈系统下，隆哥最终到达目标位置，但是现在又来了新的任务，就是又快又准地到达目标位置。所以这里隆哥开始采用

    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_i\int_{_0}^te(\tau)d\tau Ki​∫0​t​e(τ)dτ

    如下图所示；
    红色曲线阴影部分面积即为积分作用的结果，其不断累积的误差，最终乘以积分系数 K i K_i Ki​就得到了积分部分的输出；

    D
    微分则是误差变化曲线某处的导数，或者说是某一点的斜率，因此这里需要引入微分；
    K d d e ( t ) d t K_d \cfrac{de(t)}{dt} Kd​dtde(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_i\int_0^te(\tau)d\tau+K_d\cfrac{de(t)}{dt} u(t)=Kp​e(t)+Ki​∫0t​e(τ)dτ+Kd​dtde(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 Kp​e(t)离散化 ​Kp​ek​
    • 积分项： K i ∫ 0 t k e ( τ ) d τ → 离 散 化 K i ∑ i = 1 k e ( i ) Δ t K_i\int_0^{t_k}e(\tau)d\tau\xrightarrow{离散化}K_i\displaystyle\sum_{i=1}^ke(i)\Delta t Ki​∫0tk​​e(τ)dτ离散化 ​Ki​i=1∑k​e(i)Δt
    • 微分项： K d d e ( t k ) d t → 离 散 化 K d e ( k ) − e ( k − 1 ) Δ t K_d\cfrac{de(t_k)}{dt}\xrightarrow{离散化}K_d\cfrac{e(k) -e(k-1)}{\Delta t} Kd​dtde(tk​)​离散化 ​Kd​Δte(k)−e(k−1)​

    所以最终可以得到式①，也就是网上所说的位置式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_i\displaystyle\sum_{i=1}^ke(i)\Delta t+K_d\cfrac{e(k) -e(k-1)}{\Delta t} u(k)=Kp​ek​+Ki​i=1∑k​e(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))+Ki​e(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

    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;
}

PIDImpl::~PIDImpl()
{
}

#endif

    pid.h

    #ifndef _PID_H_
#define _PID_H_

class PIDImpl;
class PID
{
public:
// Kp -  proportional gain
// Ki -  Integral gain
// Kd -  derivative gain
// dt -  loop interval time
// max - maximum value of manipulated variable
// min - minimum value of manipulated variable
PID( double dt, double max, double min, double Kp, double Kd, double Ki );

// Returns the manipulated variable given a setpoint and current process value
double calculate( double setpoint, double pv );
~PID();

private:
PIDImpl *pimpl;
};

#endif

    pid_example.cpp

    #include "pid.h"
#include <stdio.h>

int main() {

PID pid = PID(0.1, 100, -100, 0.1, 0.01, 0.5);

double val = 20;
for (int i = 0; i < 100; i++) {
double inc = pid.calculate(0, val);
printf("val:% 7.3f inc:% 7.3f\n", val, inc);
val += inc;
}

return 0;
}

    编译并测试；

    g++ -c pid.cpp -o pid.o
# To compile example code:
g++ pid_example.cpp pid.o -o pid_example

    6 总结

    本文总结了

    PID
    控制器算法在闭环系统中根据偏差变化的具体调节作用，每个环节可能对系统输出造成什么样的变化，给出了位置式和增量式离散
    PID
    算法的推导过程，并给出了位置式算法的
    C++
    程序实现。

    由于作者能力和水平有限，文中难免存在错误和纰漏，请不吝赐教。

    小麦大叔 CSDN认证博客专家 CSDN签约作者 有梦想的咸鱼 更多干货，欢迎关注公众号：[小麦大叔]
    一个野生攻城狮的原创分享，
    涉及内容包括但不限于嵌入式、物联网、单片机、编程技术、PCB、硬件设计等等。
    来交个朋友？
    内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
    标签： 
    相关文章推荐
    新的分享
    章节导航