— 文首预览 —

定点DSP有限的动态范围导致在计算FFT时精度不够。这是因为使用了量化和缩放来防止输出溢出。因此，会需要使用扩展精度来执行计算，特别是对于大尺寸的FFT。高度优化的扩展精度的FFT和IFFT汇编程序，可以在TMS320C62X上，通过适度增加运行时间来提高运算精度。

目录：

1.    快速傅立叶变换FFT
2.    快速傅立叶反变换IFFT
3.    精度扩展的需要
4.    C62x上的扩展精度乘法
5.    FFT的实现
6.     IFFT的实现
7.    比例缩放问题
8.    误差估计
9.    基准（Benchmarks）
10.    输出位反转
11.    代码
12.    参考文档

注：本人E文极差，请慎重考虑是否要下载全文！

全文下载地址

环境：CCS 3.1 + C6201 Device Simulator

仿真结果如下图：

全部代码在下面，为了描述简单，把所有函数写在了一起，实际运用中不应该这样做。另外位反转索引表和旋转因子表都是在里面实时生成的，实际运用时，应该做好表格后嵌入，或在编译时生成而不是运行时生成。

感谢 pacificxu 的教程，他貌似曾经是闻亭的高手。

#include “math.h”
/*========================================*/
/* GLOBAL CONSTANTS                                                          */
/*========================================*/

#define PI    3.14159265358979
#define N        2048

/*========================================*/
/* GLOBAL VARIABLES                                                          */
/*========================================*/
static short index1[64], w1[N];
static short x1[N*2];
static int x2[N];
int i;

void DSP_radix2(int n, short *restrict xy, const short *restrict w)
{
short n1,n2,ie,ia,i,j,k,l;
short xt,yt,c,s;
n2 = n;
ie = 1;
for (k=n; k > 1; k = (k >> 1) )
{
n1 = n2;
n2 = n2>>1;
ia = 0;
for (j=0; j < n2; j++)
{
c = w[2*ia];
s = w[2*ia+1];
ia = ia + ie;
for (i=j; i < n; i += n1)
{
l = i + n2;
xt      = xy[2*l] – xy[2*i];
xy[2*i] = xy[2*i] + xy[2*l];
yt      = xy[2*l+1] – xy[2*i+1];
xy[2*i+1] = xy[2*i+1] + xy[2*l+1];
xy[2*l]   = (c*xt + s*yt)>>15;
xy[2*l+1] = (c*yt – s*xt)>>15;
}
}
ie = ie<<1;
}
}
void DSP_bitrev_cplx(int *x, short *index, int nx)
{
int     i;
short       i0, i1, i3;
short       j0, j1, j3;
int     xi0, xi1, xi3;
int     xj0, xj1, xj3;
short       t;
int     a, b, ia, ib, ibs;
int     mask;
int     nbits, nbot, ntop, ndiff, n2, halfn;
nbits = 0;
i = nx;
while (i > 1)
{
i = i >> 1;
nbits++;
}

nbot    = nbits >> 1;
ndiff   = nbits & 1;
ntop    = nbot + ndiff;
n2      = 1 << ntop;
mask    = n2 – 1;
halfn   = nx >> 1;
for (i0 = 0; i0 < halfn; i0 += 2)
{
b   = i0 & mask;
a   = i0 >> nbot;
if (!b) ia  = index[a];
ib  = index[b];
ibs = ib << nbot;
j0  = ibs + ia;
t   = i0 < j0;
xi0 = x[i0];
xj0 = x[j0];

if (t){x[i0] = xj0;
x[j0] = xi0;}

i1  = i0 + 1;
j1  = j0 + halfn;
xi1 = x[i1];
xj1 = x[j1];
x[i1] = xj1;
x[j1] = xi1;

i3  = i1 + halfn;
j3  = j1 + 1;
xi3 = x[i3];
xj3 = x[j3];
if (t){x[i3] = xj3;
x[j3] = xi3;}
}
}
void bitrev_index(short *index, int n)
{
int   i, j, k, radix = 2;
short nbits, nbot, ntop, ndiff, n2, raddiv2;
nbits = 0;
i = n;
while (i > 1)
{
i = i >> 1;
nbits++;
}
raddiv2 = radix >> 1;
nbot    = nbits >> raddiv2;
nbot    = nbot << raddiv2 – 1;
ndiff   = nbits & raddiv2;
ntop    = nbot + ndiff;
n2      = 1 << ntop;
index[0] = 0;
for ( i = 1, j = n2/radix + 1; i < n2 – 1; i++)
{
index[i] = j – 1;
for (k = n2/radix; k*(radix-1) < j; k /= radix)
j -= k*(radix-1);
j += k;
}
index[n2 - 1] = n2 – 1;
}
/*===================================*/
/* MAIN()                                                                    */
/*===================================*/
void main()

{
double delta;

/*======== init the index table for FFT bitrev =====*/

bitrev_index(index1, N);

/*======== init the FFT coeficients =====*/
delta = 2*PI/N;
for (i=0;i<N/2;i++)
{
w1[2*i] = 32767*(-cos((double)i*delta));
w1[2*i+1] = 32767*(-sin((double)i*delta));
}

/*======== init the input data =====*/
for (i=0;i<N;i++)
{
x1[2*i] = (short)((cos(PI*i/20.0)+cos(PI*i/10.0)+cos(PI*i/5.0))*0×80);
x1[2*i+1] = 0;
}
/*======== implement FFT =====*/

DSP_radix2(N, x1, w1);
for (i=0; i<N; i++)
{
x2[i] = sqrt(x1[2*i]*x1[2*i]+x1[2*i+1]*x1[2*i+1]);  //—?
}

/*======== bitrev =====*/

DSP_bitrev_cplx(x2, index1, N);
}

注意：对于C620X/670X来说，EMIF支持32bit宽度的ASRAM、SDRAM和SBSRAM，只有CE1空间支持16bit和8bit的ROM接口。

遗留问题，为什么会有4位BE(BE3:0)，如何使用？

In the following example, the loop waits for a location to be read as 0xFF:

unsigned int *ctrl;
while (*ctrl !=0xFF);

In this example, *ctrl is a loop-invariant expression, so the loop is optimized down to a single memory read. To correct this, define *ctrl as:

volatile unsigned int *ctrl;

Here the *ctrl pointer is intended to reference a hardware location, such as an interrupt flag.

来自软工吧论坛
volatile 提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有 volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。下面举例说 明。

在DSP开发中，经常需要等待某个事件的触发，所以经常会写出这样的程序：
以下内容为程序代码:
short flag;
void test()
{
do1();
while(flag==0);
do2();
}

这段程序等待内存变量flag的值变为1之后才运行do2()。变量 flag的值由别的程序更改，这个程序可能是某个硬件中断服务程序，例如如果某个按钮按下的话，就会对DSP产生中断，在按键中断程序中修改flag为 1，这样上面的程序就能够得以继续运行。

但 是，编译器并不知道flag的值会被别的程序修改，因此在它进行优化的时候，可能会把flag的值先读入某个寄存器，然后等待那个寄存器变为 1。如果不幸进行了这样的优化，那么while循环就变成了死循环，因为寄存器的内容不可能被中断服务程序修改。为了让程序每次都读取真正flag变量的 值，就需要定义为如下形式：

volatile short flag;

需要注意的是，没有volatile也可能能正常 运行，但是可能修改了编译器的优化级别之后就又不能正常运行了。因此经常会出现debug版本正常，但是release版本却不能正常的问题。所以为了安 全起见，只要是等待别的程序修改某个变量的话，就加上volatile关键字。

㈠ – 无引导：CPU直接从地址0处开始执行代码。

㈡ – ROM引导，加载过程：
①当CPU的Reset引脚处于低电平状态时，BOOTMODE的引脚状态根据预设设定， RESET信号处于上升沿的时候，相应加载方式启动。

②ROM加载方式是通过DMA控制器，将外部ROM的一段固定大小的代码复制到内部RAM中（加载时CPU处于stall状态），对于不同型号芯片，复制的代码大小不同。
对于C620x/C670x，DMA从CE1空间拷贝64K数据到地址0处
对于C621x/C671x/C64x，EDMA从CE1空间拷贝1K数据到地址0处。

③加载完毕后，CPU开始从0地址执行。
对于上述步骤②的第二种（C621x/C671x/C64x），1K是不能解决问题的，所以，一般在0地址处建立一个叫做“bootloader”的段（代码小于1KB），这一小段程序也叫 “引导程序”，上电或者重启后首先执行它，完成将其余程序（真正完成用户要求算法的程序）加载，然后跳转到主程序入口地址运行。

㈢ – 主机引导：
对具有不同接口的芯片，分别有以下三种渠道连接：
HPI
XBUS
PCI

关于bootloader的疑问：
bootloader文件如果加入的输出文件中？

参考文档：spru642_TMS320C620xC670x DSP Boot Modes and Configuration Reference Guide.pdf