打印
[技术问答]

8位单片机实现FFT

[复制链接]
559|7
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
jonas222|  楼主 | 2023-7-28 20:00 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
#include <math.h>
#include "OLED.h"
#define FFT_N 64                                                   //定义福利叶变换的点数
#define PI 3.1415926535897932384626433832795028841971               //定义圆周率值
#define Process_sensitivity        0                                                                                //修改Process_sensitivity的数值个调整频谱变化幅度,不建议超过4
unsigned char tmrcnt=0;
float ADC_OutBuf[FFT_N/4];
struct compx ADC_InBuf[FFT_N];                                      //FFT输入和输出:从S[0]开始存放,根据大小自己定义
float SIN_TAB[FFT_N/4+1];                                           //定义正弦表的存放空间
struct compx {float real,imag;};

struct compx EE(struct compx a,struct compx b)      
{
struct compx c;
c.real=a.real*b.real-a.imag*b.imag;
c.imag=a.real*b.imag+a.imag*b.real;
return(c);
}

void create_sin_tab(float *sin_t)                     
{
  int i;
  for(i=0;i<=FFT_N/4;i++)
  sin_t[i]=sin(2*PI*i/FFT_N);
}

float sin_tab(float pi)
{
  int n;
  float a=0;
   n=(int)(pi*FFT_N/2/PI);
   
  if(n>=0&&n<=FFT_N/4)
    a=SIN_TAB[n];
  else if(n>FFT_N/4&&n<FFT_N/2)
    {
     n-=FFT_N/4;
     a=SIN_TAB[FFT_N/4-n];
    }
  else if(n>=FFT_N/2&&n<3*FFT_N/4)
    {
     n-=FFT_N/2;
     a=-SIN_TAB[n];
   }
  else if(n>=3*FFT_N/4&&n<3*FFT_N)
    {
     n=FFT_N-n;
     a=-SIN_TAB[n];
   }
  
  return a;
}

float cos_tab(float pi)
{
   float a,pi2;
   pi2=pi+PI/2;
   if(pi2>2*PI)
     pi2-=2*PI;
   a=sin_tab(pi2);
   return a;
}

void FFT(struct compx *xin)
{
  register int f,m,nv2,nm1,i,k,l,j=0;
  struct compx u,w,t;
   
   nv2=FFT_N/2;                  //变址运算,即把自然顺序变成倒位序,采用雷德算法
   nm1=FFT_N-1;  
   for(i=0;i<nm1;i++)        
   {
    if(i<j)                    //如果i<j,即进行变址
     {
      t=xin[j];           
      xin[j]=xin[i];
      xin[i]=t;
     }
    k=nv2;                    //求j的下一个倒位序
    while(k<=j)               //如果k<=j,表示j的最高位为1   
     {           
      j=j-k;                 //把最高位变成0
      k=k/2;                 //k/2,比较次高位,依次类推,逐个比较,直到某个位为0
     }
   j=j+k;                   //把0改为1
  }
                        
  {
   int le,lei,ip;                            //FFT运算核,使用蝶形运算完成FFT运算
    f=FFT_N;
   for(l=1;(f=f/2)!=1;l++)                  //计算l的值,即计算蝶形级数
           ;
  for(m=1;m<=l;m++)                         // 控制蝶形结级数
   {                                        //m表示第m级蝶形,l为蝶形级总数l=log(2)N
    le=2<<(m-1);                            //le蝶形结距离,即第m级蝶形的蝶形结相距le点
    lei=le/2;                               //同一蝶形结中参加运算的两点的距离
    u.real=1.0;                             //u为蝶形结运算系数,初始值为1
    u.imag=0.0;
    w.real=cos_tab(PI/lei);                //w为系数商,即当前系数与前一个系数的商
    w.imag=-sin_tab(PI/lei);
    for(j=0;j<=lei-1;j++)                  //控制计算不同种蝶形结,即计算系数不同的蝶形结
     {
      for(i=j;i<=FFT_N-1;i=i+le)           //控制同一蝶形结运算,即计算系数相同蝶形结
       {
        ip=i+lei;                          //i,ip分别表示参加蝶形运算的两个节点
        t=EE(xin[ip],u);                   //蝶形运算,详见公式
        xin[ip].real=xin[i].real-t.real;
        xin[ip].imag=xin[i].imag-t.imag;
        xin[i].real=xin[i].real+t.real;
        xin[i].imag=xin[i].imag+t.imag;
       }
      u=EE(u,w);                          //改变系数,进行下一个蝶形运算
     }
   }
  }
  
}
void Timer0Init(void)                //1毫秒@24.000MHz
{
        AUXR |= 0x80;                //定时器时钟1T模式
        TMOD &= 0xF0;                //设置定时器模式
        TL0 = 0x40;                //设置定时初值
        TH0 = 0xA2;                //设置定时初值
        TF0 = 0;                //清除TF0标志
        TR0 = 1;                //定时器0开始计时
        ET0 = 1;
}
void Delay(unsigned short n)
{
    unsigned short x;

    while (n--)
    {
        x = 5000;
        while (x--);
    }
}
void InitADC()
{
    P1ASF = 0xff;                   //设置P1口为AD口
    ADC_CONTR =0x80|0x60;
    Delay(2);                       //ADC上电并延时
}
unsigned short GetADCResult(unsigned char ch)//ch为输入端口
{
        ADC_RES = 0;
        ADC_RESL = 0;
    ADC_CONTR =0x80|0x60|ch|0x08;
    _nop_();                        
    _nop_();
    _nop_();
    _nop_();
    while (!(ADC_CONTR & 0x10));
    ADC_CONTR &= ~0x10;         
    return ((unsigned short)(ADC_RES<<2)+ADC_RESL);
}
void processfft(void)
{
        unsigned char data pt=0,i,high,x,temp,p,j;
        for(pt=0;pt<(FFT_N);pt++)
        {
                ADC_InBuf[pt].imag=0;
        }

        FFT(ADC_InBuf);

        for(pt=2,i=0;pt<(FFT_N/2+1);pt+=2)
        {
                ADC_OutBuf[i++] = sqrt(ADC_InBuf[pt].real*ADC_InBuf[pt].real+ADC_InBuf[pt].imag*ADC_InBuf[pt].imag);
        }

        for(i=0;i<(FFT_N/4);i++)
        {
                high=(((unsigned char)ADC_OutBuf[i])>>Process_sensitivity);//修改Process_sensitivity的数值个调整频谱变化幅度,不建议超过4
                for(x=0;x<8;x++)
                {
                        OLED_SetPos(i*8,7-x);
                        temp=0x00;
                        for(j=0;j<8;j++)
                        {
                                OLED_WriteData(temp);
                        }
                }
                if(high>64)high=64;
                if(high==0)high=1;
                p=high/8;
                for(x=0;x<p;x++)
                {
                        OLED_SetPos(i*8,7-x);
                        temp=0xff;
                        for(j=0;j<7;j++)
                        {
                                OLED_WriteData(temp);
                        }
                }
                OLED_SetPos(i*8,7-(high/8));
                temp=~0xff>>(high%8);
                for(j=0;j<7;j++)
                {
                        OLED_WriteData(temp);
                }
        }
}
void main()
{
        unsigned char i;
        P0M1=0x00;
        P0M0=0x00;
        P1M1=0xc0; //设定AD输入为P16/P17,实际只用了P16
        P1M0=0x00;
        EA=1;
        Oled_Init();
        Timer0Init();
        InitADC();
        create_sin_tab(SIN_TAB);
        while(1)
        {
                if(tmrcnt>=70)
                {
                        P55=1;
                        for(i=0;i<(FFT_N);i++)
                        {  
                                ADC_InBuf[i].real=((GetADCResult(6))<<Process_sensitivity);//修改Process_sensitivity的数值个调整频谱变化幅度,不建议超过4
                        }
                        
                        processfft();
                        P55=0;
                        tmrcnt=0;
                }
        }
}
void Time0() interrupt 1
{
        tmrcnt++;
}


使用特权

评论回复
沙发
tpgf| | 2023-8-10 16:28 | 只看该作者
8位单片机实现fft是不是需要对算法进行精简啊

使用特权

评论回复
板凳
八层楼| | 2023-8-10 17:19 | 只看该作者
如果想要实现fft的话 对单片机的最低要求是什么

使用特权

评论回复
地板
观海| | 2023-8-10 17:38 | 只看该作者
FFT是离散傅氏变换的快速算法,它是根据离散傅氏变换的奇、偶、虚、实等特性,对离散傅立叶变换的算法进行改进获得的.

使用特权

评论回复
5
guanjiaer| | 2023-8-10 17:58 | 只看该作者
点数越多,运算量的节约就越大,这就是FFT的优越性

使用特权

评论回复
6
heimaojingzhang| | 2023-8-10 18:18 | 只看该作者
fft计算的深度有上限吗 大概是多少啊

使用特权

评论回复
7
keaibukelian| | 2023-8-11 08:59 | 只看该作者
感觉fft的算法真是挺复杂的 根本看不懂啊

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

23

主题

1355

帖子

0

粉丝