fft.c

FFT子程序

#include "config.h"

#ifndef STAGE
#define STAGE 7
#ifndef LENGTH
#define LENGTH 128
#ifndef RESULT_NUM
#define RESULT_NUM 8
 
 
 
unsigned int Adjust[LENGTH]={
                         0,  64,  32,   96,  16,  80,  48,  112,  
                         8,  72,  40,  104,  24,  88,  56,  120,  
                         4,  68,  36,  100,  20,  84,  52,  116,  
                        12,  76,  44,  108,  28,  92,  60,  124,  
                         2,  66,  34,   98,  18,  82,  50,  114,  
                        10,  74,  42,  106,  26,  90,  58,  122,  
                         6,  70,  38,  102,  22,  86,  54,  118,  
                        14,  78,  46,  110,  30,  94,  62,  126,  
                         1,  65,  33,   97,  17,  81,  49,  113,  
                         9,  73,  41,  105,  25,  89,  57,  121,  
                         5,  69,  37,  101,  21,  85,  53,  117,  
                        13,  77,  45,  109,  29,  93,  61,  125,  
                         3,  67,  35,   99,  19,  83,  51,  115,  
                        11,  75,  43,  107,  27,  91,  59,  123,  
                         7,  71,  39,  103,  23,  87,  55,  119,  
                        15,  79,  47,  111,  31,  95,  63,  127
                        }; 
                
/*****************************
 * FFT计算分级计算
 * 
 * STAGE    ：级数
 * LENGTH   ：数据长度
 * AdjustR[]：排序
 * x[]      ：存放采样值
 * dataR[]  ：存放结果的实部
 * dataI[]  ：存放结果的虚部
 *
 * group   ：每级的组数
 * num     ：每组的数据个数
 * half_num：蝶形节点距
 * 
 * w       ：旋转因子的幂
 * wR      ：旋转因子实部
 * wI      ：旋转因子虚部
 * 
 * tempMultipyR;第二位数字与旋转因子复数相乘得实部
 * tempMultipyI;第二位数字与旋转因子复数相乘得虚部
 * tempdataR   ;第一位数字与第二位数与旋转因子复数相乘结果相加——实部
 * tempdataI   ;第一位数字与第二位数与旋转因子复数相乘结果相减——虚部
 * 
 * ***************************/
unsigned int *FFT(float dataR[LENGTH],float dataI[LENGTH],unsigned int stage)
{
        unsigned int i=0; //for语句的局部变量
        unsigned int j=0; //for语句的局部变量
        unsigned int k=0; //for语句的局部变量
        unsigned int l=0; //for语句的局部变量
        
        unsigned int num;
        unsigned int half_num;
        unsigned int group;
        unsigned int w;
        
        
        unsigned int index1;
        unsigned int index2;
       
        float wR;
        float wI;
        float tempMultipyR;
        float tempMultipyI;
        float tempdataR;
        float tempdataI; 
        float breadth[RESULT_NUM];
        
        stage=STAGE;
        
        for(;i<stage+1;i++)
        {      
                num=1<<i;
                half_num=num>>1;
                group=LENGTH/num;
        


                for(;j<group;j++)
                {
                        for(;k<half_num;k++)
                        {
                                index1=j*LENGTH+k;//第一位数字坐标
                                index2=index1+half_num;//第二位数字坐标:index1加上蝶形节点距离
                        
                                w=k*LENGTH/(half_num*2);//旋转因子
                                wR=cos(2*PI*w/LENGTH);
                                wI=sin(2*PI*w/LENGTH);
                        
                                tempMultipyR=(dataR[index2]*wR-dataI[index2]*wI);//第二位数字与旋转因子复数相乘得实部
                                tempMultipyI=(dataR[index2]*wI+dataI[index2]*wR);//第二位数字与旋转因子复数相乘得虚部
                        
                                tempdataR=dataR[index2]+tempMultipyR;//第一位数字与第二位数与旋转因子复数相乘结果相加——实部
                                tempdataI=dataI[index2]+tempMultipyI;//第一位数字与第二位数与旋转因子复数相乘结果相加——虚部
                                                
                                dataR[index2]=dataR[index1]-tempMultipyR;//第一位数字与第二位数与旋转因子复数相乘结果相减——实部
                                dataI[index2]=dataI[index1]-tempMultipyI;//第一位数字与第二位数与旋转因子复数相乘结果相减——虚部
                                dataR[index1]=tempdataR;//赋值给dataR[index1]
                                dataI[index1]=tempdataI;//赋值给dataI[index1]
                        }                
                } 
        }
        for(;l<RESULT_NUM;l++)
        {
        float temp;
        temp=dataR[l]*dataR[l]+dataI[l]*dataI[l];
        temp=sqrt(temp);
        temp=breadth[l];
        }
        return breadth;
}

/********************************
* 生成数据
* ********************************/

void CreateData(unsigned int AdjustR[LENGTH],float dataR[LENGTH])
{
        unsigned int i = 0;
        unsigned int j = 0;
        float x[LENGTH]={0};
        for (; j < 128; i++)
        {
                float tempx1=0;
                float tempx2=0;
                for (; j < 5; j++)
                {
                tempx1 = 10 * sin(2 * PI * i * j / 128) ;
                tempx2 = tempx1/j + tempx2;         
                }
                x[i] = tempx2;
                }
        i=0;
        for (; i < LENGTH; i++)
        {
                AdjustR[i] = AdjustR[i] / 2;
                dataR[i] = x[AdjustR[i]];
        }
}