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 开环控制

首先来看开环控制系统,如下图所示,隆哥蒙着眼,需要走到虚线旗帜所表示的目标位置,由于缺少反馈(眼睛可以感知当前距离和位置,由于眼睛被蒙上没有反馈,所以这也是一个开环系统),最终隆哥会较大概率偏离预期的目标,可能会运行到途中实线旗帜所表示的位置。

PID算法

开环系统的整体结构如下所示;

PID算法
这里做一个不是很恰当的比喻;

  • Input:告诉隆哥目标距离的直线位置(10米);
  • Controller:隆哥大脑中计算出到达目标所需要走多少步
  • Process:双腿作为执行机构,输出了相应的步数,但是最终仍然偏离了目标;

看来没有反馈的存在,很难准确到达目标位置。

3 闭环控制

所以为了准确到达目标位置,这里就需要引入反馈,具体如下图所示;

PID算法
在这里继续举个不怎么恰当的比喻;隆哥重获光明之后,基本可以看到目标位置了;

  • 第一步Input:告诉隆哥目标距离的直线位置(10米);
  • 第二步Controller:隆哥大脑中计算出到达目标所需要走多少步
  • 第三步Process:双腿作为执行机构,输出了相应的步数,但是最终仍然偏离了目标;
  • 第四步Feedback通过视觉获取到目前已经前进的距离,(比如前进了2米,那么还有8米的偏差);
  • 第五步err:根据偏差重新计算所需要的步数,然后重复上述四个步骤,最终隆哥达到最终的目标位置。

4 PID

4.1 系统架构

虽然在反馈系统下,隆哥最终到达目标位置,但是现在又来了新的任务,就是又地到达目标位置。所以这里隆哥开始采用PID Controller,只要适当调整PID的参数,就可以到达目标位置,具体如下图所示;

PID算法

隆哥为了最短时间内到达目标位置,进行了不断的尝试,分别出现了以下几种情况;

  • 跑得太快,最终导致冲过了目标位置还得往回跑
  • 跑得太慢,最终导致到达目标位置所用时间太长

经过不断的尝试,终于找到了最佳的方式,其过程大概如下图所示;
PID算法
这里依然举一个不是很恰当的比喻;

  • 第一步:得到与目标位置的距离偏差(比如最开始是10米,后面会逐渐变小);
  • 第二步:根据误差,预估需要多少速度,如何估算呢,看下面几步;

P比例则是给定一个速度的大致范围,满足下面这个公式;
K p ∗ e ( t ) K_p*e(t) Kp​∗e(t)
因此比例作用相当于某一时刻的偏差err)与比例系数 K p K_p Kp​的乘积,具体如下所示;

PID算法

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


I积分则是误差在一定时间内的和,满足以下公式;
K i ∫ 0 t e ( τ ) d τ K_i\int_{_0}^te(\tau)d\tau Ki​∫0​t​e(τ)dτ

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


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


综上, 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控制器的系统框图如下所示;

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

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

PIDImpl::~PIDImpl()
{
}

#endif
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

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;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

编译并测试;

g++ -c pid.cpp -o pid.o
# To compile example code:
g++ pid_example.cpp pid.o -o pid_example
  • 1
  • 2
  • 3

6 总结

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

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

  PID算法 小麦大叔 PID算法 CSDN签约作者 有梦想的咸鱼 更多干货,欢迎关注公众号:[小麦大叔]</br>一个野生攻城狮的原创分享,</br>涉及内容包括但不限于嵌入式、物联网、单片机、编程技术、PCB、硬件设计等等。</br>来交个朋友?
  • PID算法 点赞 38
  • PID算法 评论 19
  • PID算法 分享
  • PID算法 收藏 229
  • PID算法 打赏
  • PID算法 举报
  • 关注
  • 一键三连

  腾讯位置服务开发应用征文大赛开启报名!大疆无人机等你来挑战! 01-08 如今与地图相关的位置服务已经成为开发者工具箱里的“标配”,不管是小程序开发、获取定位信息还是展示地图上的某个地点。现在分享你和腾讯位置服务有关的故事,可以是使用教程、案例分享、知识总结…大疆无人机、王者荣耀机器人多重好礼陪你跨年! 单片机之C语言实现简单的PID算法 从零开始学单片机的博客 PID算法 673 说到PID算法,想必大部人并不陌生,PID算法在很多方面都有重要应用,比如电机的速度控制,恒温槽的温度控制,四轴飞行器的平衡控制等等,作为闭环控制系统中的一种重要算法,其优点和可实现性都成为人们的首选。下面简单来讲解一下PID算法: 首先PID算法是有比例,积分,微分三部分组成,先说下比例部分,所谓比例部分,就是呈线性关系,举个例子,一个电热丝加热水,开始的时候温度很低,离50℃很大,这时应该加大...

 

PID算法
PID算法
  • PID算法 码哥PID算法IOT技术栈:那些曲线图都是咋画的4月前回复PID算法PID算法1
    • PID算法 爱码士PID算法小麦大叔PID算法回复:draw.io1月前回复PID算法PID算法
  • PID算法 爱码士PID算法ITKaven:好文!希望博主以后多多分享哈!19天前回复PID算法PID算法
  • PID算法 爱码士PID算法水巷石子:深有感触1月前回复PID算法
上一篇:关于C++的各个类型字节(转)


下一篇:巨好听的歌QAQ: september調子はどうだい(女声版)(翻自 うじたまい)