文章来源于小麦大叔 ，作者菜刀和小麦

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

  • 1 前言
  • 2 开环控制
  • 3 闭环控制
  • 4 PID

    • 4.1 系统架构
    • 4.2 理论基础
    • 4.3 离散化
    • 4.4 伪算法
  • 5 C++实现
  • 6 总结


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比例则是给定一个速度的大致范围，满足下面这个公式；
Kp​∗e(t)
因此比例作用相当于某一时刻的偏差（err）与比例系数Kp​的乘积，具体如下所示；

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

I 积分则是误差在一定时间内的和，满足以下公式；
1.jpg
如下图所示；
红色曲线阴影部分面积即为积分作用的结果，其不断累积的误差，最终乘以积分系数 Ki​ 就得到了积分部分的输出；
D微分则是误差变化曲线某处的导数，或者说是某一点的斜率，因此这里需要引入微分；
1.jpg

从图中可知，当偏差变化过快，微分环节会输出较大的负数，作为抑制输出继续上升，从而抑制过冲。


4.2 理论基础


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

图片来自Wiki
1.jpg

4.4 伪算法

这里简单总结一下增量式PID实现的伪算法；
  1. previous_error := 0  //上一次偏差
  2. integral := 0   //积分和
  4. //循环
  5. //采样周期为dt
  6. loop:
  7. //setpoint 设定值
  8. //measured_value 反馈值
  9.     error := setpoint − measured_value //计算得到偏差
  10.     integral := integral + error × dt //计算得到积分累加和
  11.     derivative := (error − previous_error) / dt //计算得到微分
  12.     output := Kp × error + Ki × integral + Kd × derivative //计算得到PID输出
  13.     previous_error := error //保存当前偏差为下一次采样时所需要的历史偏差
  14.     wait(dt) //等待下一次采用
  15.     goto loop
5 C++实现

这里是增量式PID算法的C语言实现；

pid.cpp
  1. #ifndef _PID_SOURCE_
  2. #define _PID_SOURCE_
  4. #include <iostream>
  5. #include <cmath>
  6. #include "pid.h"
  8. using namespace std;
  10. class PIDImpl
  11. {
  12.     public:
  13.         PIDImpl( double dt, double max, double min, double Kp, double Kd, double Ki );
  14.         ~PIDImpl();
  15.         double calculate( double setpoint, double pv );
  17.     private:
  18.         double _dt;
  19.         double _max;
  20.         double _min;
  21.         double _Kp;
  22.         double _Kd;
  23.         double _Ki;
  24.         double _pre_error;
  25.         double _integral;
  26. };
  29. PID::PID( double dt, double max, double min, double Kp, double Kd, double Ki )
  30. {
  31.     pimpl = new PIDImpl(dt,max,min,Kp,Kd,Ki);
  32. }
  33. double PID::calculate( double setpoint, double pv )
  34. {
  35.     return pimpl->calculate(setpoint,pv);
  36. }
  37. PID::~PID()
  38. {
  39.     delete pimpl;
  40. }
  43. /**
  44. * Implementation
  45. */
  46. PIDImpl::PIDImpl( double dt, double max, double min, double Kp, double Kd, double Ki ) :
  47.     _dt(dt),
  48.     _max(max),
  49.     _min(min),
  50.     _Kp(Kp),
  51.     _Kd(Kd),
  52.     _Ki(Ki),
  53.     _pre_error(0),
  54.     _integral(0)
  55. {
  56. }
  58. double PIDImpl::calculate( double setpoint, double pv )
  59. {
  60.    
  61.     // Calculate error
  62.     double error = setpoint - pv;
  64.     // Proportional term
  65.     double Pout = _Kp * error;
  67.     // Integral term
  68.     _integral += error * _dt;
  69.     double Iout = _Ki * _integral;
  71.     // Derivative term
  72.     double derivative = (error - _pre_error) / _dt;
  73.     double Dout = _Kd * derivative;
  75.     // Calculate total output
  76.     double output = Pout + Iout + Dout;
  78.     // Restrict to max/min
  79.     if( output > _max )
  80.         output = _max;
  81.     else if( output < _min )
  82.         output = _min;
  84.     // Save error to previous error
  85.     _pre_error = error;
  87.     return output;
  88. }
  90. PIDImpl::~PIDImpl()
  91. {
  92. }
  94. #endif
pid.h
  1. #ifndef _PID_H_
  2. #define _PID_H_
  4. class PIDImpl;
  5. class PID
  6. {
  7.     public:
  8.         // Kp -  proportional gain
  9.         // Ki -  Integral gain
  10.         // Kd -  derivative gain
  11.         // dt -  loop interval time
  12.         // max - maximum value of manipulated variable
  13.         // min - minimum value of manipulated variable
  14.         PID( double dt, double max, double min, double Kp, double Kd, double Ki );
  16.         // Returns the manipulated variable given a setpoint and current process value
  17.         double calculate( double setpoint, double pv );
  18.         ~PID();
  20.     private:
  21.         PIDImpl *pimpl;
  22. };
  24. #endif
pid_example.cpp
  1. #include "pid.h"
  2. #include <stdio.h>
  4. int main() {
  6.     PID pid = PID(0.1, 100, -100, 0.1, 0.01, 0.5);
  8.     double val = 20;
  9.     for (int i = 0; i < 100; i++) {
  10.         double inc = pid.calculate(0, val);
  11.         printf("val:% 7.3f inc:% 7.3f\n", val, inc);
  12.         val += inc;
  13.     }
  15.     return 0;
  16. }
编译并测试；
  1. g++ -c pid.cpp -o pid.o
  2. # To compile example code:
  3. g++ pid_example.cpp pid.o -o pid_example
6 总结
本文总结了PID控制器算法在闭环系统中根据偏差变化的具体调节作用，每个环节可能对系统输出造成什么样的变化，给出了位置式和增量式离散PID算法的推导过程，并给出了位置式算法的C++程序实现。