zoukankan html css js c++ java

PID算法

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

分类专栏： Embeded System 文章标签： pid 自动控制控制器算法

版权

网上关于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) Kp∗e(t) 因此比例作用相当于某一时刻的偏差（err）与比例系数 K p K_p Kp的乘积，具体如下所示；$

比例作用

绿色线为上述例子中从初始位置到目标位置的距离变化；
红色线为上述例子中从初始位置到目标位置的偏差变化，两者为互补的关系；

I积分则是误差在一定时间内的和，满足以下公式；
$K_iint_{_0}^te( au)d au Ki∫0te(τ)dτ$

如下图所示；在这里插入图片描述
红色曲线阴影部分面积即为积分作用的结果，其不断累积的误差，最终乘以积分系数 $K_i Ki就得到了积分部分的输出；$

D微分则是误差变化曲线某处的导数，或者说是某一点的斜率，因此这里需要引入微分；
$K_d cfrac{de(t)}{dt} Kddtde(t) 从图中可知，当偏差变化过快，微分环节会输出较大的负数，作为抑制输出继续上升，从而抑制过冲。$

综上， $K_p，K_i，K_d Kp，Ki，Kd，分别增加其中一项参数会对系统造成的影响总结如下表所示；$

参数	上升时间	超调量	响应时间	稳态误差	稳定性
$K_p Kp$	减少	增加	小变化	减少	降级
$K_i Ki$	减少	增加	增加	消除	降级
$K_d Kd$	微小的变化	减少	减少	理论上没有影响	$K_d Kd小，稳定性会提升$

4.2 理论基础

上面扯了这么多，无非是为了初步理解PID在负反馈系统中的调节作用，下面开始推导一下算法实现的具体过程；PID控制器的系统框图如下所示；

图片来自Wiki

因此不难得出输入

$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 Kp是比例增益； K i K_i Ki是积分增益； K d K_d Kd是微分增益；$

4.3 离散化

在数字系统中进行PID算法控制，需要对上述算法进行离散化；假设系统采样时间为

$(e_0,e_1,e_2,cdots,e_{n-2},,e_{n-1},e_{n}) (e0,e1,e2,⋯,en−2,,en−1,en)$

将输出 $(u_0,u_1,u_2,cdots,u_{n-2},,u_{n-1},u_{n}) (u0,u1,u2,⋯,un−2,,un−1,un)$

比例项： $K_pe(t)xrightarrow{离散化}K_pe_k Kpe(t)离散化$

积分项： $K_iint_0^{t_k}e( au)d auxrightarrow{离散化}K_idisplaystylesum_{i=1}^ke(i)Delta t Ki∫0tke(τ)dτ离散化$
微分项： $K_dcfrac{de(t_k)}{dt}xrightarrow{离散化}K_dcfrac{e(k) -e(k-1)}{Delta t} Kddtde(tk)离散化$

所以最终可以得到式①，也就是网上所说的位置式PID：
$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_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

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
", 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签约作者有梦想的咸鱼

更多干货，欢迎关注公众号：[小麦大叔]</br>一个野生攻城狮的原创分享，</br>涉及内容包括但不限于嵌入式、物联网、单片机、编程技术、PCB、硬件设计等等。</br>来交个朋友？

点赞 38
评论 19
分享
收藏 229
打赏
举报
关注
一键三连

码哥IOT技术栈:那些曲线图都是咋画的4月前回复

1
- 爱码士小麦大叔回复:draw.io1月前回复

爱码士ITKaven:好文！希望博主以后多多分享哈！19天前回复

爱码士水巷石子:深有感触1月前回复

查看全文

相关阅读:
时间复杂度，空间复杂度
 冒泡排序，选择排序，插入排序
 redis集群
 redis进阶
 redis常识--基础
 mysql基本操作
 TCP/IP 的介绍
 OSI七层网络模型&TCP＆UDP&三握四挥
 DNS
局域网&广域网

原文地址：https://www.cnblogs.com/linyinmobayu/p/14261994.html