YY分享

利用CCS4软件来创建FFT工程，实现DSP28335中的信号处理程序风仿真、下载等操作。

1. 创建工程 

加载TI官方附带CCS工程例程，并修改主程序(见附录)，如图所示：

2. 添加配置

添加 .ccxml 文件为 F283x CPU Cycle… 并单击 Build 功能，然后进行 Debug，如下：

4. 配置输出文件

Tools ->Graph->Dual Time配置相应的输出文件，详细配置如下：

5. 运行仿真 

加载Load生成的.out文件，仿真输出波形如下图所示：

此时，通过给内部flash下载程序，开发板便可实现相应功能。

注：CCS3.3的程序在CCS4以上版本中编译，可能会出现未知错误，此时删除code_start便可，具体操作如下所示：

附工程代码：

#include "DSP2833x_Device.h"
#include "DSP2833x_Examples.h"
#include <math.h>

#define pi 3.141593

//NL为合成信号点数，与N的值必须是一致的，即NL=N
#define NL 256

//FFT点数
int N=NL;

// 定义复数结构体
struct Complex
{
    float real,imag;
};

//定义复乘
struct Complex MUL(struct Complex a,struct Complex b)
{
    struct Complex c;
    c.real=a.real*b.real-a.imag*b.imag;
    c.imag=a.real*b.imag+a.imag*b.real;
    return(c);
}

struct Complex Wn;  //定义旋转因子
struct Complex Vn;  //每一级第一个旋转因子虚部为0，实部为1
struct Complex T;   //存放旋转因子与X(k+B)的乘积

float Input[NL]; //输入的信号序列,NL必须满足2的m次幂
float output[NL]= {0};  // 输出的FFT幅值（复数的模）
struct Complex Sample[NL]; // 采样输入的实数转化为复数

//输入为复数指针*xin，做N点FFT
void MYFFT(struct Complex *xin,int N);
//振幅序列变换
void ModelComplex(struct Complex *Sample,int N,float *output);

void main(void)
{
    Uint16 i=0;
    InitSysCtrl();

    DINT;
    InitPieCtrl();
    IER = 0x0000;
    IFR = 0x0000;

    //1.产生正弦三次谐波叠加而成的方波
    for(i=0; i<NL; i++) //产生正弦三次谐波叠加而成的方波
    {
        Input[i]=sin(2*pi*(5*i/(NL-1)))+sin(2*pi*(5*3*i/(NL-1)))/3+sin(2*pi*(5*5*i/(NL-1)))/5;
    }

    //2.输入实数信号转换为复数
    for(i=0; i<NL; i++)
    {
        Sample[i].real=Input[i];  //实序列值
        Sample[i].imag=0;    //虚序列0
    }

    //3.计算FFT
    MYFFT(Sample,NL);

    //4.求模
    ModelComplex(Sample,NL,output);

    while(1) {}
}


//输入为复数指针*xin，做N点FFT
void MYFFT(struct Complex *xin,int N)
{
    int L=0;   // 级间运算层
    int J=0;   // 级内运算层
    int K=0,KB=0;     // 蝶形运算层
    int M=1,Nn=0; // N=2^M
    float B=0;  // 蝶形运算两输入数据间隔

    //以下是为倒序新建的局部变量
    int LH=0,J2=0,N1=0,I,K2=0;
    struct Complex T;

    //以下是倒序
    LH=N/2;
    J2=LH;
    N1=N-2;
    for(I=1; I<=N1; I++)
    {
        if(I=K2)
        {
            J2-=K2;
            K2=K2/2;// K2=K2/2
        }
        J2+=K2;
    }

    //计算出N的以2为底数的幂M
    Nn=N;
    while(Nn!=2)
    {
        M++;
        Nn=Nn/2;
    }

    //蝶形运算, 级间
    for(L=1; L<=M; L++) //级间
    {
        B=pow(2,(L-1));
        Vn.real=1;
        Vn.imag=0;
        Wn.real=cos(pi/B);
        Wn.imag=-sin(pi/B);
        //级内
        for(J=0; J<B; J++)
        {
            //蝶形因子运算
            for(K=J; K<N; K+=2*B)
            {
                KB=K+B;
                T=MUL(xin[KB],Vn);
                //原址运算，计算结果存放在原来的数组中
                xin[KB].real=xin[K].real-T.real;
                xin[KB].imag=xin[K].imag-T.imag;
                xin[K].real=xin[K].real+T.real;
                xin[K].imag=xin[K].imag+T.imag;
            }
            /* 旋转因子做复乘相当于指数相加，得到的结果,
               和J*2^（M-L）是一样的，因为在蝶形因子运算
               层中M与L都是不变的，唯一变x化的是级内的J
               而且J是以1为步长的，如J*W等效于W+W+W...J个W相加
            */
            Vn=MUL(Wn,Vn);
        }
    }
}

// 取模。形参：*Sample指向需要取模的复数结构体;N为取模点数; *output存放取模后数值的数组
void ModelComplex(struct Complex *Sample,int N,float *output)
{
    int i;
    for(i=0; i<N; i++)
    {
        //输出幅度，利用sqrt函数求解
        output[i]=sqrt(Sample[i].real*Sample[i].real+Sample[i].imag*Sample[i].imag)*2/N;
    }
}