文章目录
连续PID控制器
离散式PID控制器
位置式PID
增量式PID

连续PID控制器
比例积分微分控制器，三个环节P（比例）、I（积分）、D（微分）通过线性组合，输入量为偏差信号e（t），输出为控制信号u（t）。

根据系统输出y与期望输入r的偏差e，调控u使整个系统输出y趋近于r，增强系统的稳定性。


这是时域模式，因此进行拉普拉斯变换，获得复频域传递函数



kp-比例系数——提高系统的动态响应，对应于系统响应图的超调量以及调整时间；

Ti 积分时间——Ki=1/Ti消除稳态误差，积分环节存在就会产生系统误差积累，调整Ti，是为了降低过大的误差积累；es=lim G(s)H(s)

Td 微分时间——克服系统震荡，调小Kd，可以加快系统稳定性，降低超调量与响应速度，保证动态性能。

（主要是调整Kp，Kd两个参数）



来源百科。
离散式PID控制器
位置式PID
在数字化系统中，假设周期采样Fs，采样周期为T，离散自变量为n，则离散PID控制表达式4.1为：



式中，


增量式PID
由位置式PID公式，通过递推公式，



使用增量型PID可以防止出现数据溢出的现象，保证了控制信号没有出现误差的累计，其只需确定最近两次的采样值，也就是偏差信号，所以通过加权处理，控制效果会更好一些。

可以获得增量型PID表达式。








链接: MATLAB程序下载.

                        
                        
数据结构核心原理与算法应用
                    

	

目录
1 什么是增量式PID?
2 举个例子
2.1 位置式PID
2.2 增量式PID
3 伪算法
4 C语言实现
5 总结
在之前一篇博客中( 简易PID算法的快速扫盲 )简单介绍了PID算法的基本原理和位置式算法的实现过程，由于部分推导过程已经在上一篇文章做过介绍，所以推导过程本文不再赘述，重点将对离散增量式PID的算法进行实现。
1 什么是增量式PID?
先看一下增量式PID的离散公式如下：
：比例系数：积分系数：微分系数：偏差
对于所谓的位置式，增量式的算法，这两者只是在算法的实现上的存在差异，本质的控制上对于系统控制的影响还是相同，单纯从输入和输出的角度来比较，具体如下表所示；
这里简单的说明一下；
位置式：位置式算法较为简单，直接输入当前的偏差 ，即可得到输出；
增量式：增量式算法需要保存历史偏差，，，即在第次控制周期时，需要使用第和第次控制所输入的偏差，最终计算得到 ，此时，这还不是我们所需要的PID输出量；所以需要进行累加；
不难发现第一次控制周期时，即时；
由以上公式我们可以推导出下式；
所以可以看出，最终PID的输出量，满足以下公式；
可见增量式算法，就是所计算出的PID增量的历史累加和；
2 举个例子
2.1 位置式PID
下面从一个简单的例子中去理解一下增量式PID，这里依然举一个不是很恰当的例子；如果是位置式PID算法的话：
隆哥对一个直流电机进行调速，设定了转速为 1000；
这时由于反馈回来的速度和设定的速度偏差为 ；
经过位置式PID计算得到；
作为Process的输入值(可以是PWM的占空比)，最终Process输出相应的PWM驱动直流电机；
反馈装置检测到电机转速，然后重复以上步骤；
整体框图如下所示；
2.2 增量式PID
对于增量式PID来说；
隆哥对一个直流电机进行调速，设定了转速为 1000；
这时由于反馈回来的速度和设定的速度偏差为 ，系统中保存上一次的偏差和上上次的偏差，这三个输入量经过增量PID计算得到；
系统中还保存了上一次的PID输出的，所以加上增量，就是本次控制周期的PID输出——；
作为Process的输入值(可以是PWM的占空比)，最终Process输出相应的PWM驱动直流电机；
反馈装置检测到电机转速，然后重复以上步骤；
整体框图如下所示；
所以这里不难发现，所谓增量式PID，它的特点有：
需要输入历史的偏差值；
计算得到的是PID输出增量，因此每一次需要累加历史增量最为当前的PID输出；
下面简单介绍一下如何实现增量式PID算法；
3 伪算法
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

4 C语言实现
这里直接使用了TI公司的PID算法，做了积分抗饱和；具体可以参考controlSUITE\libs\app_libs\motor_control\math_blocks\v4.2\pid_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     
}
 
5 总结
本文简单总结了位置式PID算法和增量式PID算法的差异，参考了TI公司的增量式PID算法实现，对于不同的控制对象可以根据系统要求选择合适的PID算法；
由于作者能力和水平有限，文中难免存在错误和纰漏，请不吝赐教。
精彩回顾
● STC单片机自动下载电路● 简易PID算法的快速扫盲
● 你会51单片机的精确延时吗？
● 原来SPI并没有我想的那么简单
● 什么是状态机？用C语言实现进程5状态模型
●精彩好文：CPU 到底是怎么识别代码的？

	

目录
1 什么是增量式PID?
2 举个例子
2.1 位置式PID
2.2 增量式PID
3 伪算法
4 C语言实现
5 总结
在之前一篇博客中( 简易PID算法的快速扫盲 )简单介绍了PID算法的基本原理和位置式算法的实现过程，由于部分推导过程已经在上一篇文章做过介绍，所以推导过程本文不再赘述，重点将对离散增量式PID的算法进行实现。
1 什么是增量式PID?
先看一下增量式PID的离散公式如下：
：比例系数：积分系数：微分系数：偏差
对于所谓的位置式，增量式的算法，这两者只是在算法的实现上的存在差异，本质的控制上对于系统控制的影响还是相同，单纯从输入和输出的角度来比较，具体如下表所示；这里简单的说明一下；
位置式：位置式算法较为简单，直接输入当前的偏差 ，即可得到输出；
增量式：增量式算法需要保存历史偏差，，，即在第次控制周期时，需要使用第和第次控制所输入的偏差，最终计算得到 ，此时，这还不是我们所需要的PID输出量；所以需要进行累加；
不难发现第一次控制周期时，即时；由以上公式我们可以推导出下式；所以可以看出，最终PID的输出量，满足以下公式；可见增量式算法，就是所计算出的PID增量的历史累加和；
2 举个例子
2.1 位置式PID
下面从一个简单的例子中去理解一下增量式PID，这里依然举一个不是很恰当的例子；如果是位置式PID算法的话：
隆哥对一个直流电机进行调速，设定了转速为 1000；
这时由于反馈回来的速度和设定的速度偏差为 ；
经过位置式PID计算得到；
作为Process的输入值(可以是PWM的占空比)，最终Process输出相应的PWM驱动直流电机；
反馈装置检测到电机转速，然后重复以上步骤；
整体框图如下所示；
2.2 增量式PID
对于增量式PID来说；
隆哥对一个直流电机进行调速，设定了转速为 1000；
这时由于反馈回来的速度和设定的速度偏差为 ，系统中保存上一次的偏差和上上次的偏差，这三个输入量经过增量PID计算得到；
系统中还保存了上一次的PID输出的，所以加上增量，就是本次控制周期的PID输出——；
作为Process的输入值(可以是PWM的占空比)，最终Process输出相应的PWM驱动直流电机；
反馈装置检测到电机转速，然后重复以上步骤；
整体框图如下所示；
所以这里不难发现，所谓增量式PID，它的特点有：
需要输入历史的偏差值；
计算得到的是PID输出增量，因此每一次需要累加历史增量最为当前的PID输出；
下面简单介绍一下如何实现增量式PID算法；
3 伪算法
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
4 C语言实现
这里直接使用了TI公司的PID算法，做了积分抗饱和；具体可以参考controlSUITE\libs\app_libs\motor_control\math_blocks\v4.2\pid_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 wordstypedef 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     
}
5 总结
本文简单总结了位置式PID算法和增量式PID算法的差异，参考了TI公司的增量式PID算法实现，对于不同的控制对象可以根据系统要求选择合适的PID算法；-END-
往期好文合集
PID到底是个啥？来给你讲个故事再论PID，PID其实很简单。。。电子设计竞赛(4)-常用的两种PID算法
  最 后   
若觉得文章不错，转发分享，也是我们继续更新的动力。5T资源大放送！包括但不限于：C/C++，Linux，Python，Java，PHP，人工智能，PCB、FPGA、DSP、labview、单片机、等等！在公众号内回复「更多资源」，即可免费获取，期待你的关注~

	

少年不识愁滋味，爱上层楼。爱上层楼，为赋新词强说愁。而今识尽愁滋味，欲说还休。欲说还休，却道天凉好个秋。
一、开局一张图，剩下全靠编。
PID控制系统原理图
二、PID控制算法大致分为增量式PID和位置式PID。
1.位置式PID:输出控制的值u(k)当前误差，过去累计误差，当前误差与上次误差的和相加。直接输出控制值。
位置式公式
2.增量式PID:由公式可以看出，输出值只与前三次误差有关系。输出值u(k)需要进行累加。
增量式公式
3.我这里使用到的是增量式PID，下图是PID调节理想状态下的模型。结合前面所提到的文章“一种提高ADC精度的方法”，用生成的多项式来修正ADC转换出来的结果，再加上PID调节，可以提高设备的精度和响应速度。
 
理想状态下模型
 二、参数的调节
PID系数的确定更多是依靠调试的经验和实际的情况，最终快速，稳定，准确的达到目标值。难点在于调节速度和稳定，速度提高会导致系统震荡、过冲，系统过于稳定会导致调节速度过慢，所以需要取合适的参数来平衡。在实际系统中还会遇到实际的问题，比如：过冲，系统惯性，系统延迟，反馈时间，这些都是根据设备的不同而不同，需要根据具体的实际情况调节。调试的方法具体分为三步。
1.先调节比例系数P，将I=0，D=0;先将P取一个较大的值，然后慢慢减小，直到系统的震荡减小。设定的调节目标值需要小于系统的最大阀值。
2.调节积分时间常数I，比例系数P参数确定后，调节I的方法与P相似，调至系统不震荡为止。3.调节微分时间常数D,P和I确定之后，最后来调节D，方法与上面一样，调节至系统不震荡为止。
三、实际案例
最后贴出部分源代码
void power_pid(void)        /*xiaoyang,增量式PID*/{    static float dac_channe11_value=600;    static float power_error,power_last_error,power_previous_error;     /*本次误差，上次误差，上上次误差*/    if(RF & Power && ready)    {        power_error = Pset - PowerOut;        dac_channe11_value += 0.002f*(power_error-power_last_error)                              +0.030f*power_error                              +0.004f*(power_error-2*power_last_error+power_previous_error);        power_previous_error = power_last_error;        /*上次误差存入上上次误差*/        power_last_error = power_error;         /*本次误差存入上次误差*/        if(dac_channe11_value > 4000)            dac_channe11_value = 4000;                DAC_SetChannel2Data(DAC_Align_12b_R,dac_channe11_value);         /*硬件采用两级放大，这是使用两级共同放大*/        DAC_SetChannel1Data(DAC_Align_12b_R,dac_channe11_value);    }    else    {        dac_channe11_value=600;        power_error=0, power_last_error=0,power_previous_error=0;        DAC_SetChannel2Data(DAC_Align_12b_R,dac_channe11_value);        DAC_SetChannel1Data(DAC_Align_12b_R,dac_channe11_value);    }}
算法代码
从输出功率波形上来看，输出功率在短时间内得到了上升，在达到了设定功率后，稳定没有跳变或变化很小，误差范围控制在0.5%。
功率输出波形
从实际的输出功率与设定的输出功率可以看出，设定值为6000W，实际输出功率为5999W。
功率设置