PID算法

2018年04月06日 15:54:43
阅读数：10

1.      数字（离散）PID控制算法的表达式：

将PID调节器离散化，用差分方程来代替连续系统的微分方程，分为位置式和增量式两类。

重点理解概念如下：

a）  基本偏差e(t)：表示当前测量值与设定目标值间的差，设定目标是被减数，结果可为正或负值，正值表示未达到目标，负值表示超过设定值。（代表比例）

b）  偏差和：即每次测量的差值总和，注意正负（代表积分）

c）  基本偏差的相对偏差：即e(t)-e(t-1)用本次的基本偏差减去上一次的基本偏差。（代表微分）

位置式：

增量式：

位置式和增量式三个参数的作用：

1.      Kp参数：能迅速反映误差，从而减小误差，但他不能消除稳态误差，加大Kp还会引起系统的不稳定。

2.      Ki参数：只要有足够的时间，积分作用将能完全消除误差。但其缺点积分控制是偏差累积控制，控制作业缓慢，但是如果积分作用太强会使系统的超调量加大，甚至出现振荡。

3.      Kd参数：预测误差变化趋势，减小超调量，克服振荡，使系统的稳定性提高，还能加快系统的动态响应速度，减小调整时间，从而改善系统的动态性能。

参考代码如下:

[cpp] 
view plain
 copy

1. /* 
2.  
3.     位置型pid 
4.  
5. */  
6. #include <stdio.h>  
7. #include<ioctl.h>  
8.   
9. struct _pid{  
10. float SetSpeed;         //定义设定值  
11. float ActualSpeed;      //定义实际值  
12. float err;              //定义偏差值  
13. float err_last;         //定义上一个偏差值  
14. float Kp,Ki,Kd;         //定义比例、积分、微分系数  
15. float voltage;          //定义电压值（控制执行器的变量）  
16. float integral;         //定义积分值  
17. }pid;  
18.   
19. //项目中获取到的参数  
20. void PID_init(){  
21.     printf(“PID_init begin \n”);  
22.     pid.SetSpeed=0.0;  
23.     pid.ActualSpeed=0.0;  
24.     pid.err=0.0;  
25.     pid.err_last=0.0;  
26.     pid.voltage=0.0;  
27.     pid.integral=0.0;  
28.     pid.Kp=0.2;             //自己设定  
29.     pid.Ki=0.015;           //自己设定  
30.     pid.Kd=0.2;             //自己设定  
31.     printf(“PID_init end \n”);  
32. }  
33.   
34. float PID_realize(float speed){  
35.     pid.SetSpeed=speed;                     //设定值  
36.     pid.err=pid.SetSpeed-pid.ActualSpeed;   //设定值-实际值  
37.     pid.integral+=pid.err;                  //积分值，偏差累加  
38.     pid.voltage=pid.Kp*pid.err+pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);  
39.     pid.err_last=pid.err;                   //上一个偏差值  
40.     pid.ActualSpeed=pid.voltage*1.0;        //算出实际值  
41.     return pid.ActualSpeed;                 //返回  
42. }  
43.   
44. int main(){  
45.     printf(“System begin \n”);  
46.     PID_init();  
47.     int count=0;  
48.     while(count<1000)  
49.     {  
50.     float speed=PID_realize(200.0);  
51.     printf(“%f\n”,speed);  
52.     count++;  
53.     }  
54.     return 0;  
55. }  

增量式代码：

[cpp] 
view plain
 copy

1. /* 
2.     增量型pid 
3. */  
4. #include<stdio.h>  
5. #include<stdlib.h>  
6. struct _pid{  
7.     float SetSpeed; //定义设定值  
8.     float ActualSpeed; //定义实际值  
9.     float err; //定义偏差值  
10.     float err_next; //定义上一个偏差值  
11.     float err_last; //定义最上前的偏差值  
12.     float Kp,Ki,Kd; //定义比例、积分、微分系数  
13. }pid;  
14. void PID_init(){  
15.     pid.SetSpeed=0.0;  
16.     pid.ActualSpeed=0.0;  
17.     pid.err=0.0;  
18.     pid.err_last=0.0;  
19.     pid.err_next=0.0;  
20.     pid.Kp=0.2;  
21.     pid.Ki=0.015;  
22.     pid.Kd=0.2;  
23. }  
24. float PID_realize(float speed){  
25.     pid.SetSpeed=speed;  
26.     pid.err=pid.SetSpeed-pid.ActualSpeed;  
27.     float  
28.     incrementSpeed=pid.Kp*(pid.err-pid.err_next)+pid.Ki*pid.err+pid.Kd*(pid.err-2*pid.err_next+pid.err_last);  
29.     pid.ActualSpeed+=incrementSpeed;  
30.     pid.err_last=pid.err_next;  
31.     pid.err_next=pid.err;  
32.     return pid.ActualSpeed;  
33. }  
34. int main(){  
35.     PID_init();  
36.     int count=0;  
37.     while(count<1000)  
38.     {  
39.     float speed=PID_realize(200.0);  
40.     printf(“%f\n”,speed);  
41.     count++;  
42.     }  
43.     return 0;  
44. }  

文章标签： 
pid
个人分类： 
算法