电子说
PID算法非常强大，其三个部分分别为；
P：比例环节；I：积分环节；D：微分环节；PID算法可以自动对控制系统进行准确且迅速的校正，因此被广泛地应用于工业控制系统。
Input：告诉隆哥目标距离的直线位置（10米）；Controller：隆哥大脑中计算出到达目标所需要走多少步；Process：双腿作为执行机构，输出了相应的步数，但是最终仍然偏离了目标；
Input：告诉隆哥目标距离的直线位置（10米）；Controller：隆哥大脑中计算出到达目标所需要走多少步；Process：双腿作为执行机构，输出了相应的步数，但是最终仍然偏离了目标；Feedback：通过视觉获取到目前已经前进的距离，（比如前进了2米，那么还有8米的偏差）；err：根据偏差重新计算所需要的步数，然后重复上述四个步骤，最终隆哥达到最终的目标位置。 PID Controller，只要适当调整P，I和D的参数，就可以到达目标位置，具体如下图所示；
P比例则是给定一个速度的大致范围，满足下面这个公式；
err）与比例系数的乘积，具体如下所示；
绿色线为上述例子中从初始位置到目标位置的距离变化；红色线为上述例子中从初始位置到目标位置的偏差变化，两者为互补的关系；
I积分则是误差在一定时间内的和，满足以下公式；
如下图所示；
D微分则是误差变化曲线某处的导数，或者说是某一点的斜率，因此这里需要引入微分；
| Kp | 减少 | 增加 | 小变化 | 减少 | 降级 |
| Ki | 减少 | 增加 | 增加 | 消除 | 降级 |
| Kd | 微小的变化 | 减少 | 减少 | 理论上没有影响 | 小，稳定性会提升 |
PID在负反馈系统中的调节作用，下面开始推导一下算法实现的具体过程；PID控制器的系统框图如下所示；
是比例增益；是积分增益；是微分增益；
将式①再做一下简化；
最终得到增量式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
pid.cpp
#ifndef _PID_SOURCE_ #define _PID_SOURCE_ #include #include #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 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
PID控制器算法在闭环系统中根据偏差变化的具体调节作用，每个环节可能对系统输出造成什么样的变化，给出了位置式和增量式离散PID算法的推导过程，并给出了位置式算法的C++程序实现。
先看一下增量式PID的离散公式如下：
：比例系数 ：积分系数 ：微分系数 ：偏差
对于所谓的位置式，增量式的算法，这两者只是在算法的实现上的存在差异，本质的控制上对于系统控制的影响还是相同，单纯从输入和输出的角度来比较，具体如下表所示；
这里简单的说明一下；
不难发现第一次控制周期时，即时；
由以上公式我们可以推导出下式；
所以可以看出，最终PID的输出量，满足以下公式；
可见增量式算法，就是所计算出的PID增量的历史累加和；
下面从一个简单的例子中去理解一下增量式PID，这里依然举一个不是很恰当的例子；如果是位置式PID算法的话：
整体框图如下所示；
对于增量式PID来说；
整体框图如下所示；
所以这里不难发现，所谓增量式PID，它的特点有：
下面简单介绍一下如何实现增量式PID算法；
previous02_error := 0 //上上次偏差
previous01_error := 0 //上一次偏差
integral := 0 //积分和
pid_out := 0 //pid增量累加和
//循环
//采样周期为dt
loop:
//setpoint 设定值
//measured_value 反馈值
error := setpoint − measured_value //计算得到偏差
proportion := error - previous01_error //计算得到比例输出
integral := error × dt //计算得到积分累加和
derivative := (error − 2*previous01_error + previous02_error) / dt //计算得到微分
pid_delta := Kp × error + Ki × integral + Kd × derivative //计算得到PID增量
pid_out := pid_out + pid_delta //计算得到PID输出
//保存当前的偏差和上一次偏差作为下一次采样所需要的历史偏差
previous02_error := previous01_error
previous01_error := error //保存当前偏差为下一次采样时所需要的历史偏差
wait(dt) //等待下一次采用
goto loop
这里直接使用了TI公司的PID算法，做了积分抗饱和；具体可以参考controlSUITElibsapp_libsmotor_controlmath_blocksv4.2pid_grando.h
具体代码如下所示；
pid_grando.h
/* =================================================================================
File name: PID_GRANDO.H
===================================================================================*/
#ifndef __PID_H__
#define __PID_H__
typedef struct { _iq Ref; // Input: reference set-point
_iq Fbk; // Input: feedback
_iq Out; // Output: controller output
_iq c1; // Internal: derivative filter coefficient 1
_iq c2; // Internal: derivative filter coefficient 2
} PID_TERMINALS;
// note: c1 & c2 placed here to keep structure size under 8 words
typedef struct { _iq Kr; // Parameter: reference set-point weighting
_iq Kp; // Parameter: proportional loop gain
_iq Ki; // Parameter: integral gain
_iq Kd; // Parameter: derivative gain
_iq Km; // Parameter: derivative weighting
_iq Umax; // Parameter: upper saturation limit
_iq Umin; // Parameter: lower saturation limit
} PID_PARAMETERS;
typedef struct { _iq up; // Data: proportional term
_iq ui; // Data: integral term
_iq ud; // Data: derivative term
_iq v1; // Data: pre-saturated controller output
_iq i1; // Data: integrator storage: ui(k-1)
_iq d1; // Data: differentiator storage: ud(k-1)
_iq d2; // Data: differentiator storage: d2(k-1)
_iq w1; // Data: saturation record: [u(k-1) - v(k-1)]
} PID_DATA;
typedef struct { PID_TERMINALS term;
PID_PARAMETERS param;
PID_DATA data;
} PID_CONTROLLER;
/*-----------------------------------------------------------------------------
Default initalisation values for the PID objects
-----------------------------------------------------------------------------*/
#define PID_TERM_DEFAULTS {
0,
0,
0,
0,
0
}
#define PID_PARAM_DEFAULTS {
_IQ(1.0),
_IQ(1.0),
_IQ(0.0),
_IQ(0.0),
_IQ(1.0),
_IQ(1.0),
_IQ(-1.0)
}
#define PID_DATA_DEFAULTS {
_IQ(0.0),
_IQ(0.0),
_IQ(0.0),
_IQ(0.0),
_IQ(0.0),
_IQ(0.0),
_IQ(0.0),
_IQ(1.0)
}
/*------------------------------------------------------------------------------
PID Macro Definition
------------------------------------------------------------------------------*/
#define PID_MACRO(v)
/* proportional term */
v.data.up = _IQmpy(v.param.Kr, v.term.Ref) - v.term.Fbk;
/* integral term */
v.data.ui = _IQmpy(v.param.Ki, _IQmpy(v.data.w1,
(v.term.Ref - v.term.Fbk))) + v.data.i1;
v.data.i1 = v.data.ui;
/* derivative term */
v.data.d2 = _IQmpy(v.param.Kd, _IQmpy(v.term.c1,
(_IQmpy(v.term.Ref, v.param.Km) - v.term.Fbk))) - v.data.d2;
v.data.ud = v.data.d2 + v.data.d1;
v.data.d1 = _IQmpy(v.data.ud, v.term.c2);
/* control output */
v.data.v1 = _IQmpy(v.param.Kp,
(v.data.up + v.data.ui + v.data.ud));
v.term.Out= _IQsat(v.data.v1, v.param.Umax, v.param.Umin);
v.data.w1 = (v.term.Out == v.data.v1) ? _IQ(1.0) : _IQ(0.0);
#endif // __PID_H__
example
/* Instance the PID module */
PID pid1={ PID_TERM_DEFAULTS, PID_PARAM_DEFAULTS, PID_DATA_DEFAULTS };
main() {
pid1.param.Kp = _IQ(0.5);
pid1.param.Ki = _IQ(0.005);
pid1.param.Kd = _IQ(0);
pid1.param.Kr = _IQ(1.0);
pid1.param.Km =_IQ(1.0);
pid1.param.Umax= _IQ(1.0);
pid1.param.Umin= _IQ(-1.0);
}
void interrupt periodic_interrupt_isr() {
pid1.Ref = input1_1; // Pass _iq inputs to pid1
pid1.Fbk = input1_2; // Pass _iq inputs to pid1
PID_MACRO(pid1); // Call compute macro for pid1
output1 = pid1.Out; // Access the output of pid1
}
简单总结了位置式PID算法和增量式PID算法的差异，参考了TI公司的增量式PID算法实现，对于不同的控制对象可以根据系统要求选择合适的PID算法。
原文标题：干货 | 什么是PID算法，增量式PID又是什么?
文章出处：【微信公众号：电子工程世界】欢迎添加关注!文章转载请注明出处。
审核编辑：汤梓红
全部0条评论
快来发表一下你的评论吧 !
