sum+=value_buf[count]*coe[count];
return（char）（sum/sum_coe）;
}
9、消抖滤波法
一、方法：
设置一个滤波计数器
将每次采样值不当前有效值比较：
如果采样值＝当前有效值，则计数器清零
如果采样值<>当前有效值，则计数器+1，并判断计数器是否>=上限N（溢出）
如果计数器溢出,则将本次值替换当前有效值,并清计数器
二、优点：
对于变化缓慢的被测参数有较好的滤波效果,
可避免在临界值附近控制器的反复开/关跳动或显示器上数值抖动
三、缺点：
对于快速变化的参数丌宜
如果在计数器溢出的那一次采样到的值恰好是干扰值,则会将干扰值当作有效值
导入系统
四、模块程序
#defineN12
charfilter（）
{
charcount=0;
charnew_value;
new_value=get_ad（）;
while（value!
=new_value）;
{
count++;
if（count>=N）returnnew_value;
delay（）;
new_value=get_ad（）;
}
returnvalue;
}
10、限幅消抖滤波法
一、方法：
相当于“限幅滤波法”+“消抖滤波法”
先限幅,后消抖
二、优点：
继承了“限幅”和“消抖”的优点
改进了“消抖滤波法”中的某些缺陷,避免将干扰值导入系统
三、缺点：
对于快速变化的参数丌宜
四、模块程序
参考子程序1、9
11、IIR数字滤波器
一、方法：
确定信号带宽，滤之。
Y（n）=a1*Y（n-1）+a2*Y（n-2）+...+ak*Y（n-k）+b0*X（n）+b1*X（n-1）+
b2*X（n-2）+...+bk*X（n-k）
二、优点：
高通，低通，带通，带阻任意。
设计简单（用matlab）
三、缺点：
运算量大。
四、模块程序
intBandpassFilter4（intInputAD4）
{
intReturnValue;
intii;
RESLO=0;
RESHI=0;
MACS=*PdelIn;
OP2=1068;//FilterCoeff4[4];
MACS=*（PdelIn+1）;
OP2=8;//FilterCoeff4[3];
MACS=*（PdelIn+2）;
OP2=-2001;//FilterCoeff4[2];
MACS=*（PdelIn+3）;
OP2=8;//FilterCoeff4[1];
MACS=InputAD4;
OP2=1068;//FilterCoeff4[0];
MACS=*PdelOu;
OP2=-7190;//FilterCoeff4[8];
MACS=*（PdelOu+1）;
OP2=-1973;//FilterCoeff4[7];
MACS=*（PdelOu+2）;
OP2=-19578;//FilterCoeff4[6];
MACS=*（PdelOu+3）;
OP2=-3047;//FilterCoeff4[5];
*p=RESLO;
*（p+1）=RESHI;
mytestmul<<=2;
ReturnValue=*（p+1）;
for（ii=0;ii<3;ii++）
{
DelayInput[ii]=DelayInput[ii+1];
DelayOutput[ii]=DelayOutput[ii+1];
}
DelayInput[3]=InputAD4;
DelayOutput[3]=ReturnValue;
//if（ReturnValue<0）
//{
//ReturnValue=-ReturnValue;
//}
returnReturnValue;
}
12、RC滤波算法
例子程序
RcDigital（double&X,double&Y）
{
staticintMidFlag;
staticdoubleYn_1,Xn_1;
doubleMyGetX=0,MyGetY=0;
doubleAlfa;
Alfa=0.7;
if（X==0||Y==0）
{
MidFlag=0;
Xn_1=0;
Yn_1=0;
MyGetX=0;
MyGetY=0;
}
if（X>0&&Y>0）
{
if（MidFlag==1）
{
MyGetY=（1-Alfa）*Y+Alfa*Yn_1;
MyGetX=（1-Alfa）*X+Alfa*Xn_1;
Xn_1=MyGetX;
Yn_1=MyGetY;
}
else
{
MidFlag=1;
MyGetX=X;
MyGetY=Y;
Xn_1=X;
Yn_1=Y;
}
}
X=MyGetX;
Y=MyGetY;
}
13、PID算法
结构·
模块程序
typedefstructPIDValue
{
uint32Ek_Uint32[3];//差值保存，给定和反馈的差值
uint8EkFlag_Uint8[3];//符号，1则对应的为负数，0为对应的
为正数
uint8KP_Uint8;
uint8KI_Uint8;
uint8KD_Uint8;
uint16Uk_Uint16;//上一时刻的控制电压
uint16RK_Uint16;//设定值
uint16CK_Uint16;//实际值
}PIDValueStr;
PIDValueStrPID;
uint8out;//加热输出
uint8count;//输出时间单位计数器
/*********************************
PID=Uk+KP*[E（k）-E（k-1）]+KI*E（k）+KD*[E（k）-2E（k-1）+E（k-2）];（增量型PID算式）
函数入口:
RK（设定值）,CK（实际值）,KP,KI,KD
函数出口:
U（K）
//PID运算函数
********************************/
voidPIDOperation（void）
{
uint32Temp[3];//中间临时变量
uint32PostSum;//正数和
uint32NegSum;//负数和
Temp[0]=0;
Temp[1]=0;
Temp[2]=0;
PostSum=0;
NegSum=0;
if（PID.RK_Uint16>PID.RK_Uint16）//设定值大于实际值否？
{
if（PID.RK_Uint16-PID.RK_Uint16>10）//偏差大于10否？
{
PID.Uk_Uint16=100;
}//偏差大于10为上限幅值输出（全速加热）
else
{
Temp[0]=PID.RK_Uint16-PID.CK_Uint16;//偏差<=10,计算E（k）
PID.EkFlag_Uint8[1]=0;//E（k）为正数
//数值秱位
PID.Ek_Uint32[2]=PID.Ek_Uint32[1];
PID.Ek_Uint32[1]=PID.Ek_Uint32[0];
PID.Ek_Uint32[0]=Temp[0];
/****************************************/
if（PID.Ek_Uint32[0]>PID.Ek_Uint32[1]）//E（k）>E（k-1）否？
{
Temp[0]=PID.Ek_Uint32[0]-PID.Ek_Uint32[1];//E（k）>E（k-1）
PID.EkFlag_Uint8[0]=0;}//E（k）-E（k-1）为正数
else
{
Temp[0]=PID.Ek_Uint32[0]-PID.Ek_Uint32[1];//E（k）PID.EkFlag_Uint8[0]=1;}//E（k）-E（k-1）为负
数
/****************************************/
Temp[2]=PID.Ek_Uint32[1]*2;//2E（k-1）
if（（PID.Ek_Uint32[0]+PID.Ek_Uint32[2]）>Temp[2]）//E（k-
2）+E（k）>2E（k-1）否？
{
Temp[2]=（PID.Ek_Uint32[0]+PID.Ek_Uint32[2]）-Temp[2];//E（k-
2）+E（k）>2E（k-1）
PID.EkFlag_Uint8[2]=0;}//E（k-2）+E（k）-2E（k-
1）为正数
else
{
Temp[2]=Temp[2]-（PID.Ek_Uint32[0]+PID.Ek_Uint32[2]）;//E（k-
2）+E（k）<2E（k-1）
PID.EkFlag_Uint8[2]=1;}//E（k-2）+E（k）-2E（k-1）为
负数
/****************************************/
Temp[0]=（uint32）PID.KP_Uint8*Temp[0];//KP*[E（k）-E（k-1）]
Temp[1]=（uint32）PID.KI_Uint8*PID.Ek_Uint32[0];//KI*E（k）
Temp[2]=（uint32）PID.KD_Uint8*Temp[2];//KD*[E（k-2）+E（k）-
2E（k-1）]
/*以下部分代码是讲所有的正数项叠加，负数项叠加*/
/**********KP*[E（k）-E（k-1）]**********/
if（PID.EkFlag_Uint8[0]==0）
PostSum+=Temp[0];//正数和
else
NegSum+=Temp[0];//负数和
/*********KI*E（k）****************/
if（PID.EkFlag_Uint8[1]==0）
PostSum+=Temp[1];//正数和
else
;//空操作，E（K）>0
/****KD*[E（k-2）+E（k）-2E（k-1）]****/
if（PID.EkFlag_Uint8[2]==0）
PostSum+=Temp[2];//正数和
else
NegSum+=Temp[2];//负数和
/***************U（K）***************/
PostSum+=（uint32）PID.Uk_Uint16;
if（PostSum>NegSum）//是否控制量为正数
{
Temp[0]=PostSum-NegSum;
if（Temp[0]<100）//小于上限幅值则为计算值输出
PID.Uk_Uint16=（uint16）Temp[0];
else
PID.Uk_Uint16=100;//否则为上限幅值输出
}
else//控制量输出为负数，则输出0（下限幅值输出）
PID.Uk_Uint16=0;
}
}
else
{
PID.Uk_Uint16=0;
}
}
14.FFT变换算法
一、思想：
FFT变换算法的基本思想：
利用WN的周期性和对称性，把一个N项序列
（设N=2k,k为正整数），分为两个N/2项的子序列，每个N/2点DFT变换需要（N/2）
^2次运算，再用N次运算把两个N/2点的DFT变换组合成一个N点的DFT变换。
这
样变换以后，总的运算次数就变成N+2（N/2）2=N+N^2/2。
二、模块程序
#include
typedefstruct
{
doubler;
doublei;
}my_complex;
//检查a是否为2的整数次方数
#defineNOT2POW（a）（（（a）-1）&（a）||（a）<=0）
#defineMYPI3.14159265358979323846//pi
my_complex*fft（constmy_complex*x,unsignedintlen）
{
unsignedintex=0,t=len;
unsignedinti,j,k;
my_complex*y;
doubletr,ti,rr,ri,yr,yi;
if（NOT2POW（len））returnNULL;//如果失败，迒回空指针
for（;!
（t&1）;t>>=1）ex++;//len应该等于2的ex次方
y=（my_complex*）malloc（len*sizeof（my_complex））;
if（!
y）returnNULL;//变址计算，库里-图基算法
for（i=0;iwhile（（t--）>0）{j<<=1;j|=k&1;k>>=1;}
if（j>=i）{y[i]=x[j];y[j]=x[i];}
}//用变址后的y向量进行计算
for（i=0;ifor（j=0;j{ti=-MYPI*k/t;rr=cos（ti）;ri=sin（ti）;
tr=y[j+k+t].r;ti=y[j+k+t].i;
yr=rr*tr-ri*ti;yi=rr*ti+ri*tr;
tr=y[j+k].r;ti=y[j+k].i;
y[j+k].r=tr+yr;y[j+k].i=ti+yi;
y[j+k+t].r=tr-yr;y[j+k+t].i=ti-yi;}}}
returny;
}//以下为测试
intmain（）
{
inti,DATA_LEN;
my_complex*x,*y;
printf（"基二FFT测试\n输入生成序列长度:
"）;
scanf（"%d",&DATA_LEN）;
x=（my_complex*）malloc（DATA_LEN*sizeof（my_complex））;
for（i=0;iprintf（"处理前...\n实部\t\t虚部\n"）;
for（i=0;iprintf（"%lf\t%lf\n",x[i].r,
升级会员 