電子發(fā)燒友App
PID算法的定義：
P：比例控制項。 I：積分控制項。 D：微分控制項。
設(shè)當前輸出量為U，我們的期望值或是設(shè)定值為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的計算不太方便，長時間單方向的累加將可能出現(xiàn)溢出，于是將上式改為如下所示的增量形式：
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結(jié)構(gòu)=========================
static float MinValue; //最大值限制
static float MaxValue; //最小值限制
static float CurrentValue; //當前采樣值
static struct PID{
float Ki; //定義積分常數(shù)
float Kp; //定義比例常數(shù)
float Kd; //定義微分常數(shù)
float E_2; //存儲前前次誤差
float E_1; //存諸前次誤差
float E; //存儲本次誤差
float OutPut; //本次輸出量
float ValueSet; //設(shè)定值或期望值
}Control;
//===========================PID計算函數(shù)=====================
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;
}
以上三個函數(shù)為PID的主體函數(shù)，也是萬用PID函數(shù)．代碼量已經(jīng)相當精簡了。注意上面的PID初始化函數(shù)中有Kp，Ki，Kd的符號一定要正確，否則輸出量方向相反，后果不堪設(shè)想！！！
附上一段完整代碼：
#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++;
}
}
工商網(wǎng)監(jiān)
評論