改进式PID控制以及C语言实现过程

改进式PID控制

         如果是在低速模式下，标准的PID基本可以满足控制要求，但随着速度的提升，PID算法要进一步修改和完善才能达到控制要求。因此需要对PID算式进行适当的改进，从而提高控制质量。

         积分项的改进

         积分项的作用：消除稳态误差，提高控制系统的精度。

积分项存在的问题：偏差较大时，积分的滞后作用会影响系统的响应速度，引起较大的超调及加长过渡过程，尤其对时间常数较大，有时间滞后的被控对象，更加剧了振荡过程。

1.      积分分离法：

改进方案：当偏差大于某个规定的门限值时，取消积分作用，从而使积分不至于过大。只有当e（k）较小时，才引入积分作用，以消除静差。这样控制量不易进入饱和区；即使进入了饱和区，也能较快的退出，所以能使系统的输出特性得到改善。

 

2.      抗积分饱和法：

改进方案：当控制量进入饱和区后，只执行削弱积分项的累加，而不进行增大积分项的累加。即计算u(k)时，先判断u(k-1)是否超过限制范围，若已超过umax，则只累计负偏差；若小于umin，则只累计正偏差，这种方法也可以避免控制量长期停留在饱和区。

算法案例如下：

/*
	积分分离的pid控制算法c语言实现
	系统所用时间是原来时间的一半
	系统的快速性得到了提高
*/

#include<stdio.h>
#include<stdlib.h>

struct _pid{
	float SetSpeed; 		//定义设定值	//24V   1100-1900
	float ActualSpeed; 		//定义实际值
	float err; 				//定义偏差值
	float err_last; 		//定义上一个偏差值
	float Kp,Ki,Kd; 		//定义比例、积分、微分系数
	float voltage; 			//定义电压值（控制执行器的变量）
	float integral;		    //定义积分值
}pid;

//项目中获取到的参数
void PID_init(){
	printf("PID_init begin \n");
	pid.SetSpeed=0.0;
	pid.ActualSpeed=0.0;
	pid.err=0.0;
	pid.err_last=0.0;
	pid.voltage=0.0;
	pid.integral=0.0;
	pid.Kp=0.2;				//自己设定
	pid.Ki=0.04;			//自己设定
	pid.Kd=0.2;				//自己设定
	printf("PID_init end \n");
}


float PID_realize(float speed){
	pid.SetSpeed=speed;						//设定值
	pid.err=pid.SetSpeed-pid.ActualSpeed;	//设定值-实际值
	int index;
	if(abs(pid.err)>200)
	{
		index=0;
	}else{
		index=1;
		pid.integral+=pid.err;
	}
	pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.
	err-pid.err_last); //算法具体实现过程
	
	pid.err_last=pid.err;					//上一个偏差值
	pid.ActualSpeed=pid.voltage*1.0;		//算出实际值
	return pid.ActualSpeed;					//返回
}

int main(){
	PID_init();
	int count=0;
	while(count<1000)
	{
	float speed=PID_realize(200.0);
	printf("%f\n",speed);
	count++;
	}
	return 0;
}

/*
	抗击分饱和的pid控制算法
	
*/

#include<stdio.h>
#include<stdlib.h>
struct _pid{
	float SetSpeed; //定义设定值
	float ActualSpeed; //定义实际值
	float err; //定义偏差值
	float err_last; //定义上一个偏差值
	float Kp,Ki,Kd; //定义比例、积分、微分系数
	float voltage; //定义电压值（控制执行器的变量）
	float integral; //定义积分值
	float umax;
	float umin;
}pid;

void PID_init(){
	printf("PID_init begin \n");
	pid.SetSpeed=0.0;
	pid.ActualSpeed=0.0;
	pid.err=0.0;
	pid.err_last=0.0;
	pid.voltage=0.0;
	pid.integral=0.0;
	pid.Kp=0.2;
	pid.Ki=0.1; //注意，和上几次相比，这里加大了积分环节的值
	pid.Kd=0.2;
	pid.umax=400;
	pid.umin=-200;
	printf("PID_init end \n");
}

float PID_realize(float speed){
	int index;
	pid.SetSpeed=speed;
	pid.err=pid.SetSpeed-pid.ActualSpeed;
	if(pid.ActualSpeed>pid.umax) //灰色底色表示抗积分饱和的实现
	{
		if(abs(pid.err)>200) //蓝色标注为积分分离过程
		{
		index=0;
		}else{
			index=1;
			if(pid.err<0)
			{
			pid.integral+=pid.err;
			}
		}
	}else if(pid.ActualSpeed<pid.umin){
		if(abs(pid.err)>200) //积分分离过程
		{
			index=0;
		}else{
			index=1;
			if(pid.err>0)
			{
				pid.integral+=pid.err;
			}
		}
	}else{
			if(abs(pid.err)>200) //积分分离过程
			{
				index=0;
			}else{
				index=1;
				pid.integral+=pid.err;
			}
		}
//	pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral+pid.Kd*(pid.err-pid.err_last);
pid.voltage=pid.Kp*pid.err+index*pid.Ki*pid.integral/2+pid.Kd*(pid.err-pid.err_last);//梯形积分
	pid.err_last=pid.err;
	pid.ActualSpeed=pid.voltage*1.0;
	return pid.ActualSpeed;
}

int main(){
	PID_init();
	int count=0;
	while(count<1000)
	{
	float speed=PID_realize(200.0);
	printf("%f\n",speed);
	count++;
	}
	return 0;
}