电子发烧友App
PID算法的定义：
P：比例控制项。 I：积分控制项。 D：微分控制项。
设当前输出量为U，我们的期望值或是设定值为U0，则可得当前时刻误差：E=U-U0;
PID算法即是对误差量E及E的历史进行某种线性组合得到控制量的算法。
一般形式：
Up=P*E;
Ui=i*（E+E_1+E_2+.。。） E_n为之前的第n次误差．
Ud=i*（E-E_1）
U=Up+Ui+Ud; U为PID控制输出量．
上式中Ui的计算不太方便，长时间单方向的累加将可能出现溢出，于是将上式改为如下所示的增量形式：
Up=p*（E-E_1） 比例项增量
Ui=i*（E-2*E_1+E_2） 微分项增量
Ud=i*E 积分项增量
U=Uout_1+Up+Ui+Ud U为PID控制输出量，Uout_1为前次PID输出值
Uout=U 保存本次值
对于上面的公式或理论，便可得到相应的C语言程序：
//======================定义PID结构=========================
static float MinValue; //最大值限制
static float MaxValue; //最小值限制
static float CurrentValue; //当前采样值
static struct PID{
float Ki; //定义积分常数
float Kp; //定义比例常数
float Kd; //定义微分常数
float E_2; //存储前前次误差
float E_1; //存诸前次误差
float E; //存储本次误差
float OutPut; //本次输出量
float ValueSet; //设定值或期望值
}Control;
//===========================PID计算函数=====================
void PidWork（） {
float Up，Ud，Ui;
Control.E=CurrentValue-Control.ValueSet; //得到本次误差
Up =Control.Kp*（Control.E-Control.E_1）; //得到比例项
Ud=Control.Kd*（Control.E-2*Control.E_1+Control.E_2）; //得到微分项
Ui=Control.Ki*Control.E; //得到积分项
Control.E_2=Control.E_1; //历史存储
Control.E_1=Control.E;
Control.OutPut+=Up+Ud+Ui; //计算增量和
if（Control.OutPut
else if（Control.OutPut》MaxValue）Control.OutPut=MaxValue;
}
//==========================初始化速度=========================
void PidInit（） {
MinValue=0;
MaxValue=1000;
CurrentValue=0;
Control.Kp=-6;
Control.Ki=-1.5;
Control.Kd=-0.5;
Control.E=0;
Control.E_2=0;
Control.E_1=0;
Control.ValueSet=100;
Control.OutPut=0;
}
以上三个函数为PID的主体函数，也是万用PID函数．代码量已经相当精简了。注意上面的PID初始化函数中有Kp，Ki，Kd的符号一定要正确，否则输出量方向相反，后果不堪设想！！！
附上一段完整代码：
#include
struct _pid {
int pv; /*integer that contains the process value*/
int sp; /*integer that contains the set point*/
float integral;
float pgain;
float igain;
float dgain;
int deadband;
int last_error;
};
struct _pid warm，*pid;
int process_point， set_point，dead_band;
float p_gain， i_gain， d_gain， integral_val，new_integ;;
/*------------------------------------------------------------------------
pid_init
DESCRIPTION This function initializes the pointers in the _pid structure
to the process variable and the setpoint. *pv and *sp are
integer pointers.
------------------------------------------------------------------------*/
void pid_init（struct _pid *warm， int process_point， int set_point）
{
struct _pid *pid;
pid = warm;
pid-》pv = process_point;
pid-》sp = set_point;
}
/*------------------------------------------------------------------------
pid_tune
DESCRIPTION Sets the proportional gain （p_gain）， integral gain （i_gain），
derivitive gain （d_gain）， and the dead band （dead_band） of
a pid control structure _pid.
------------------------------------------------------------------------*/
void pid_tune（struct _pid *pid， float p_gain， float i_gain， float d_gain， int dead_band）
{
pid-》pgain = p_gain;
pid-》igain = i_gain;
pid-》dgain = d_gain;
pid-》deadband = dead_band;
pid-》integral= integral_val;
pid-》last_error=0;
}
/*------------------------------------------------------------------------
pid_setinteg
DESCRIPTION Set a new value for the integral term of the pid equation.
This is useful for setting the initial output of the
pid controller at start up.
------------------------------------------------------------------------*/
void pid_setinteg（struct _pid *pid，float new_integ）
{
pid-》integral = new_integ;
pid-》last_error = 0;
}
/*------------------------------------------------------------------------
pid_bumpless
DESCRIPTION Bumpless transfer algorithim. When suddenly changing
setpoints， or when restarting the PID equation after an
extended pause， the derivative of the equation can cause
a bump in the controller output. This function will help
smooth out that bump. The process value in *pv should
be the updated just before this function is used.
------------------------------------------------------------------------*/
void pid_bumpless（struct _pid *pid）
{
pid-》last_error = （pid-》sp）-（pid-》pv）;
}
/*------------------------------------------------------------------------
pid_calc
DESCRIPTION Performs PID calculations for the _pid structure *a. This function uses the positional form of the pid equation， and incorporates an integral windup prevention algorithim. Rectangular integration is used， so this function must be repeated on a consistent time basis for accurate control.
RETURN VALUE The new output value for the pid loop.
USAGE #include ‘control.h’*/
float pid_calc（struct _pid *pid）
{
int err;
float pterm， dterm， result， ferror;
err = （pid-》sp） - （pid-》pv）;
if （abs（err） 》 pid-》deadband）
{
ferror = （float） err; /*do integer to float conversion only once*/
pterm = pid-》pgain * ferror;
if （pterm 》 100 || pterm 《》
{
pid-》integral = 0.0;
}
else
{
pid-》integral += pid-》igain * ferror;
if （pid-》integral 》 100.0）
{
pid-》integral = 100.0;
}
else if （pid-》integral 《 0.0）=“” pid-=“”》integral = 0.0;
}
dterm = （（float）（err - pid-》last_error）） * pid-》dgain;
result = pterm + pid-》integral + dterm;
}
else result = pid-》integral;
pid-》last_error = err;
return （result）;
}
void main（void）
{
float display_value;
int count=0;
pid = &warm;
// printf（‘Enter the values of Process point， Set point， P gain， I gain， D gain \n’）;
// scanf（‘%d%d%f%f%f’， &process_point， &set_point， &p_gain， &i_gain， &d_gain）;
process_point = 30;
set_point = 40;
p_gain = （float）（5.2）;
i_gain = （float）（0.77）;
d_gain = （float）（0.18）;
dead_band = 2;
integral_val =（float）（0.01）;
printf（‘The values of Process point， Set point， P gain， I gain， D gain \n’）;
printf（‘ %6d %6d %4f %4f %4f\n’， process_point， set_point， p_gain， i_gain， d_gain）;
printf（‘Enter the values of Process point\n’）;
while（count《》
{
scanf（‘%d’，&process_point）;
pid_init（&warm， process_point， set_point）;
pid_tune（&warm， p_gain，i_gain，d_gain，dead_band）;
pid_setinteg（&warm，0.0）; //pid_setinteg（&warm，30.0）;
//Get input value for process point
pid_bumpless（&warm）;
// how to display output
display_value = pid_calc（&warm）;
printf（‘%f\n’， display_value）;
//printf（‘\n%f%f%f%f’，warm.pv，warm.sp，warm.igain，warm.dgain）;
count++;
}
}
工商网监
评论