DSP的特点

对于没有使用过DSP的初学者来说，第一个困惑就是DSP其他的嵌入式处理器究竟有什么不同，它和单片机，ARM有什么区别。事实上，DSP也是一种嵌入式处理器，它完全可以完成单片机的功能。
唯一的重要的区别在于DSP支持单时钟周期的“乘-加”运算。这几乎是所有厂家的DSP芯片的一个共特征。几乎所有的DSP处理器的指令集中都会有一条MAC指令，这条指令可以把两个操作数从RAM中取出相乘，然后加到一个累加器中，所有这些操作都在一个时钟周期内完成。拥有这样一条指令的处理器就具备了
DSP功能。
具有这条指令就称之为数字信号处理器的原因在于，所有的数字信号处理算法中最为常见的算术操作就是“乘-加”。这是因为数字信号处理中大量使用了内积，或称“点积”的运算。无论是FIR滤波，FFT，信号相关，数字混频，下变频。所有这些数字信号处理的运算经常是将输入信号与一个系数表或者与一个本地参考信号相乘然后积分（累加），这就表现为将两个向量（或称序列）进行点积，在编程上就变成将输入的采样放在一个循环buffer里，本地的系数表或参考信号也放在一个buffer里，然后使用两个指针指向这两个buffer。这样就可以在一个loop里面使用一个MAC指令将二者进行点积运算。这样的点积运算对与处理器来说是最快的，因为仅需一个始终周期就可以完成一次乘加。
了解DSP的这一特点后，当我们设计一个嵌入式系统时，首先要考虑处理器所实现的算法中是否有点积运算
，即是否要经常进行两个数组的乘加，（记住数字滤波，相关等都表现为两个数组的点积）如果有的话，每秒要做多少次，这样就能够决定是否采用DSP，采用多高性能的DSP了。

浮点与定点

浮点与定点也是经常是初学者困惑的问题，在选择DSP器件的时候，是采用浮点还是采用定点，如果用定点是16位还是32位？其实这个问题和你的算法所要求的信号的动态范围有关。
定点的计算不过是把一个数据当作整数来处理，通常AD采样来的都是整数，这个数相对于真实的模拟信号有一个刻度因子，大家都知道用一个16位的AD去采样一个0到5V的信号，那么AD输出的整数除以2^16再乘以5V就是对应的电压。在定点DSP中是直接对这个16位的采样进行处理，并不将它转换成以小数表示的电压，因为定点DSP无法以足够的精度表示一个小数，它只能对整数进行计算。
而浮点DSP的优势在于它可以把这个采样得到的整数转换成小数表示的电压，并不损失精度（这个小数用科学记数法来表示），原因在于科学记数法可以表示很大的动态范围的一个信号，以IEEE754浮点数为例，
单精度浮点格式： [31] 1位符号 [30-23]8位指数 [22-00]23位小数
这样的能表示的最小的数是+-2^-149,最大的数是+-（2-2^23)*2^127.动态范围为20*log(最大的数/最小的数）=1667.6dB 这样大的动态范围使得我们在编程的时候几乎不必考虑乘法和累加的溢出，而如果使用定点处理器编程，对计算结果进行舍入和移位则是家常便饭，这在一定程度上会损失是精度。原因在于定点处理处理的信号的动态范围有限，比如16位定点DSP，可以表示整数范围为1-65536，其动态范围为20*log(65536/1)=96dB.对于32定点DSP，动态范围为20*log(2^32/1)=192dB,远小于32位ieee浮点数的1667.6dB,但是，实际上192dB对绝大多数应用所处理的信号已经足够了。
由于AD转换器的位数限制，一般输入信号的动态范围都比较小，但在DSP的信号处理中，由于点积运算会使中间节点信号的动态范围增加，所以主要考虑信号处理流程中中间结果的动态范围，以及算法对中间结果的精度要求，来选择相应的DSP。另外就是浮点的DSP更易于编程，定点DSP编程中程序员要不断调整中间结果的P，Q值，实际就是不断对中间结果进行移位调整和舍入。

DSP与RTOS

TI的CCS提供BIOS，ADI的VDSP提供VDK，都是基于各自DSP的嵌入式多任务内核。DSP编程可以用单用C，也可以用汇编，或者二者结合，一般软件编译工具都提供了很好的支持。我不想在这里多说BIOS，VDK怎么用这在相应的文档里说的很详细。我想给初学者说说DSP的RTOS原理。用短短几段话说这个复杂的东西也是挑战！^_^

其实DSP的RTOS和基于其他处理器的通用RTOS没什么大的区别，现在几乎人人皆知的uCOSii也很容易移植到DSP上来，只要把寄存器保存与恢复部分和堆栈部分改改就可以。一般在用BIOS和VDK之前，先看看操作系统原理的书比较好。uCOS那本书也不错。
BIOS和VDK其实是一个RTOS内核函数集，DSP的应用程序会和这些函数连接成一个可执行文件。其实实现一个简单的多任务内核并不复杂，首先定义好内核的各种数据结构，然后写一个scheduler函数，功能是从所有就绪任务中（通过查找就绪任务队列或就绪任务表）找出优先级最高的任务，并恢复其执行。然后在此基础上写几个用于任务间通信的函数就可以了，比如event,message box,等等。
RTOS一般采用抢先式的任务调度方式，举例说当任务A等待的资源available的时候,DSP会执行一个任务调度函数scheduler,这个函数会检查当前任务是否比任务A优先级低，如果是的话，就会把它当前挂起，然后把任务A保存在堆栈里寄存器值全部pop到DSP处理器中(这就是所谓的任务现场恢复）。接着scheduler还会把从堆栈中取出任务A挂起时的程序执行的地址，pop到PC，使任务A继续执行。这样当前任务就被任务A抢先了。
使用RTOS之后，每个任务都会有一个主函数，这个函数的起始地址就是该任务的入口。一般每个任务的主函数里有一个死循环，这个循环使该任务周期地执行，完成一部分算法模块的功能，其实这个函数跟普通函数没任何区别，类似于C语言中的main函数。一个任务创建的时候，RTOS会把这个函数入口地址压入任务的堆栈中，好象这个函数（任务）刚发生过一次中断一样。一旦这个新创建任务的优先级在就绪队列中是最高的，RTOS就会从其堆栈中弹出其入口地址开始执行。
有一个疑问是，不使用RTOS，而是简单使用一个主循环在程序中调用各个函数模块，一样可以实现软件的调度执行。那么，这种常用的方法与使用RTOS相比有什么区别呢？其实，使用主循环的方法不过是一种没有优先级的顺序执行的调度策略而已。这种方法的缺点在于，主循环中调用的各个函数是顺序执行的，那么，即使是一个无关紧要的函数（比如闪烁一个LED），只要他不主动返回，也会一直执行直到结束，这时，如果发生一个重要的事件（比如DMA buffer full 中断)，就会得不到及时的响应和处理，只能等到那个闪烁LED的函数执行完毕。这样就使整个DSP处理的优先次序十分不合理。而在使用了RTOS之后，当一个重要的事件发生时，中断处理会进入RTOS，并调用scheduler,这时scheduler 会让处理这一事件的任务抢占DSP处理器（因为它的优先级高）。而哪个闪烁LED任务即使晚执行几毫秒都没任何影响。这样整个DSP的调度策略就十分合理。
RTOS要说的内容太多，我只能讲一下自己的一点体会吧

DSP与正（余）弦波

在DSP的应用中，我们经常要用到三角函数，或者合成一个正（余）弦波。这是因为我们喜欢把信号通过傅立叶变换映射到三角函数空间来理解信号的频率特性。信号处理的一些计算技巧都需要在DSP软件中进行三角函数计算。然而三角函数计算是非线性的计算，DSP并没有专门的指令来求一个数的正弦或余弦。于是我们需要用线性方法来近似求解。
一个直接的想法是用多项式拟合，这也正是大多数DSP C编译器提供正余弦库函数所采用的方法。其原理是把三角函数向函数空间{1，x,x^2,x^3....}上投影，从而获得一系列的系数，用这些系数就可以拟合出三角函数。比如，我们在[0，pi/2]区间上拟合sin,只需在matlab中输入以下命令：
x=0:0.05:pi/2;
p=polyfit(x,sin(x),5)
就得到5阶的多项式系数：
p =
0.00581052047605 0.00580963216172 -0.17193865685360
0.00209002716293 0.99969270087312 0.00000809543448
于是在[0，pi/2]区间上：
sin(x)= 0.00000809543448+0.99969270087312*x+ 0.00209002716293*x^2-0.17193865685360*x^3+
0.00580963216172*x^4+0.00581052047605*x^5
于是在DSP程序中，我们可以通过用乘加（MAC）指令计算这个多项式来近似求得sin(x)
当然如果用定点DSP还要把P这个多项式系数表用一定的Q值来改写成定点数。

这样的三角函数计算一般都需要几十个cycle 的开销。这对于某些场合是不能容忍的

另一种更快的方法是借助于查表，比如，我们将[0，pi/2]分成32个区间，每个区间长度就为pi/64,在每个区间上我们使用直线段拟合sin曲线，每个区间线段起点的正弦值和线段斜率事先算好，存在RAM里，这样就需要在在RAM里存储64个
常数：
32个起点的精确的正弦值（事先算好）： s[32]={0,sin(pi/64),sin(pi/32),sin(pi/16)....}
32个线段的斜率： f[32]={0.049,.....}
对于输入的每一个x,先根据其大小找到所在区间i，通常x用定点表示，一般取其高几位就是系数i了，然 后通过下式即可求出sin(x)：
sin(x)= s[i]*f[i]
这样一般只需几个CYCLE就可以算出正弦值，如果需要更高的精度，可以将区间分得更细，当然，也就需 要更多的RAM去存储常数表。
事实上，不仅三角函数，其他的各种非线性函数都是这样近似计算

布局:
总体思想：在符合产品电气以及机械结构要求的基础上考虑整体美观，在一个PCB板上，元件的布局要求要均衡，疏密有序。
1．印制板尺寸必须与加工图纸尺寸相符，符合PCB制造工艺要求，放置MARK点。
2．元件在二维、三维空间上有无冲突？
3．元件布局是否疏密有序，排列整齐？是否全部布完？
4．需经常更换的元件能否方便的更换？插件板插入设备是否方便？
5．热敏元件与发热元件之间是否有适当的距离？
6．调整可调元件是否方便？
7．在需要散热的地方，装了散热器没有？空气流是否通畅？
8．信号流程是否顺畅且互连最短？
9．插头、插座等与机械设计是否矛盾？
10．蜂鸣器远离柱形电感，避免干扰声音失真。
11．速度较快的器件如SRAM要尽量的离CPU近。
12．由相同电源供电的器件尽量放在一起。

布线：　　
1．走线要有合理的走向：如输入/输出，交流/直流，强/弱信号，高频/低频，高压/低压等...，它们的走向应该是呈线形的(或分离)，不得相互交融。其目的是防止相互干扰。最好的走向是按直线，但一般不易实现，避免环形走线。对于是直流，小信号，低电压PCB设计的要求可以低些。输入端与输出端的边线应避免相邻平行， 以免产生反射干扰。必要时应加地线隔离，两相邻层的布线要互相垂直，平行容易产生寄生耦合。
2．选择好接地点：一般情况下要求共点地，数字地与模拟地在电源输入电容处相连。
3．合理布置电源滤波/退耦电容：布置这些电容就应尽量靠近这些元部件，离得太远就没有作用了。在贴片器件的退耦电容最好在布在板子另一面的器件肚子位置，电源和地要先过电容，再进芯片。
4．线条有讲究：有条件做宽的线决不做细；高压及高频线应园滑，不得有尖锐的倒角，拐弯也不得采用直角，一般采用135度角。地线应尽量宽，最好使用大面积敷铜，这对接地点问题有相当大的改善。 设计中应尽量减少过线孔，减少并行的线条密度。
5．尽量加宽电源、地线宽度，最好是地线比电源线宽，它们的关系是：地线＞电源线＞号线。
6．数字电路与模拟电路的共地处理，现在有许多PCB不再是单一功能电路（数字或模拟电路），而是由数字电路和模拟电路混合构成的。因此在布线时就需要考虑它们之间互相干扰问题，特别是地线上的噪音干扰。
数字电路的频率高，模拟电路的敏感度强，对信号线来说，高频的信号线尽可能远离敏感的模拟电路器件，对地线来说，整个PCB对外界只有一个结点，所以必须在PCB内部进行处理数、模共地的问题，而在板内部数字地和模拟地实际上是分开的它们之间互不相连，只是在PCB与外界连接的接口处（如插头等）。数字地与模拟地有一点短接。
7．信号线布在电（地）层上
在多层印制板布线时，由于在信号线层没有布完的线剩下已经不多，再多加层数就会造成浪费也会给生产增加一定的工作量，成本也相应增加了，为解决这个矛盾，可以考虑在电（地）层上进行布线。首先应考虑用电源层，其次才是地层。因为最好是保留地层的完整性。
8．关键信号的处理，关键信号如时钟线应该进行包地处理，避免产生干扰，同时在晶振器件边做一个焊点使晶振外壳接地。
9．设计规则检查（DRC）
　　布线设计完成后，需认真检查布线设计是否符合设计者所制定的规则，同时也需确认所制定的规则是否符合印制板生产工艺的需求，一般检查有如下几个方面：
线与线，线与元件焊盘，线与贯通孔，元件焊盘与贯通孔，贯通孔与贯通孔之间的距离是否合理，是否满足生产要求。
　　电源线和地线的宽度是否合适，电源与地线之间是否紧耦合（低的波阻抗）？在PCB中是否还有能让地线加宽的地方。
　　对于关键的信号线是否采取了最佳措施，如长度最短，加保护线，输入线及输出线被明显地分开。
　　模拟电路和数字电路部分，是否有各自独立的地线。
　　后加在PCB中的图形（如图标、注标）是否会造成信号短路。
　　对一些不理想的线形进行修改。
    在PCB上是否加有工艺线？阻焊是否符合生产工艺的要求，阻焊尺寸是否合适，字符标志是否压在器件焊盘上，以免影响电装质量。
　　多层板中的电源地层的外框边缘是否缩小，如电源地层的铜箔露出板外容易造成短路。
10．关于EMC方面：
a．尽可能选用信号斜率较慢的器件，以降低信号所产生的高频成分。
b．注意高频器件摆放的位置，不要太靠近对外的连接器。
c．注意高速信号的阻抗匹配，走线层及其回流电流路径，以减少高频的反射与辐射。
d.在各器件的电源管脚放置足够与适当的去耦合电容以缓和电源层和地层上的噪声。特别注意电容的频率响应与温度的特性是否符合设计所需。
e电源层比地层内缩20H，H为电源层与地层之间的距离。
11．GERBER输出检查
检查输出的GERBER文件是否按层叠顺序要求输出，在CAM350里查看每一层数据以及DRILL表，同时注意特殊孔如方孔的输出。

总结体会，供参考：
1.要有合理的走向：如输入/输出，交流/直流，强/弱信号，高频/低频，高压/低压等...，它们的走向应该是呈线形的(或分离)，不得相互交融。其目的是防止相互干扰。最好的走向是按直线，但一般不易实现，最不利的走向是环形，所幸的是可以设隔离带来改善。对于是直流，小信号，低电压PCB设计的要求可以低些。所以“合理”是相对的。

2.选择好接地点：小小的接地点不知有多少工程技术人员对它做过多少论述，足见其重要性。一般情况下要求共点地，如：前向放大器的多条地线应汇合后再与干线地相连等等...。现实中，因受各种限制很难完全办到，但应尽力遵循。这个问题在实际中是相当灵活的。每个人都有自己的一套解决方案。如能针对具体的电路板来解释就容易理解。

3.合理布置电源滤波/退耦电容：一般在原理图中仅画出若干电源滤波/退耦电容，但未指出它们各自应接于何处。其实这些电容是为开关器件(门电路)或其它需要滤波/退耦的部件而设置的，布置这些电容就应尽量靠近这些元部件，离得太远就没有作用了。有趣的是，当电源滤波/退耦电容布置的合理时，接地点的问题就显得不那么明显。

4.线条有讲究：有条件做宽的线决不做细；高压及高频线应园滑，不得有尖锐的倒角，拐弯也不得采用直角。地线应尽量宽，最好使用大面积敷铜，这对接地点问题有相当大的改善。

5.有些问题虽然发生在后期制作中，但却是PCB设计中带来的，它们是：过线孔太多，沉铜工艺稍有不慎就会埋下隐患。所以，设计中应尽量减少过线孔。同向并行的线条密度太大，焊接时很容易连成一片。所以，线密度应视焊接工艺的水平来确定。焊点的距离太小，不利于人工焊接，只能以降低工效来解决焊接质量。否则将留下隐患。所以，焊点的最小距离的确定应综合考虑焊接人员的素质和工效。

焊盘或过线孔尺寸太小，或焊盘尺寸与钻孔尺寸配合不当。前者对人工钻孔不利，后者对数控钻孔不利。容易将焊盘钻成“c”形，重则钻掉焊盘。导线太细，而大面积的未布线区又没有设置敷铜，容易造成腐蚀不均匀。即当未布线区腐蚀完后，细导线很有可能腐蚀过头，或似断非断，或完全断。所以，设置敷铜的作用不仅仅是增大地线面积和抗干扰。以上诸多因素都会对电路板的质量和将来产品的可靠性大打折扣。

C语言测试是招聘嵌入式系统程序员过程中必须而且有效的方法。这些年，我既参加也组织了许多这种测试，在这过程中我意识到这些测试能为带面试者和被面试者提供许多有用信息，此外，撇开面试的压力不谈，这种测试也是相当有趣的。
从被面试者的角度来讲，你能了解许多关于出题者或监考者的情况。这个测试只是出题者为显示其对ANSI标准细节的知识而不是技术技巧而设计吗？这个愚蠢的问题吗？如要你答出某个字符的ASCII值。这些问题着重考察你的系统调用和内存分配策略方面的能力吗？这标志着出题者也许花时间在微机上而不上在嵌入式系统上。如果上述任何问题的答案是“是”的话，那么我知道我得认真考虑我是否应该去做这份工作。
从面试者的角度来讲，一个测试也许能从多方面揭示应试者的素质：最基本的，你能了解应试者C语言的水平。不管怎么样，看一下这人如何回答他不会的问题也是满有趣。应试者是以好的直觉做出明智的选择，还是只是瞎蒙呢？当应试者在某个问题上卡住时是找借口呢，还是表现出对问题的真正的好奇心，把这看成学习的机会呢？我发现这些信息与他们的测试成绩一样有用。
有了这些想法，我决定出一些真正针对嵌入式系统的考题，希望这些令人头痛的考题能给正在找工作的人一点帮住。这些问题都是我这些年实际碰到的。其中有些题很难，但它们应该都能给你一点启迪。
这个测试适于不同水平的应试者，大多数初级水平的应试者的成绩会很差，经验丰富的程序员应该有很好的成绩。为了让你能自己决定某些问题的偏好，每个问题没有分配分数，如果选择这些考题为你所用，请自行按你的意思分配分数。
预处理器（Preprocessor）

1 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
?; #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）

?; 懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
?; 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
?; 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。
2 . 写一个“标准”宏MIN ，这个宏输入两个参数并返回较小的一个。

#define MIN(A,B) （（A） <= (B) ? (A) : (B))

这个测试是为下面的目的而设的：
?; 标识#define在宏中应的基本知识。这是很重要的，因为直到嵌入(inline)操作符变为标准C的一部分，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。
?; 三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。
?; 懂得在宏中小心地把参数用括号括起来
?; 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？

least = MIN(*p++, b);

3. 预处理器标识#error的目的是什么？
如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。
死循环（Infinite loops）

4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？
这个问题用几个解决方案。我首选的方案是：

while(1)
{
?}

一些程序员更喜欢如下方案：

for(;
{
?}

这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的基本原理。如果他们的基本答案是：“我被教着这样做，但从没有想到过为什么。”这会给我留下一个坏印象。
第三个方案是用 goto

Loop:
...
goto Loop;

应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。

数据声明（Data declarations）

5. 用变量a给出下面的定义
a) 一个整型数（An integer）
b)一个指向整型数的指针（ A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
d)一个有10个整型数的数组（ An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）

答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案（或至少大部分答案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢？
Static
6. 关键字static的作用是什么？
这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
?; 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
?; 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
?; 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。

Const

7．关键字const有什么含意？
我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
如果应试者能正确回答这个问题，我将问他一个附加的问题：
下面的声明都是什么意思？

const int a;
int const a;
const int *a;
int * const a;
int const * a const;

/******/
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
?; 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
?; 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
?; 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。
Volatile

8. 关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
?; 并行设备的硬件寄存器（如：状态寄存器）
?; 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
?; 多线程应用中被几个任务共享的变量

回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。
假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
?; 一个参数既可以是const还可以是volatile吗？解释为什么。
?; 一个指针可以是volatile 吗？解释为什么。
?; 下面的函数有什么错误：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}

下面是答案：
?; 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
?; 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
?; 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}

位操作（Bit manipulation）

9. 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。
对这个问题有三种基本的反应
?; 不知道如何下手。该被面者从没做过任何嵌入式系统的工作。
?; 用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序，它用到了bit fields因此完全对我无用，因为我的编译器用其它的方式来实现bit fields的。从道德讲：永远不要让一个非嵌入式的家伙粘实际硬件的边。
?; 用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：

#define BIT3 (0x1 << 3)
static int a;

void set_bit3(void) {
a |= BIT3;
}
void clear_bit3(void) {
a &= ~BIT3;
}

一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数，这也是可接受的。我希望看到几个要点：说明常数、|=和&=~操作。
访问固定的内存位置（Accessing fixed memory locations）

10. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。
这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：

int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;

A more obscure approach is:
一个较晦涩的方法是：

*(int * const)(0x67a9) = 0xaa55;

即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。

中断（Interrupts）

11. 中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。

__interrupt double compute_area (double radius)
{
double area = PI * radius * radius;
printf("\nArea = %f", area);
return area;
}

这个函数有太多的错误了，以至让人不知从何说起了：
?; ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。
?; ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。
?; 在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。
?; 与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。

*****
代码例子（Code examples）

12 . 下面的代码输出是什么，为什么？

void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ”>6”。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。
13. 评价下面的代码片断：

unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
/*1's complement of zero */

对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：

unsigned int compzero = ~0;

这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。
到了这个阶段，应试者或者完全垂头丧气了或者信心满满志在必得。如果显然应试者不是很好，那么这个测试就在这里结束了。但如果显然应试者做得不错，那么我就扔出下面的追加问题，这些问题是比较难的，我想仅仅非常优秀的应试者能做得不错。提出这些问题，我希望更多看到应试者应付问题的方法，而不是答案。不管如何，你就当是这个娱乐吧…

动态内存分配（Dynamic memory allocation）
14. 尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？
这里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J. Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：
下面的代码片段的输出是什么，为什么？

char *ptr;
if ((ptr = (char *)malloc(0)) ==
NULL)
else
puts("Got a null pointer");
puts("Got a valid pointer");

这是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc，得到了一个合法的指针之后，我才想到这个问题。这就是上面的代码，该代码的输出是“Got a valid pointer”。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基本原理更重要些。
Typedef
:
15 Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：

#define dPS struct s *
typedef struct s * tPS;

以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：

dPS p1,p2;
tPS p3,p4;

第一个扩展为

struct s * p1, p2;

.
上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

晦涩的语法

16 . C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？

int a = 5, b = 7, c;
c = a+++b;

这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：

c = a++ + b;

因此, 这段代码持行后a = 6, b = 7, c = 12。
如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题。
好了，伙计们，你现在已经做完所有的测试了。这就是我出的C语言测试题，我怀着愉快的心情写完它，希望你以同样的心情读完它。如果是认为这是一个好的测试，那么尽量都用到你的找工作的过程中去吧。天知道也许过个一两年，我就不做现在的工作，也需要找一个。

引 言

    随着数字信号处理器(DSP)和现场可编程门阵列器件(FPGA)的发展，采用DSP+FPGA的数字硬件系统显示出其优越性，正愈来愈得到人们重视。通用的DSP优点是通过编程可以应用到广泛的产品中，并且主流制造商生产的DSP 已能满足算法控制结构复杂、运算速度高、寻址方式灵活和通信性能强大等需求。但是传统的DSP 采用冯-诺依曼(Von Neumann)结构或某种类型扩展。此种结构本质上是串行的，因此遇到需处理的数据量大，对处理速度要求高，但是对运算结构相对比较简单的底层信号处理算法来说显不出优点，适合采用FPGA 硬件实现。这样，采用DSP + FPGA 的数字硬件系统就可以把二者优点结合一起，兼顾速度和灵活性，既满足底层信号处理要求，又满足高层信号处理要求。

DSP+FPGA系统特点与组成 

    DSP + FPGA 系统最大优点是结构灵活，有较强的通用性，适合于模化设计，从而能够提高算法效率；同时其开发周期较短，系统容易维护和扩展，适合实时信号处理。
    DSP + FPGA系统的核心由DSP芯片和可重构器件FPGA 组成。另外还包括一些外围的辅助电路，如存储器、先进先出(FIFO)器件及FLASH ROM等。FPGA 电路与DSP 相连，利用DSP 处理器强大的I/O功能实现系统内部的通信。从DSP 角度看，FPGA相当于它的宏功能协处理器。外围电路辅助核心电路进行工作。DSP 和FPGA 各自带有RAM，用于存放处理过程所需要的数据及中间结果。FLASH ROM 中存储了DSP 执行程序和FPGA 的配置数据。先进先出(FIFO)器件则用于实现信号处理中常用到的一些操作，如延迟线、顺序存储等。

DSP 和FPGA 的外围电路及连接线

    DSP 的外围电路主要是FLASH、ROM和SRAM，需要连接地址线、数据线和控制线。它需要连接的连线主要包括DSP 模式选择、时钟模式选择、选择外部时钟或本机晶振产生的时钟﹑JTAG接口和电源等。FPGA外围电路主要是用于配置的PROM、FLASH ROM、模数转换和先进先出(FIFO)器件等。它需要连接的连线主要包括FPGA 模式选择、全局时钟、选择外部时钟或本机晶振产生的时钟、JTAG接口、输出/输入接口、测试口和电源等。
    DSP与FPGA 的连接包括(1)数据线：DSPD0~DSPD15；(2)地址线：DSPA0~DSPA15；(3)控制线：BIO、HCS、DSPPS、DSPDS、DSPIS、DSPMSTRB、DSPIOSTRB、DSPREADY、DSPRW；（4）中断线：DSPINT0、DSPINT1、DSPINT2、DSPINT3；（5）串口线：BFSX0、BDX0、BCLKX0、BFSR0、BDR0、BCLKR0、BFSX1、BDX1、BCLKX1、BFSR1、BDR1、BCLKR1。

FPGA 的编程设计过程

    用户可编程FPGA 芯片体系结构由二个主要的可配置的元件组成：可配置的逻辑模块(configurable logic blocks-CLBs)和输入/输出模块(input/output blocks IOBs)。CLBs 提供构造逻辑功能；IOBs 提供可配置的逻辑模块与包装引脚之间的接口；CLBs 之间的相互连接通过一个通用的路由矩阵(a general routing matrix -GRM)。GRM由位于水平方向和垂直方向路由通道交叉路口的路由开关阵列构成。构成一个通用模块的每一CLB也提供本地的路由资源把CLB连接到GRM。
    FPGA的编程设计过程。首先，从数字系统的行为级模拟得到各个行为模块的逻辑要求，包括组合逻辑和时序逻辑两方面要求，即得到NGD文件。其次，通过对NGD文件进行优化、组合和映射，创建基本逻辑单元。每一个基本逻辑单元由功能产生器(F/G)、D型触发器、进位逻辑等组成。然后，把基本逻辑单元包装成可配置的逻辑块CLBs，其中一小部分包装成输入/输出模块IOBs或TBUF模块。输出没有布局和布线的NCD文件。最后，把NCD文件中每一个可配置的逻辑块CLBs和每一个输入/输出块IOBs分别放置到FPGA 芯片上一个特定位置，称为布局。并且连通路由，完成布线。如果设计结果不能达到定时指标或不能完全接通，需要重新进行布局和布线。以上设计开发过程可以借助于开发工具及加入适当的手工设置操作完成。对于FPGA的布局有以下指导原则：
门阵列小于100K系统的I/O的布局原则
    在FPGA顶部和底部的I/O引脚用作控制信号，即信号路由方向是垂直方向；在FPGA左部和右部的I/O引脚用作数据总线，因为FPGA 的体系结构适合数据作水平方向流动。
100K系统的I/O的布局原则
    门阵列大于100K系统的I/O的布局原则与小于100K系统相同。需要附加考虑下列问题。第一，可配置逻辑组的控制信号和数据总线尽量接近内部逻辑。第二，主要的信号可以放置在接近芯片的中间位置，以便容易接入到水平方向的长线。
数据总线布局
    当算术运算的比特数大于5比特，需要使用进位逻辑。进位链路的布线需要使用垂直方向。它同时影响到内部逻辑单元和I/O布局。开关同时输出信号会引起地线上反弹，为了减少这种反弹现象，需要把开关输出线分散开，因而把数据总线的一半安排到芯片的左端I/O，另一半安排到芯片的右端I/O，保持数据的流动的方向仍然是左右方向流动。
内部逻辑布局技巧
    当进行内部逻辑布局时，特别是进行逻辑进位或TBUF设计时，内部逻辑应安排成垂直队列，这是一种关键的技巧。数据路途元件配置应使得数据交互地通过电路片，不管是从左到右，还是从右到左都是认可的。应使用最短的路由，以至节点之间的延迟最小。为了避免路由阻塞，应使得路由的总趋势不要互相成十字交叉。
TBUF布局
    双向数据总线长线沿着水平方向放置，三相使能控制线沿着垂直方向放置。布局和布线时，软件会按照上述原则自动地排列TBUF。在大型的FPGA 的芯片中，沿着水平方向的长线可以在中间断开，使TBUF的版图使用半长线，以便增加利用率。如果你的设计不能满足性能指标，或者布线不能完全接通，可以通过下列途径来改进：可以增加定时约束；在关键路由上减少逻辑；增加在布局和布线上的考虑和编辑版面图等。
FPGA的配置
    XILINX公司生产的FPGA ，它的配置是通过装载配置数据到内部配置存储器实现的。注意：如果装载一个不正确的比特流，会引起配置的失败并损害装置。配置使用的引脚有专用的，也有作为一般目的用的输入和输出引脚。一旦配置完成后，后者可重复使用。专用的引脚包含：模式引脚(M2,M1, M0)、配置时钟引脚(CCLK)、PROGRAM 引脚、DONE 引脚和边界扫描引脚(TDI, TDO, TMS, TCK)。依赖于配置模式的选择，CCLK 能够由FPGA 产生，或者由外部产生。FPGA 支持四种配置模式：主串模式、从串模式、选择MAP 模式和边界扫描模式(JTAG)。通过边界扫描口的配置总是有效的，它独立于模式选择。选择边界扫描模式能够简单地转向其它模式。

文章来源：国外电子元器件

摘要：论述了以DSP芯片TMS320F2812为核心的一种测量仪器的组成原理、设计思想以及快速定点算法的实现方法,同时对定点和浮点算法结果进行了比较。

    关键词：定点芯片;浮点运算;快速算法;系统配置;TMS320F2812

１ TMS320F2812简介

ＴＭＳ３２０Ｆ２８１２是ＴＩ公司的一款用于控制的高性能、多功能、高性价比的３２位定点ＤＳＰ芯片。该芯片兼容ＴＭＳ３２０ＬＦ２４０７指令系统最高可在１５０ＭＨｚ主频下工作,并带有１８ｋ×１６位０等待周期片上ＳＲＡＭ和１２８ｋ×１６位片上ＦＬＡＳＨ（存取时间３６ｎｓ）。其片上外设主要包括２×８路１２位ＡＤＣ（最快８０ｎｓ转换时间）、２路ＳＣＩ、１路ＳＰＩ、１路ＭｃＢＳＰ、１路ｅＣＡＮ等,并带有两个事件管理模块（ＥＶＡ、ＥＶＢ）,分别包括６路ＰＷＭ／ＣＭＰ、２路ＱＥＰ、３路ＣＡＰ、２路１６位定时器（或ＴｘＰＷＭ／ＴｘＣＭＰ）。另外,该器件还有３个独立的３２位ＣＰＵ定时器,以及多达５６个独立编程的ＧＰＩＯ引脚,可外扩大于１Ｍ×１６位程序和数据存储器。ＴＭＳ３２０Ｆ２８１２采用哈佛总线结构,具有密码保护机制,可进行双１６×１６乘加和３２×３２乘加操作,因而可兼顾控制和快速运算的双重功能。

通过对ＴＭＳ３２０Ｆ２８１２定点ＤＳＰ芯片合理的系统配置和编程可实现快速运算,本文着重对此加以说明。

２ TMS320F2812基本系统配置

２．１ ＴＭＳ３２０Ｆ２８１２时钟

ＴＭＳ３２０Ｆ２８１２的片上外设按输入时钟可分为如下４个组：

(１)ＳＹＳＯＵＴＣＬＫ组：包括ＣＰＵ定时器和ｅＣＡＮ总线,可由ＰＬＬＣＲ寄存器动态地修改;

(２)ＯＳＣＣＬＫ组：主要是看门狗电路,由ＷＤＣ寄存器设置分频系数;

(３)低速组：有ＳＣＩ、ＳＰＩ、ＭｃＢＳＰ,可由ＬＯＳＰＣＰ寄存器设置分频系数;

(４)高速组：包括ＥＶＡ／Ｂ、ＡＤＣ,可由ＨＩＳＰＣＰ寄存器设置分频系数。

为了使系统具有较快的工作速度,除了定时器和ＳＣＩ等少数需要低速时钟的地方,其它外设均可以１５０ＭＨｚ时钟工作。



    ２．２ 存储空间    3.2 FIR滤波器编程

图１所示是ＴＭＳ３２０Ｆ２８１２的内部存储空间映射图。ＴＭＳ３２０Ｆ２８１２为哈佛（Ｈａｒｖａｒｄ）结构的ＤＳＰ,即在同一个时钟周期内可同时进行一次取指令、读数据和写数据的操作。在逻辑上有４Ｍ×１６位程序空间和４Ｍ×１６位数据空间,但物理上已将程序空间和数据空间统一为一个４Ｍ×１６位的存储空间,各总线按优先级由高到低的顺序为：数据写、程序写、数据读、程序读。其中由ＣＹ７Ｃ１０４１扩展的２５６ｋ×１６位ＳＡＲＡＭ位于Ｚｏｎｅ ６（０ｘ１０００００～０ｘ１３ＦＦＦＦ）,存取时间不小于１２ｎｓ;１２８ｋ×１６位ＦＬＡＳＨ空间（０ｘ３Ｄ８０００～ ０ｘ３Ｆ７ＦＦＦ）取指时间不小于３６ｎｓ。为了尽可能提高器件的工作速度,在对FLASH寄存器编程使其在较高速度下工作的同时,可将时间要求比较严格的程序（如时延计算子程序、FIR滤波子程序等）、变量（如FIR滤波器系数、自适应算法的权向量等）各堆栈空间搬移到H0、L0、L1、M0、M1空间来运行。

2.3 中断

TMS320F28x系列DSP片上都有非常丰富的外设,每个片上外设均可产生1个或多个中断请求。中断由两级组成,其中一级是PIE中断,另一级是CPU中断。CPU中断有32个中断源,包括RESET、NMI、EMUINT、ILLEGAL、12个用户定义的软件中断USER1～USER12和16个可屏蔽中断（INT1～INT14、RTOSINT和DLOGINT）。所有软件中断均属于非屏蔽中断。由于CPU没有足够的中断源来管理所有的片上外设中断请求,所以在TMS320F28x系列DSP中设置了一个外设中断扩展控制器（PIE）来管理片上外设和外部引脚引起的中断请求。

PIE中断共有96个,被分为12个组,每组内有8个片上外设中断请求,96个片上外设中断请求信号可记为INTx.y(x=1,2,…,12;y=1,2,…,8)。每个组输出一个中断请求信号给CPU,即PIE的输出INTx(x=1,2,…,…12）对应CPU中断输入的INT1～INT12。TMS320F28x系列DSP的96个可能的PIE中断源中有45个被TMS320F2812使用,其余的被保留作以后的DSP器件使用。

ADC、定时器、SCI编程等均以中断方式进行,可提高CPU的利用率。

2.4 复位引导

图2所示是TMS320F2812的片上引导ROM空间映射。其此导程序配置在图2中的0x3FFC00～0x3FFFBF,根据图1,设置VMAP=1,MP/MC=0,ENPIE=0,复位向量指向片上0x3FFFC0,而片上0x3FFFC0中内容为0x3FFC00,即指向图2中的引导程序。配置表2中的GPIOF4（SCITXDA）=1,则转向FLASH中的0x3F7FF6开始执行程序,最后在0x3F7FF6片设置跳转指令指向用户程序的开始处,以开始运行用户程序。由于在实际应用中使用了PIE中断,因此,在用户应用程序中,应首先初始化PIE中断向量表,然后使能PIE。

3 编程设计

编程是实现系统正常工作和快速运算必不可少的重要环节。在系统配置合理的条件下,用定点芯片实现快速运算的关键用整数取代浮点数进行计算处理。用C编译器时,为产生最优代码,应遵循以下原则：

（1）将除法转换为乘法,尽量使编译器产生MAC指令,以充分利用DSP的硬件乘法器资源进行快速运算,且应使MAC的操作数为局部变量以分配到寄存器中（或到一个累加器中）。

（2）尽可能使用静态直接插入函数,以节省函数调用的额外开销。

（3）对FOR循环的上限,使用常数或具有常数属性的变量可产生重复指令RPT。

3.1 ADC编程

TMS20F2812带有两个8选1多路切换器和双采样/保持器的12位ADC,模拟量输入范围为0～3V,最快转换速率为80ns,选用10kSPS采样率,并采用EVA的定时器（0.1ms）自动触发方式,可同时采样4个通道,并采用每次转换结束的中断方式来纪录采样结果（右移4位）。

转换结果=（212-1）×（输入的模拟信号-ADCLO）/3

ADC转换时,首先初始化DSP系统,然后设置PIE中断矢量表,再初始化ADC模块,接着将ADC中断的入口地址装入中断矢量表并开中断,然后再启动0.1ms定时器,同时等待ADC中断,最后在ADC中断中读取ADC转换结果,并用软件启动下一次中断。

目标信号对某些低频干扰非常敏感,它将直接响应到定位结果和数据的有效性。为了在滤波后不影响时延数据的计算,可采用线性相位的FIR滤波器。滤波器系数h(i)用MATLAB的产生,并在变成整形然后固化到程序中,这样做（而不是单独计算滤波器系数）的目的是为了实现快速滤波而不会过多增加整个测量系统定位计算的时间。

3.3 定位算法的移植

由于定位算法采用自适应时延估计法,因此计算量非常庞大,对DSP芯片性能要求较高。TMS320F2812具有32位硬件乘法器和累加器,其RPT指令非常适合循环计算,处理能力可达150MIPS,因而具有较高的性能。但它是一款定点处理芯片,需要使用定点算法来解决处理量大的问题。因此,对初始数据、权矢量应采用16位整形变量（Q=12：由ADC转换精度决定）,而循环计算中产生的中间结果则使用32位整形变量（Q=20：在结果不溢出的情况下尽量满足计算精度）;至于对三角函数等的运算,可用查表法并利用图2中的表格来进行快速计算。

C编译器带有浮点运算库,因此可将浮点算法和定点算法的结果进行比较,对于4路各1024点数据处理,用浮点算法实现约需3.6秒,而用定点算法只需1.3秒。

另外,还可对算法进行优化。第一是将经常使用的中间变量配置到等待周期为0的内存中;第二是采用FLASH加速技术（使能FOPT寄存器的ENPIPE位实现预指机制的FLASH流水线模式）,这样可以达到100～120MIPS的处理能力,大大高于其本身36ns的读取能力。需要注意的是,由于TMS320F2812的保护机制,对FLASH寄存器进行存取的这段程序必须搬移到L0、L1中执行。尽管这样,将这段对时间要求比较荷记得的算法移植到内存H0中,可以达到最高150MIPS的处理速度,并能使用函数memcpy()完成程序的搬移。

链接命令文件.cmd将链接信息放在一个文件中，以便在多次使用同样的链接信息时调用。在命令文件中两个十分有用的伪指令MEMORY&SECTION,来指定实际应用中的存储器结构和运行地址的映射.MEMORY用来指定目标存储器结构,Memory下可以通过PAGE选项配置地址空间。链接器把每一页当做一个独立的存储空间，通常情况下，PAGE0代表程序存储器用来存放程序，PAGE1代表数据存储器，用来存放数据。由编译器生成的可重定位的代码和数据块叫做SECTION块,Section块用来控制段的构成与地址分配。对于不同的系统配置，Section的分配方式也不相同，链接器通过Section来控制地址的分配，所以Section的分配成了配置.cmd文件的重要环节。以下是Section的定义及分配的详细介绍。
   它分成两个基本的部分：
1.被初始化的Section（包含数据表和可执行代码）
  .text它包含所有的可执行代码和常数，必须放在程序页
  .cinit它包含初始化的变量和常量表，要求放在程序页
  .pinit 它包括全局构造器（C++）初始化的变量表，要求放在程序页
  .const它包括符串，声明，以及被明确初始化过的全局和静态变量，要求放在低地址数据页。
  .econst他是在使用大存储器模式时使用的，包括字符串，声明，以及被明确初始化过的全局变量和静态变量，可以在数据页的任何地方。
  .switch它包括为转换声明设置的表格，可以放在程序页，也可以放在低地址的数据页。
2. 未被初始化的Section(为程序运行中创建和存放的变量在存储器中保留空间)
  .bss它为全局变量和静态变量保留空间.在程序开始运行时,C导入路径把数据从.cinit节复制出去然后存在.bss节中.要求放在低地址的数据页.
  .ebbs它是在远访问(C)和大存储器模式下使用,它为全局变量和静态变量保留空间.在程序开始运行时,C导入路径把数据从.cinit段复制出去然后存在.ebss节中。可以存放在数据页的任何地方。
  .stack为C系统堆栈保留空间，这部分存储器为用来将声明传给函数及为局部变量留出空间。要求放在低地址的数据页。
  .system动态存储器分配保留空间，这个空间用于malloc函数，如果不使用malloc函数，这个段的大小就是0。要求放在低地址的数据页。
  .esystem动态存储器分配保留空间，这个空间用于外部malloc函数，如果不使用外部malloc函数，这个段的大小就是0。可也放在数据页的任何地方。

《中庸》有云：喜怒哀乐之未发谓之中，发而皆中节谓之和。电容极高明而道中庸，过犹不及。

不要轻视电容哦。。。什么地方都有如果用得不好，死得难看的，所以首先。。。

A、什么是好电容。

1.电容容量越大越好。
很多人在电容的替换中往往爱用大容量的电容。我们知道虽然电容越大，为IC提供的电流补偿的能力越强。且不说电容容量的增大带来的体积变大，增加成本的同时还影响空气流动和散热。关键在于电容上存在寄生电感，电容放电回路会在某个频点上发生谐振。在谐振点，电容的阻抗小。因此放电回路的阻抗最小，补充能量的效果也最好。但当频率超过谐振点时，放电回路的阻抗开始增加，电容提供电流能力便开始下降。电容的容值越大，谐振频率越低，电容能有效补偿电流的频率范围也越小。从保证电容提供高频电流的能力的角度来说，电容越大越好的观点是错误的，一般的电路设计中都有一个参考值的。

2.同样容量的电容，并联越多的小电容越好，
耐压值、耐温值、容值、ESR(等效电阻)等是电容的几个重要参数，对于ESR自然是越低越好。ESR与电容的容量、频率、电压、温度等都有关系。当电压固定时候，容量越大，ESR越低。在板卡设计中采用多个小电容并连多是出与PCB空间的限制，这样有的人就认为，越多的并联小电阻，ESR越低，效果越好。理论上是如此，但是要考虑到电容接脚焊点的阻抗，采用多个小电容并联，效果并不一定突出。

3.ESR越低，效果越好。
结合我们上面的提高的供电电路来说，对于输入电容来说，输入电容的容量要大一点。相对容量的要求，对ESR的要求可以适当的降低。因为输入电容主要是耐压，其次是吸收MOSFET的开关脉冲。对于输出电容来说，耐压的要求和容量可以适当的降低一点。ESR的要求则高一点，因为这里要保证的是足够的电流通过量。但这里要注意的是ESR并不是越低越好，低ESR电容会引起开关电路振荡。而消振电路复杂同时会导致成本的增加。板卡设计中，这里一般有一个参考值，此作为元件选用参数，避免消振电路而导致成本的增加。

4.好电容代表着高品质。
“唯电容论”曾经盛极一时，一些厂商和媒体也刻意的把这个事情做成一个卖点。在板卡设计中，电路设计水平是关键。和有的厂商可以用两相供电做出比一些厂商采用四相供电更稳定的产品一样，一味的采用高价电容，不一定能做出好产品。衡量一个产品，一定要全方位多角度的去考虑，切不可把电容的作用有意无意的夸大。

B、电容爆浆之面面谈

爆浆的种类：

分两类，输入电容爆浆和输出电容爆浆。

对于输入电容来说，就是我是说的C1，C1对由电源接收到的电流进行过滤。

输入电容爆浆和电源输入电流的品质有关。过多的毛刺电压，峰值电压过高，电流不稳定等都使电容过于充放电过于频繁，长时间处于这类工作环境下的电容，内部温度升高很快。超过泄爆口的承受极限就会发生爆浆。

对于输出电容来说，就我说的C2，对经电源模块调整后的电流进行滤波。此处电流经过一次过滤，比较平稳，发生爆浆的可能性相对来说小了不少。但如果环境温度过高，电容同样容易发生爆浆。 

爆，报也。
采用垃圾东西自然要爆，报应啊。
欲知过去因者，见其现在果；欲知未来果者，见其现在因。

爆浆的原因：

电容爆浆的原因有很多，比如电流大于允许的稳波电流、使用电压超出工作电压、逆向电压、频繁的充放电等。但是最直接的原因就是高温。
我们知道电容有一个重要的参数就是耐温值，指的就是电容内部电解液的沸点。当电容的内部温度达到电解液的沸点时，电解液开始沸腾，电容内部的压力升高，当压力超过泄爆口的承受极限就发生了爆浆。所以说温度是导致电容爆浆的直接原因。
电容设计使用寿命大约为2万小时，受环境温度的影响也很大。电容的使用寿命随温度的增加而减小，实验证明环境温度每升高10℃，电容的寿命就会减半。主要原因就是温度加速化学反应而使介质随时间退化失效，这样电容寿命终结。
为了保证电容的稳定性，电容在插板前要经过长时间的高温环境的测试。即使是在100℃，高品质的电容也可以工作几千个小时。同时，我们提到的电容的寿命是指电容在使用过程中，电容容量不会超过标准范围变化的10%。电容寿命指的是电容容量的问题，而不是设计寿命到达之后就发生爆浆。只是无法保证电容的设计的容量标准。

所以，短时期内，正常使用的板卡电容就发生爆浆的情况，这就是电容品质问题。
另外，不正常的使用情况也有可能发生电容爆浆的情况。比如热插拔电脑配件也会导致板卡局部电路电流、电压的剧烈变化，从而引发电容使用故障。

变量作用域和存储类别：

了解了基本的变量类型后，我们要进一步了解它的存储类别和变量作用域问题。

变量类别 子类别
局部变量 静态变量（离开函数，变量值仍保留）
自动变量
寄存器变量
全局变量 静态变量（只能在本文件中用）
非静态变量（允许其他文件使用）

换一个角度

变量类别 子类别
静态存储变量  静态局部变量（函数） 
静态全局变量（本文件） 
非静态全局/外部变量（其他文件引用） 
动态存储变量 自动变量
寄存器变量
形式参数

extern型的存储变量在处理多文件问题时常能用到，在一个文件中定义extern型的变量即说明这个变量用的是其他文件的。顺便说一下，笔者在做课设时遇到out of memory的错误，于是改成做多文件，再把它include进来（注意自己写的*.h要用“”不用<>），能起到一定的效用。static 型的在读程序写结果的试题中是个考点。多数时候整个程序会出现多个定义的变量在不同的函数中，考查在不同位置同一变量的值是多少。主要是遵循一个原则，只要本函数内没有定义的变量就用全局变量（而不是main里的），全局变量和局部变量重名时局部变量起作用，当然还要注意静态与自动变量的区别。

函数：

对于函数最基本的理解是从那个叫main的单词开始的，一开始总会觉得把语句一并写在main里不是挺好的么，为什么偏择出去。其实这是因为对函数还不够熟练，否则函数的运用会给我们编程带来极大的便利。我们要知道函数的返回值类型，参数的类型，以及调用函数时的形式。事先的函数说明也能起到一个提醒的好作用。所谓形参和实参，即在调用函数时写在括号里的就是实参，函数本身用的就是形参，在画流程图时用平行四边形表示传参。

函数的另一个应用例子就是递归了，笔者开始比较头疼的问题，反应总是比较迟钝，按照老师的方法，把递归的过程耐心准确的逐级画出来，学习的效果还是比较好的，会觉得这种递归的运用是挺巧的，事实上，著名的八皇后、汉诺塔等问题都用到了递归。

例子：
long fun(int n)
{
long s;
if(n==1||n==2) s=2;
   else s=n-fun(n-1);
return s;
}
main()
{
printf("%ld",fun(4));
} 

数组：

分为一维数组和多维数组，其存储方式画为表格的话就会一目了然，其实就是把相同类型的变量有序的放在一起。因此，在处理比较多的数据时（这也是大多数的情况）数组的应用范围是非常广的。

具体的实际应用不便举例，而且绝大多数是与指针相结合的，笔者个人认为学习数组在更大程度上是为学习指针做一个铺垫。作为基础的基础要明白几种基本操作：即数组赋值、打印、排序（冒泡排序法和选择排序法）、查找。这些都不可避免的用到循环，如果觉得反应不过来，可以先一点点的把循环展开，就会越来越熟悉，以后自己编写一个功能的时候就会先找出内在规律，较好的运用了。另外数组做参数时，一维的[]里可以是空的，二维的第一个[]里可以是空的但是第二个[]中必须规定大小。

冒泡法排序函数：
void bubble(int a[],int n)
{
int i,j,k;
for(i=1,i<n;i++)
   for(j=0;j<n-i;j++)
   if(a[j]>a[j+1])
    {
    k=a[j];
       a[j]=a[j+1];
       a[j+1]=k;
       }
}

选择法排序函数：
void sort(int a[],int n)
{
int i,j,k,t;
for(i=0,i<n-1;i++)
   {
   k=i;
   for(j=i+1;j<n;j++)
      if(a[k]<a[j]) k=j;
      if(k!=i)
         {
         t=a[i];
         a[i]=a[k];
         a[k]=t;
         }
   }
}

折半查找函数（原数组有序）：
void search(int a[],int n,int x)
{
int left=0,right=n-1,mid,flag=0;
while((flag==0)&&(left<=right))
   {
   mid=(left+right)/2;
   if(x==a[mid])
      {
      printf("%d%d",x,mid);
      flag =1;
      }
      else if(x<a[mid]) right=mid-1;
                   else left=mid+1;
   }
} 

相关常用的算法还有判断回文，求阶乘，Fibanacci数列，任意进制转换，杨辉三角形计算等等。

字符串：

字符串其实就是一个数组（指针），在scanf的输入列中是不需要在前面加“&”符号的，因为字符数组名本身即代表地址。值得注意的是字符串末尾的‘{post.abstract}’，如果没有的话，字符串很有可能会不正常的打印。另外就是字符串的定义和赋值问题了，笔者有一次的比较综合的上机作业就是字符串打印老是乱码，上上下下找了一圈问题，最后发现是因为

char *name; 

而不是

char name[10]; 

前者没有说明指向哪儿，更没有确定大小，导致了乱码的错误，印象挺深刻的。

另外，字符串的赋值也是需要注意的，如果是用字符指针的话，既可以定义的时候赋初值，即

char *a="Abcdefg"; 

也可以在赋值语句中赋值，即

char *a;
a="Abcdefg"; 

但如果是用字符数组的话，就只能在定义时整体赋初值，即char a[5]={"abcd"};而不能在赋值语句中整体赋值。

常用字符串函数列表如下，要会自己实现：

函数作用  函数调用形式  备注 
字符串拷贝函数 strcpy(char*,char *) 后者拷贝到前者
字符串追加函数 strcat(char*,char *) 后者追加到前者后，返回前者，因此前者空间要足够大
字符串比较函数 strcmp(char*,char *) 前者等于、小于、大于后者时，返回0、正值、负值。注意，不是比较长度，是比较字符ASCII码的大小，可用于按姓名字母排序等。
字符串长度 strlen(char *) 返回字符串的长度，不包括'{post.abstract}'.转义字符算一个字符。
字符串型->整型 atoi(char *)
整型->字符串型 itoa(int,char *,int) 做课设时挺有用的
sprintf(char *,格式化输入） 赋给字符串，而不打印出来。课设时用也比较方便

注：对字符串是不允许做==或！=的运算的，只能用字符串比较函数

指针：

指针可以说是C语言中最关键的地方了，其实这个“指针”的名字对于这个概念的理解是十分形象的。首先要知道，指针变量的值（即指针变量中存放的值）是指针（即地址）。指针变量定义形式中：基本类型 *指针变量名 中的“*”代表的是这是一个指向该基本类型的指针变量，而不是内容的意思。在以后使用的时候，如*ptr=a时，“*”才表示ptr所指向的地址里放的内容是a。

指针比较典型又简单的一应用例子是两数互换，看下面的程序，

swap(int c,int d)
{
int t;
t=c;
c=d;
d=t;
}
main()
{
int a=2,b=3;
swap(a,b);
printf(“%d,%d”,a,b);
} 

这是不能实现a和b的数值互换的，实际上只是形参在这个函数中换来换去，对实参没什么影响。现在，用指针类型的数做为参数的话，更改如下：

swap(#3333FF *p1,int *p2)
{
int t;
t=*p1;
*p1=*p2;
*p2=t;
}
main()
{
int a=2,b=3;
int *ptr1,*ptr2;
ptr1=&a;
ptr2=&b;
swap(prt1,ptr2);
printf(“%d,%d”,a,b);
} 

这样在swap中就把p1,p2 的内容给换了，即把a，b的值互换了。

指针可以执行增、减运算，结合++运算符的法则，我们可以看到:

*++s  取指针变量加1以后的内容
 
*s++  取指针变量所指内容后s再加1
(*s)++  指针变量指的内容加1

指针和数组实际上几乎是一样的，数组名可以看成是一个常量指针，一维数组中ptr=&b[0]则下面的表示法是等价的：

a[3]等价于*(a+3)
ptr[3]等价于*(ptr+3)

下面看一个用指针来自己实现atoi（字符串型->整型）函数：

int atoi(char *s)
{
int sign=1,m=0;
if(*s=='+'||*s=='-') /*判断是否有符号*/
sign=(*s++=='+')?1:-1; /*用到三目运算符*/
while(*s!='{post.abstract}') /*对每一个字符进行操作*/
   {
   m=m*10+(*s-'0');
   s++; /*指向下一个字符*/
   }
return m*sign;
} 

指向多维数组的指针变量也是一个比较广泛的运用。例如数组a[3][4]，a代表的实际是整个二维数组的首地址，即第0行的首地址，也就是一个指针变量。而a+1就不是简单的在数值上加上1了，它代表的不是a[0][1]，而是第1行的首地址，&a[1][0]。

指针变量常用的用途还有把指针作为参数传递给其他函数，即指向函数的指针。
看下面的几行代码：

void Input(ST *);
void Output(ST *);
void Bubble(ST *);
void Find(ST *);
void Failure(ST *);
/*函数声明：这五个函数都是以一个指向ST型（事先定义过）结构的指针变量作为参数，无返回值。*/

void (*process[5])(ST *)={Input,Output,Bubble,Find,Failure};
/*process被调用时提供5种功能不同的函数共选择(指向函数的指针数组）*/

printf("\nChoose:\n?");
scanf("%d",&choice);
if(choice>=0&&choice<=4)
(*process[choice])(a); /*调用相应的函数实现不同功能*;/ 

总之，指针的应用是非常灵活和广泛的，不是三言两语能说完的，上面几个小例子只是个引子，实际编程中，会逐渐发现运用指针所能带来的便利和高效率。

文件：

函数调用形式  说明 
fopen("路径","打开方式") 打开文件
fclose(FILE *) 防止之后被误用
fgetc(FILE *) 从文件中读取一个字符
fputc(ch,FILE *) 把ch代表的字符写入这个文件里
fgets(FILE *) 从文件中读取一行
fputs(FILE *) 把一行写入文件中
fprintf(FILE *,"格式字符串",输出表列） 把数据写入文件
fscanf(FILE *,"格式字符串",输入表列） 从文件中读取
fwrite（地址，sizeof（），n，FILE *） 把地址中n个sizeof大的数据写入文件里
fread（地址，sizeof（），n，FILE *） 把文件中n个sizeof大的数据读到地址里
rewind（FILE *） 把文件指针拨回到文件头
fseek（FILE *，x，0/1/2） 移动文件指针。第二个参数是位移量，0代表从头移，1代表从当前位置移，2代表从文件尾移。
feof(FILE *) 判断是否到了文件末尾

文件打开方式  说明 
r  打开只能读的文件
w  建立供写入的文件，如果已存在就抹去原有数据
a  打开或建立一个把数据追加到文件尾的文件
r+  打开用于更新数据的文件
w+  建立用于更新数据的文件，如果已存在就抹去原有数据
a+  打开或建立用于更新数据的文件，数据追加到文件尾

注：以上用于文本文件的操作，如果是二进制文件就在上述字母后加“b”。

我们用文件最大的目的就是能让数据保存下来。因此在要用文件中数据的时候，就是要把数据读到一个结构（一般保存数据多用结构，便于管理）中去，再对结构进行操作即可。例如，文件aa.data中存储的是30个学生的成绩等信息，要遍历这些信息，对其进行成绩输出、排序、查找等工作时，我们就把这些信息先读入到一个结构数组中，再对这个数组进行操作。如下例：

#include<stdio.h>
#include<stdlib.h>
#define N 30
typedef struct student /*定义储存学生成绩信息的数组*/
{
char *name;
int chinese;
int maths;
int phy;
int total;
}ST;

main()
{
ST a[N]; /*存储N个学生信息的数组*/
FILE *fp;
void (*process[3])(ST *)={Output,Bubble,Find}; /*实现相关功能的三个函数*/
int choice,i=0;
Show();
printf("\nChoose:\n?");
scanf("%d",&choice);
while(choice>=0&&choice<=2)
   {
   fp=fopen("aa.dat","rb");
   for(i=0;i<N;i++)
      fread(&a[i],sizeof(ST),1,fp); /*把文件中储存的信息逐个读到数组中去*/
   fclose(fp);
   (*process[choice])(a); /*前面提到的指向函数的指针，选择操作*/
   printf("\n");
   Show();
   printf("\n?");
   scanf("%d",&choice);
   }
}

void Show()
{
printf("\n****Choices:****\n0.Display the data form\n1.Bubble it according to the total score\n2.Search\n3.Quit!\n");
}

void Output(ST *a) /*将文件中存储的信息逐个输出*/
{
int i,t=0;
printf("Name Chinese Maths Physics Total\n");
for(i=0;i<N;i++)
   {
   t=a[i].chinese+a[i].maths+a[i].phy;
   a[i].total=t;
   printf("%4s%8d%8d%8d%8d\n",a[i].name,a[i].chinese,a[i].maths,a[i].phy,a[i].total);
   }
}

void Bubble(ST *a) /*对数组进行排序，并输出结果*/
{
int i,pass;
ST m;
for(pass=0;pass<N-1;pass++)
   for(i=0;i<N-1;i++)
      if(a[i].total<a[i+1].total)
         {
         m=a[i]; /*结构互换*/
         a[i]=a[i+1];
         a[i+1]=m;
         }
Output(a);
}

void Find(ST *a)
{
int i,t=1;
char m[20];
printf("\nEnter the name you want:");
scanf("%s",m);
for(i=0;i<N;i++)
   if(!strcmp(m,a[i].name)) /*根据姓名匹配情况输出查找结果*/
   {
   printf("\nThe result is:\n%s, Chinese:%d, Maths:%d,     Physics:%d,Total:%d\n",m,a[i].chinese,a[i].maths,a[i].phy,a[i].total);
   t=0;
   }
if(t)
   printf("\nThe name is not in the list!\n");
}
 

链表：
链表是C语言中另外一个难点。牵扯到结点、动态分配空间等等。用结构作为链表的结点是非常适合的，例如：

struct node
{
int data;
struct node *next;
}; 

其中next是指向自身所在结构类型的指针，这样就可以把一个个结点相连，构成链表。

链表结构的一大优势就是动态分配存储，不会像数组一样必须在定义时确定大小，造成不必要的浪费。用malloc和free函数即可实现开辟和释放存储单元。其中，malloc的参数多用sizeof运算符计算得到。

链表的基本操作有：正、反向建立链表；输出链表；删除链表中结点；在链表中插入结点等等，都是要熟练掌握的，初学者通过画图的方式能比较形象地理解建立、插入等实现的过程。

typedef struct node
{
char data;
struct node *next;
}NODE; /*结点*/

正向建立链表：
NODE *create()
{
char ch='a';
NODE *p,*h=NULL,*q=NULL;
while(ch<'z')
   {
   p=(NODE *)malloc(sizeof(NODE)); /*强制类型转换为指针*/
   p->data=ch;
   if(h==NULL) h=p;
      else q->next=p;
   ch++;
   q=p;
   }
q->next=NULL; /*链表结束*/
return h;
} 

逆向建立：

NODE *create()
{
char ch='a';
NODE *p,*h=NULL;
while(ch<='z')
   {
   p=(NODE *)malloc(sizeof(NODE));
   p->data=ch;
   p->next=h; /*不断地把head往前挪*/
   h=p;
 nbsp; ch++;
   }
return h;
} 

用递归实现链表逆序输出：

void output(NODE *h)
{
if(h!=NULL)
   {
   output(h->next);
   printf("%c",h->data);
   }
} 

插入结点（已有升序的链表）：

NODE *insert(NODE *h,int x)
{
NODE *new,*front,*current=h;
while(current!=NULL&&(current->data<x)) /*查找插入的位置*/
   {
   front=current;
   current=current->next;
   }
new=(NODE *)malloc(sizeof(NODE));
new->data=x;
new->next=current;
if(current==h) /*判断是否是要插在表头*/
   h=new;
else front->next=new;
return h;
} 

删除结点：

NODE *delete(NODE *h,int x)
{
NODE *q,*p=h;
while(p!=NULL&&(p->data!=x))
   {
   q=p;
   p=p->next;
   }
if(p->data==x) /*找到了要删的结点*/
   {
   if(p==h) /*判断是否要删表头*/
   h=h->next;
      else q->next=p->next;
   free(p); /*释放掉已删掉的结点*/
   }
return h;
} 

经常有链表相关的程序填空题，做这样的题要注意看下面提到的变量是否定义了，用到的变量是否赋初值了，是否有给分配空间的没有分配空间，最后看看返回值是否正确。

笔者水平有限，难免有疏漏、错误的地方，浅显之处，还望指正见谅。上述内容仅是个提示作用，并不包括C语言的全部内容