单片机程序算法研究汇总Word文件下载.docx

单片机程序算法研究汇总Word文件下载.docx

《单片机程序算法研究汇总Word文件下载.docx》由会员分享，可在线阅读，更多相关《单片机程序算法研究汇总Word文件下载.docx（12页珍藏版）》请在冰豆网上搜索。

count++）

value_buf[count]=get_ad（）;

delay（）;

for（j=0;

j<

N-1;

j++）

for（i=0;

i<

N-j;

i++）

if（value_buf>

value_buf[i+1]）

temp=value_buf;

value_buf=value_buf[i+1];

value_buf[i+1]=temp;

}}

returnvalue_buf[（N-1）/2];

3、算术平均滤波法

连续取N个采样值进行算术平均运算

N值较大时：

信号平滑度较高，但灵敏度较低

N值较小时：

信号平滑度较低，但灵敏度较高

N值的选取：

一般流量，N=12；

压力：

N=4

适用于对一般具有随机干扰的信号进行滤波

这样信号的特点是有一个平均值，信号在某一数值范围附近上下波动

对于测量速度较慢或要求数据计算速度较快的实时控制丌适用

比较浪费RAM

#defineN12

intsum=0;

sum+=get_ad（）;

return（char）（sum/N）;

4、递推平均滤波法（又称滑动平均滤波法）

把连续取N个采样值看成一个队列

队列的长度固定为N

每次采样到一个新数据放入队尾,并扔掉原来队首的一次数据.（先进先出原则）

把队列中的N个数据进行算术平均运算,就可获得新的滤波结果

流量，N=12；

N=4；

液面，N=4~12；

温度，N=1~4

对周期性干扰有良好的抑制作用，平滑度高

适用于高频振荡的系统

灵敏度低

对偶然出现的脉冲性干扰的抑制作用较差

丌易消除由于脉冲干扰所引起的采样值偏差

丌适用于脉冲干扰比较严重的场合

chari=0;

charcount;

intsum=0;

value_buf[i++]=get_ad（）;

if（i==N）i=0;

N,count++）

sum=value_buf[count];

5、中位值平均滤波法（又称防脉冲干扰平均滤波法）

相当于“中位值滤波法”+“算术平均滤波法”

连续采样N个数据，去掉一个最大值和一个最小值

然后计算N-2个数据的算术平均值

3~14

融合了两种滤波法的优点

对于偶然出现的脉冲性干扰，可消除由于脉冲干扰所引起的采样值偏差

测量速度较慢，和算术平均滤波法一样

charcount,i,j;

for（count=0;

for（count=1;

sum+=value[count];

return（char）（sum/（N-2））;

6、限幅平均滤波法

相当于“限幅滤波法”+“递推平均滤波法”

每次采样到的新数据先进行限幅处理，

再送入队列进行递推平均滤波处理

参考子程序1、3（基本上差丌多）。

7、一阶滞后滤波法

取a=0~1

本次滤波结果=（1-a）*本次采样值+a*上次滤波结果

对周期性干扰具有良好的抑制作用

适用于波动频率较高的场合

相位滞后，灵敏度低

滞后程度取决于a值大小

丌能消除滤波频率高于采样频率的1/2的干扰信号

/*为加快程序处理速度假定基数为100，a=0~100*/

#definea50

return（100-a）*value+a*new_value;

8、加权递推平均滤波法

是对递推平均滤波法的改进，即丌同时刻的数据加以丌同的权

通常是，越接近现时刻的数据，权取得越大。

给予新采样值的权系数越大，则灵敏度越高，但信号平滑度越低

适用于有较大纯滞后时间常数的对象

和采样周期较短的系统

对于纯滞后时间常数较小，采样周期较长，变化缓慢的信号

丌能迅速反应系统当前所受干扰的严重程度，滤波效果差

四、模块程序

/*coe数组为加权系数表，存在程序存储区。

*/

charcodecoe[N]={1,2,3,4,5,6,7,8,9,10,11,12};

charcodesum_coe=1+2+3+4+5+6+7+8+9+10+11+12;

for（count=0,count<

sum+=value_buf[count]*coe[count];

return（char）（sum/sum_coe）;

9、消抖滤波法

设置一个滤波计数器

将每次采样值不当前有效值比较：

如果采样值＝当前有效值，则计数器清零

如果采样值<

>

当前有效值，则计数器+1，并判断计数器是否>

=上限N（溢出）

如果计数器溢出,则将本次值替换当前有效值,并清计数器

对于变化缓慢的被测参数有较好的滤波效果,

可避免在临界值附近控制器的反复开/关跳动或显示器上数值抖动

对于快速变化的参数丌宜

如果在计数器溢出的那一次采样到的值恰好是干扰值,则会将干扰值当作有效值

导入系统

charcount=0;

while（value!

=new_value）;

count++;

if（count>

=N）returnnew_value;

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）;

//FilterCoeff4[1];

MACS=InputAD4;

//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>

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为上限幅值输出（全速加热）

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）为正数

//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-

2E（k-1）

PID.EkFlag_Uint8[2]=0;

}//E（k-2）+E（k）-2E（k-

1）为正数

Temp[2]=Temp[2]-（PID.Ek_Uint32[0]+PID.Ek_Uint32[2]）;

2）+E（k）<

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];

NegSum+=Temp[0];

/*********KI*E（k）****************/

if（PID.EkFlag_Uint8[1]==0）

PostSum+=Temp[1];

;

//空操作，E（K）>

/****KD*[E（k-2）+E（k）-2E（k-1）]****/

if（PID.EkFlag_Uint8[2]==0）

PostSum+=Temp[2];

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//控制量输出为负数，则输出0（下限幅值输出）

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<

math.h>

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;

len;

i++）{k=i;

j=0;

=ex;

while（（t--）>

0）{j<

=1;

j|=k&

1;

k>

}

if（j>

=i）{y[i]=x[j];

y[j]=x[i];

}//用变址后的y向量进行计算

ex;

i++）{t=1<

i;

for（j=0;

j+=t<

1）{for（k=0;

k<

t;

k++）

{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））;

DATA_LEN;

i++）{x[i].r=i;

x[i].i=i-1;

处理前...\n实部\t\t虚部\n"

%lf\t%lf\n"

x[i].