flash内得程序代码以最快速度运行，需要设置flash配置寄存器的等待周期数，而“设置flash配置寄存器的等待周期数”的这段代码是不能在flash内部执行的，这样就会出现两种实际的配置方式：
  
一种是2812系统无外扩程序存储器，此时程序只能写在2812内部得flash区，程序运行开始后，需要将“设置flash配置寄存器的等待周期数”的这段代码用数据复制的方式复制到内部sram区，比如 
L0 区，然后使用跳转指令跳转到L0 
区“设置flash配置寄存器的等待周期数”的代码进行flash配置寄存器的设置，设置完成后再使用跳转指令跳转到flash程序区执行正常的功能程序。这样以后的flash内的代码就会以最快速度运行。


  
还有一种是2812系统外扩了部分“引导”程序存储器，“设置flash配置寄存器的等待周期数”的这段代码放置在外扩的“引导”程序存储器内，而其他的所有程序代码都放在2812内部flash区，系统复位后，首先运行外扩的“引导”程序存储器内的程序，一旦完成了对内部flash配置寄存器的设置后，即跳转到flash程序区执行正常的功能程序。


  正如上述，对2812外部接口XINTF配置寄存器的设置代码，也是不能在“外部”程序代码区进行的，为了实现对其的正常设置，可仿照上述办法进行相关操作。


2007.8.13 19:06 作者：wind 收藏 | 评论：0
成功烧写TMS320F2812经验
分类:默认栏目用的是CCS2.20版本提供的SDFLASH,设置好SDFLASH后,主要是要将需要下载的.out文件写进去.
关键在于在线仿真时的cmd文件要加以更换成新的.使用的是:






-o .DebugPULSE_AD.out             
-m PULSE_AD.map


MEMORY
{
PAGE 0 : 
   OTP         : origin = 0x3D7800, length = 0x000800
   FLASHJ      : origin = 0x3D8000, length = 0x002000
   FLASHI      : origin = 0x3DA000, length = 0x002000
   FLASHH      : origin = 0x3DC000, length = 0x004000 
   FLASHG      : origin = 0x3E0000, length = 0x004000
   FLASHF      : origin = 0x3E4000, length = 0x004000
   FLASHE      : origin = 0x3E8000, length = 0x004000 
   FLASHD      : origin = 0x3EC000, length = 0x004000
   FLASHC      : origin = 0x3F0000, length = 0x004000
   FLASHB      : origin = 0x3F4000, length = 0x002000 
   FLASHA      : origin = 0x3F6000, length = 0x001FF6
   BEGIN       : origin = 0x3F7FF6, length = 0x000002
   PASSWDS     : origin = 0x3F7FF8, length = 0x000008
   ROM         : origin = 0x3FF000, length = 0x000FC0
   VECTORS     : origin = 0x3FFFC2, length = 0x00003E
         
PAGE 1 : 
   /* SARAM                     */     
   RAMM0M1    : origin = 0x000000, length = 0x000800


   /* Peripheral Frame 0:   */
   DEV_EMU    : origin = 0x000880, length = 0x000180
   FLASH_REGS : origin = 0x000A80, length = 0x000060
   CSM        : origin = 0x000AE0, length = 0x000010
   XINTF      : origin = 0x000B20, length = 0x000020
   CPU_TIMER0 : origin = 0x000C00, length = 0x000008
   CPU_TIMER1 : origin = 0x000C08, length = 0x000008                 
   CPU_TIMER2 : origin = 0x000C10, length = 0x000008                 
   PIE_CTRL   : origin = 0x000CE0, length = 0x000020
   PIE_VECT   : origin = 0x000D00, length = 0x000100


   /* Peripheral Frame 1:   */
   ECAN_A     : origin = 0x006000, length = 0x000100
   ECAN_AMBOX : origin = 0x006100, length = 0x000100


   /* Peripheral Frame 2:   */
   SYSTEM     : origin = 0x007010, length = 0x000020
   SPI_A      : origin = 0x007040, length = 0x000010
   SCI_A      : origin = 0x007050, length = 0x000010
   XINTRUPT   : origin = 0x007070, length = 0x000010
   GPIOMUX    : origin = 0x0070C0, length = 0x000020
   GPIODAT    : origin = 0x0070E0, length = 0x000020
   ADC        : origin = 0x007100, length = 0x000020
   EV_A       : origin = 0x007400, length = 0x000040
   EV_B       : origin = 0x007500, length = 0x000040
   SPI_B      : origin = 0x007740, length = 0x000010
   SCI_B      : origin = 0x007750, length = 0x000010
   MCBSP_A    : origin = 0x007800, length = 0x000040


   /* CSM Password Locations */
   CSM_PWL    : origin = 0x3F7FF8, length = 0x000008


   /* SARAM                    */     
   RAML0L1    : origin = 0x008000, length = 0x002000
   RAMH0      : origin = 0x3F8000, length = 0x002000        
}




SECTIONS
{
   /* Allocate program areas: */
   .reset              : > BEGIN       PAGE = 0
   vectors             : > VECTORS     PAGE = 0
   .cinit              : > FLASHJ      PAGE = 0
   .text               : > FLASHA       PAGE = 0


   /* Allocate data areas: */
   .stack              : > RAMM0M1     PAGE = 1
   .bss                : > RAML0L1     PAGE = 1
   .ebss               : > RAML0L1     PAGE = 1
   .const:                        load =         FLASHB PAGE 0, run = RAML0L1 
PAGE 1
        {
            /* Get Run Address        */
            __const_run = .;
            /* Mark Load Address*/
            *(.c_mark)
            /* Allocate .const        */
            *(.const)
            /* Compute Length        */
            __const_length = .-__const_run;
        }  
   
   .econst:                        load =         FLASHB PAGE 0, run = RAML0L1 
PAGE 1
        {
            /* Get Run Address        */
            __econst_run = .;
            /* Mark Load Address*/
            *(.ec_mark)
            /* Allocate .const        */
            *(.econst)
            /* Compute Length        */
            __econst_length = .-__econst_run;
        }    
   .sysmem             : > RAMH0       PAGE = 1


   /* Allocate IQ math areas: */
   IQmath              : > FLASHI      PAGE = 0   /* Math Code */
   IQmathFastTables    : > FLASHI      PAGE = 0   /* Math Tables in fast memory 
*/
   IQmathTables        : > ROM         PAGE = 0   /* Math Tables In ROM */
      
   /* Allocate Peripheral Frame 0 Register Structures:   */
   DevEmuRegsFile      : > DEV_EMU     PAGE = 1
   FlashRegsFile       : > FLASH_REGS  PAGE = 1
   CsmRegsFile         : > CSM         PAGE = 1
   XintfRegsFile       : > XINTF       PAGE = 1
   CpuTimer0RegsFile   : > CPU_TIMER0  PAGE = 1      
   CpuTimer1RegsFile   : > CPU_TIMER1  PAGE = 1      
   CpuTimer2RegsFile   : > CPU_TIMER2  PAGE = 1      
   PieCtrlRegsFile     : > PIE_CTRL    PAGE = 1      
   PieVectTable        : > PIE_VECT    PAGE = 1


   /* Allocate Peripheral Frame 2 Register Structures:   */
   ECanaRegsFile       : > ECAN_A      PAGE = 1   
   ECanaMboxesFile     : > ECAN_AMBOX  PAGE = 1


   /* Allocate Peripheral Frame 1 Register Structures:   */
   SysCtrlRegsFile     : > SYSTEM      PAGE = 1
   SpiaRegsFile        : > SPI_A       PAGE = 1
   SciaRegsFile        : > SCI_A       PAGE = 1
   XIntruptRegsFile    : > XINTRUPT    PAGE = 1
   GpioMuxRegsFile     : > GPIOMUX     PAGE = 1
   GpioDataRegsFile    : > GPIODAT     PAGE = 1
   AdcRegsFile         : > ADC         PAGE = 1
   EvaRegsFile         : > EV_A        PAGE = 1
   EvbRegsFile         : > EV_B        PAGE = 1
   ScibRegsFile        : > SCI_B       PAGE = 1
   McbspaRegsFile      : > MCBSP_A     PAGE = 1


   /* CSM Password Locations */
   CsmPwlFile          : > CSM_PWL     PAGE = 1


}






然后把lib文件替换成:rts2800_fl040830.lib
就可以啦.
希望你也成功!!!




本人qq: 15007807  欢迎以后交流. 
点评：
FLASH不用分这么细的,编大一点的程序会有麻烦
以下是本人做过的某项目CMD文件
MEMORY
{
PAGE 0 :
   /* For this example, H0 is split between PAGE 0 and PAGE 1 */  
   /* BEGIN is used for the "boot to HO" bootloader mode      */
   /* RESET is loaded with the reset vector only if           */
   /* the boot is from XINTF Zone 7.  Otherwise reset vector  */
   /* is fetched from boot ROM. See .reset section below      */
   
   RAMM0      : origin = 0x000000, length = 0x000400
   BEGIN      : origin = 0x3f7ff6, length = 0x000002  
   PRAMH0     : origin = 0x3d8000, length = 0x004000   /*   */
   RESET      : origin = 0x3FFFC0, length = 0x000002           
   
         
PAGE 1 : 


   /* For this example, H0 is split between PAGE 0 and PAGE 1 */


   LSARAM     : origin = 0x3de000, length = 0x008000 /*   */
   RAMM1      : origin = 0x000400, length = 0x000400
   DRAMH0     : origin = 0x3f8000, length = 0x001000 /*   */
   BUFA       : origin = 0x8000,   length=0x1000
   BUFB       : origin = 0x9000,   length=0x1000
   BUFC       : origin = 0x3f9000, length=0x1000
   RECORDDATA : origin = 0x80020,  length=0x700
   PARAMETER  : origin = 0x80725,  length=0x20
   PASSWORD   : origin = 0x80005,  length=0x08
}




SECTIONS
{
   /* Setup for "boot to H0" mode: 
      The codestart section (found in DSP28_CodeStartBranch.asm)
      re-directs execution to the start of user code.  
      Place this section at the start of H0  */


   codestart        : > BEGIN,        PAGE = 0
   ramfuncs         : > PRAMH0        PAGE = 0  
   .text            : > PRAMH0,       PAGE = 0
   .cinit           : > PRAMH0,       PAGE = 0
   .pinit           : > PRAMH0,       PAGE = 0
   .switch          : > RAMM0,        PAGE = 0
   .reset           : > RESET,        PAGE = 0, TYPE = DSECT /* not used, */
   
   .stack           : > RAMM1,        PAGE = 1
   .ebss            : > DRAMH0,       PAGE = 1
   .econst          : > LSARAM,       PAGE = 1      
   .esysmem         : > DRAMH0,       PAGE = 1
   .bufferA         : {}>BUFA         PAGE 1 
   .bufferB         : {}>BUFB         PAGE 1  
   .bufferC         : {}>BUFC         PAGE 1  
   .RecordData      : {}>RECORDDATA   PAGE 1
   .parameter       : {}>PARAMETER    PAGE 1
   .password        : {}>PASSWORD     PAGE 1
}


2007.8.13 19:04 作者：wind 收藏 | 评论：0
于DDS的简单介绍
分类:默认栏目DDS同DSP（数字信号处理）一样，是一项关键的数字化技术。DDS是直接数字式频率合成器（Direct Digital 
Synthesizer）的英文缩写。与传统的频率合成器相比，DDS具有低成本、低功耗、高分辨率和快速转换时间等优点，广泛使用在电信与电子仪器领域，是实现设备全数字化的一个关键技术。 


  
一块DDS芯片中主要包括频率控制寄存器、高速相位累加器和正弦计算器三个部分（如Q2220）。频率控制寄存器可以串行或并行的方式装载并寄存用户输入的频率控制码；而相位累加器根据频率控制码在每个时钟周期内进行相位累加，得到一个相位值；正弦计算器则对该相位值计算数字化正弦波幅度（芯片一般通过查表得到）。DDS芯片输出的一般是数字化的正弦波，因此还需经过高速D/A转换器和低通滤波器才能得到一个可用的模拟频率信号。 


 
 另外，有些DDS芯片还具有调幅、调频和调相等调制功能及片内D/A变换器（如AD7008）。 
 
DDS有如下优点：⑴ 频率分辨率高，输出频点多；⑵频率切换速度快，可达us量级；⑶ 频率切换时相位连续；⑷ 可以输出宽带正交信号；⑸ 
输出相位噪声低，对参考频率源的相位噪声有改善作用；⑹可以产生任意波形；⑺ 
全数字化实现，便于集成，体积小，重量轻，因此八十年代以来各国都在研制和发展各自的DDS产品，如美国QUALCOMM公司的Q2334，Q2220；STANFORD公司的STEL-1175，STEL-1180；AD公司的AD7008，AD9850，AD9854等。这些DDS芯片的时钟频率从几十兆赫兹到几百兆赫兹不等，芯片从一般功能到集成有D/A转换器和正交调制器。
2007.8.13 18:44 作者：wind 收藏 | 评论：0
使用C/C 语言编写基于DSP程序的注意事项
分类:默认栏目 1、 
不影响执行速度的情况下，可以使用c或c/c++语言提供的函数库，也可以自己设计函数，这样更易于使用“裁缝师”优化处理，例如：进行绝对值运算，可以调用fabs()或abs()函数，也可以使用if...else...判断语句来替代。 


    2、 要非常谨慎地使用局部变量，根据自己项目开发的需要，应尽可能多地使用全局变量和静态变量。
    3、 
一定要非常重视中断向量表的问题，很多朋友对中断向量表的调用方式不清楚。其实中断向量表中的中断名是任意取定的，dsp是不认名字的，它只认地址！！中断向量表要重新定位。这一点很重要。
    4、 
要明确dsp软件开发的第一步是对可用存储空间的分析，存储空间分配好坏关系到一个dsp程序员的水平。对于dsp，我们有两种名称的存储空间，一种是物理空间，另一种是映射空间。物理空间是dsp上可以存放数据和程序的实际空间（包括外部存储器），我们的数据和程序最终放到物理空间上，但我们并不能直接访问它们。我们要访问物理空间，必须借助于映射空间才行！！但是映射空间本身是个“虚”空间，是个不存在的空间。所以，往往是映射空间远远大于实际的物理空间，有些映射空间，如io映射空间，它本身还代表了一种接口。只有那些物理空间映射到的映射空间才是我们真正可访问（读或写）的存储空间。
    5、 尽可能地减少除法运算，而尽可能多地使用乘法和加法运算代替。
    6、 
如果ti公司或第三方软件合作商提供了dsplib或其他的合法子程序库供调用，应尽可能地调用使用。这些子程序均使用用汇编写成，更为重要之处是通过了tms320算法标准测试。而且，常用的数字信号处理算法均有包括！！
    7、 尽可能地采用内联函数！！而不用一般的函数！！可以提高代码的集成度。
    8、 编程风格力求简炼！！尽可能用c语言而不用c++语言。我个人感到虽然c++终代码长了一些，好象对执行速度没有影响。
    9、 
因为在c5000中double型和float型均占有2个字，所以都可以使用，而且，可以直接将int型赋给float型或double型，但，尽可能地多使用int数据类型代替！这一点需要注意！！
    10、 程序最后至少要加上一个空行，编译器当这个空行为结尾提示符。
    11、 大胆使用位运算符，非常好用！！
2007.8.13 18:09 作者：wind 收藏 | 评论：0
CMD文件的作用
分类:默认栏目在DSP里，程序执行过程中也有好多地方需要跳转，所以需要跳转的目标地址。如果你在编程序时知道你所要跳转的地址，那就更好的，但实际上，这是很不好控制的。所以就产生了.CMD。它有一个最大的好处，可以把每个段分配地址，所以比如你想从一个段跳到另一个段的时候，就很方便的知道这个段的起始地址。 


CMD 
它是用来分配rom和ram空间用的,告诉链接程序怎样计算地址和分配空间.所以不同的芯片就有不同大小的rom和ram.放用户程序的地方也不尽相同.所以要根据你的芯片进行修改.cmd文件分两部分.MEMORY和SECTIONS. 


MEMORY 
{ 
  PAGE 0 .......... 
  PAGE 1......... 
} 
SECTIONS 
{SECTIONS 
{ 
.vectors ................. 
.reset ................. 
................ 
} 


MEMORY是用来指定芯片的rom和ram的大小和划分出几个区间. 
PAGE 0 对应rom;PAGE 1对应ram 
PAGE 里包含的区间名字与其后面的参数反映了该区间的起始地址和长度. 
如: PAGE 0 : VECS(区间名字): origin(起始地址) = 0h , length (长度)=040h /*VECTORS*/ 
SECTIONS：(在程序里添加下面的段名如.vectors.用来指定该段名以下，另一个段名以上的程序(属于PAGE0)或数据(属于PAGE1)放到“>”符号后的空间名字所在的地方。 


如引用字段名“.vectors ”的程序或数据将被放到VECS ，VECS是PAGE0即是ROM空间 00H至40H的地方 
SECTIONS 
{ 
.vectors : { } > VECS PAGE 0 /* Interrupt vector table */ 
.reset :   { } > VECS PAGE 0 /* Reset code */ 
............ 
} 
.vectors，.reset都是段名。  加不加“.”随你便，即.vectors表示名为  “.vectors”的段。 
{}表示段的全部，{}> VECS PAGE 0表示将段的全部放入名为 VECS PAGE 0的内存区。 
example: 
/****************************************************************************/ 


/******** Specify the memory configuration **********************************/ 


/****************************************************************************/ 


MEMORY 
{ 
PAGE 0: VECS: origin = 00000h, length = 00040h 
         LOW: origin = 00040h, length = 03FC0h 
       SARAM: origin = 04000h, length = 00800h 
          B0: origin = 0FF00h, length = 00100h 
PAGE 1: B0: origin = 00200h, length = 00100h 
        B1: origin = 00300h, length = 00100h 
        B2: origin = 00060h, length = 00020h 
     SARAM: origin = 08000h, length = 00800h 
} 
/*--------------------------------------------------------------------------*/ 
/* SECTIONS ALLOCATION  */ 
/*--------------------------------------------------------------------------*/ 
SECTIONS 
{ 
.text : { } > LOW PAGE 0 
.cinit : { } > LOW PAGE 0 
.switch : { } > LOW PAGE 0 
.const : { } > SARAM PAGE 1 
.data : { } > SARAM PAGE 1 
.bss : { } > SARAM PAGE 1 
.stack : { } > SARAM PAGE 1 
.sysmem : { } > SARAM PAGE 1 
} 
1,系统定义: 
.cinit 存放C程序中的变量初值和常量; 
.const 存放C程序中的字符常量、浮点常量和用const声明的常量; 
.switch 存放C程序中switch语句的跳针表; 
.text 存放C程序的代码; 
.bss 为C程序中的全局和静态变量保留存储空间; 
.far 为C程序中用far声明的全局和静态变量保留空间; 
.stack 为C程序系统堆栈保留存储空间，用于保存返回地址、函数间的参数传递、存储局部变量和保存中间结果; 
.sysmem 用于C程序中malloc、calloc和realloc函数动态分配存储空间 
2,用户定义: 
#pragma CODE_SECTION (symbol, "section name"; 
#pragma DATA_SECTION (symbol, "section name" 






DSP的C语言的特殊性 
大家在使用51系列C语言时已经注意到，控制器的C语言和PC机上使用的C有一个显著的特点：经常要对硬件操作，程序中有大量针对控制器内部资源进行操作的语句。所以，开发者要明白怎样用C语言来操纵控制器的内部资源，既怎样用C语句操作寄存器和内部存储器等。 


举个例子，在51汇编中我们写 MOV A，#20H，汇编程序能够识别A是指累加器，而在51 C程序中我们写 
ACC=32；，编译器能够识别ACC是指累加器而不是一般的变量。即每一个寄存器都有一个专有名字供开发者使用，它们定义在一个头文件reg51.h 
中，程序员只需在程序的开始部分用#include“reg51.h”语句将该文件包含进来即可。注意：这些寄存器的名字不能用做变量名。 
同样，在TMS320F240的C语言中也有一个头文件C240.H定义各个寄存器的名称，这里摘录几条语句进行介绍。 
比如：#define IMR （（PORT）0x0004） 
#define XINT1_CR （（PORT）0x07070） 
IMR 
、XINT1_CR就对应两个寄存器，实际是寄存器的地址，用高级语言的说法是指针。我们也在程序的开始部分用#include“c240.h”语句将该文件包含进来。这样，在DSP的C语言中使用它们只需在前面加一个星号（*），例如， 


*IMR=0X1010；/* 将16进制数1010H赋给IMR寄存器 */ 
*XINT1_CR=0X0A0B0；/*将16进制数A0B0H赋给XINT1_CR寄存器 */ 


最好将c240.h这个文件打印出来，弄清楚各个寄存器的定义名称。 
TMS320F240芯片的C语言开发过程 
简单地说，整个过程包括以下五个步骤： 
1、编辑C语言源程序 
2、编译源程序（注意编译参数） 
3、链接目标文件（注意用CMD文件） 
4、在线仿真 
5、固化程序
2007.8.13 17:06 作者：wind 收藏 | 评论：0
电容的作用
分类:默认栏目1.电容器主要用于交流电路及脉冲电路中，在直流电路中电容器一般起隔断直流的作用。 
2.电容既不产生也不消耗能量，是储能元件。
3.电容器在电力系统中是提高功率因数的重要器件；在电子电路中是获得振荡、滤波、相移、旁路、耦合等作用的主要元件。 
4.因为在工业上使用的负载主要是电动机感性负载,所以要并电容这容性负载才能使电网平衡.
5.在接地线上,为什么有的也要通过电容后再接地咧?
答：在直流电路中是抗干扰，把干扰脉冲通过电容接地（在这次要作用是隔直——电路中的电位关系）；交流电路中也有这样通过电容接地的，一般容量较小，也是抗干扰和电位隔离作用.
6.电容补尝功率因数是怎么回事?
答：因为在电容上建立电压首先需要有个充电过程，随着充电过程，电容上的电压逐步提高，这样就会先有电流，后建立电压的过程，通常我们叫电流超前电压90度（电容电流回路中无电阻和电感元件时，叫纯电容电路）。电动机、变压器等有线圈的电感电路，因通过电感的电流不能突变的原因，它与电容正好相反，需要先在线圈两端建立电压，后才有电流（电感电流回路中无电阻和电容时，叫纯电感电路），纯电感电路的电流滞后电压90度。由于功率是电压乘以电流，当电压与电流不同时产生时（如：当电容器上的电压最大时，电已充满，电流为0；电感上先有电压时，电感电流也为0），这样，得到的乘积（功率）也为0！这就是无功。那么，电容的电压与电流之间的关系正好与电感的电压与电流的关系相反，就用电容来补偿电感产生的无功，这就是无功补偿的原理。


2007.8.13 15:16 作者：wind 收藏 | 评论：0
volatile的用法 
分类:默认栏目避免编译器优化的用法 转自<海涛的笔记>   _lindwen


volatile的本意是“易变的” 

由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：

static int i=0;

int main(void)
{
...
while (1)
{
if (i) dosomething();
}
}

/* Interrupt service routine. */
void ISR_2(void)
{
i=1;
}

程序的本意是希望ISR_2中断产生时，在main当中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此
可能只执行一次对从i到某寄存器的读***作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被
调用。如果将将变量加上volatile修饰，则编译器保证对此变量的读写***作都不会被优化（肯定执行）。此例中i也应该如此说明。

一般说来，volatile用在如下的几个地方：

1、中断服务程序中修改的供其它程序检测的变量需要加volatile；

2、多任务环境下各任务间共享的标志应该加volatile；

3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；

另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实
现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。

 

volatile 的含义
volatile总是与优化有关，编译器有一种技术叫做数据流分析，分析程序中的变量在哪里赋值、在哪里使用、在哪里失效，分析结果可以用于常量合并，常量传播等优化，进一步可以死代码消除。但有时这些优化不是程序所需要的，这时可以用volatile关键字禁止做这些优化，volatile的字面含义是易变的，它有下面的作用： 



1 不会在两个***作之间把volatile变量缓存在寄存器中。在多任务、中断、甚至setjmp环境下，变量可能被其他的程序改变，编译器 
自己无法知道，volatile就是告诉编译器这种情况。 

2 不做常量合并、常量传播等优化，所以像下面的代码： 
volatile int i = 1; 
if (i > 0) ... 

if的条件不会当作无条件真。 

3 对volatile变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到，编译器常常可以省略那个赋值***作，然而对Memory Mapped 
IO的处理是不能这样优化的。 

前面有人说volatile可以保证对内存***作的原子性，这种说法不大准确，其一，x86需要LOCK前缀才能在SMP下保证原子性，其二，RISC根本不能对内存直接运算，要保证原子性得用别的方法，如atomic_inc。 



对于jiffies，它已经声明为volatile变量，我认为直接用jiffies++就可以了，没必要用那种复杂的形式，因为那样也不能保证原子性。 

你可能不知道在Pentium及后续CPU中，下面两组指令 

inc jiffies 
;; 
mov jiffies, %eax 
inc %eax 
mov %eax, jiffies 

作用相同，但一条指令反而不如三条指令快。 
现举例说明（以Keil-c与a51为例
例子来自Keil FQA）,看完例子后你应该明白volatile的意思了，如果还不明白，那只好
再看一遍了。




例1.


void main (void)
{
      volatile int i;
      int j;


      i = 1;    //1    不被优化 i=1
      i = 2;    //2    不被优化 i=1
      i = 3;    //3    不被优化 i=1


      j = 1;    //4    被优化
      j = 2;    //5    被优化
      j = 3;    //6    j = 3
}
---------------------------------------------------------------------
例2.


函数：


void func (void)
{
      unsigned char xdata xdata_junk;
      unsigned char xdata *p = &xdata_junk;
      unsigned char t1, t2;


      t1 = *p;
      t2 = *p;
}


编译的汇编为：


0000 7E00      R       MOV       R6,#HIGH xdata_junk
0002 7F00      R       MOV       R7,#LOW xdata_junk
;---- Variable 'p' assigned to Register 'R6/R7' ----


0004 8F82            MOV       DPL,R7
0006 8E83            MOV       DPH,R6


;!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 注意
0008 E0              MOVX      A,@DPTR
0009 F500      R       MOV       t1,A


000B F500      R       MOV       t2,A
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
000D 22              RET     


将函数变为：
void func (void)
{
      volatile unsigned char xdata xdata_junk;
      volatile unsigned char xdata *p = &xdata_junk;
      unsigned char t1, t2;


      t1 = *p;
      t2 = *p;
}


编译的汇编为：
0000 7E00      R       MOV       R6,#HIGH xdata_junk
0002 7F00      R       MOV       R7,#LOW xdata_junk
;---- Variable 'p' assigned to Register 'R6/R7' ----


0004 8F82            MOV       DPL,R7
0006 8E83            MOV       DPH,R6


;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
0008 E0              MOVX      A,@DPTR
0009 F500      R       MOV       t1,A          ;a处


000B E0              MOVX      A,@DPTR
000C F500      R       MOV       t2,A
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


000E 22              RET     




比较结果可以看出来，未用volatile关键字时，只从*p所指的地址读一次
如在a处*p的内容有变化，则t2得到的则不是真正*p的内容。


---------------------------------------------------------------------
例3




volatile unsigned char bdata var;    // use volatile keyword here
sbit var_0 = var^0;
sbit var_1 = var^1;
unsigned char xdata values[10];


void main (void)    {
    unsigned char i;


    for (i = 0; i < sizeof (values); i++)    {
      var = values[i];
      if (var_0)    {
        var_1 = 1;      //a处
              
        values[i] = var;    // without the volatile keyword, the compiler
                          // assumes that 'var' is unmodified and does not
                          // reload the variable content.
      }
    }
}




在此例中，如在a处到下一句运行前，var如有变化则不会，如var=0xff; 则在
values[i] = var;得到的还是values[i] = 1;


---------------------------------------------------------------------
应用举例：


例1.
#define DBYTE ((unsigned char volatile data    *) 0)


说明：此处不用volatile关键字，可能得不到真正的内容。
---------------------------------------------------------------------


例2.




#define TEST_VOLATILE_C 


//***************************************************************
// verwendete Include Dateien
//***************************************************************
#if __C51__ < 600
    #error: !! Keil 版本不正确
#endif


//***************************************************************
// 函数 void v_IntOccured(void)
//***************************************************************
extern void v_IntOccured(void);


//***************************************************************
// 变量定义
//***************************************************************
char xdata cValue1;            //全局xdata
char volatile xdata cValue2; //全局xdata


//***************************************************************
// 函数： v_ExtInt0()
// 版本：
// 参数：
// 用途：cValue1++,cValue2++
//***************************************************************
void v_ExtInt0(void) interrupt 0 {
    cValue1++;
    cValue2++; 
}        


//***************************************************************
// 函数： main()
// 版本：
// 参数：
// 用途：测试volatile
//***************************************************************


void main() {
char cErg;


//1. 使cErg=cValue1;
cErg = cValue1;


//2. 在此处仿真时手动产生中断INT0,使cValue1++; cValue2++
if (cValue1 != cErg)
    v_IntOccured();


//3. 使cErg=cValue2;
cErg = cValue2;


//4. 在此处仿真时手动产生中断INT0,使cValue1++; cValue2++
if (cValue2 != cErg)
    v_IntOccured();
  
//5. 完成
    while (1);
}


//***************************************************************
// 函数： v_IntOccured()
// 版本：
// 参数：
// 用途： 死循环
//***************************************************************
void v_IntOccured() {
    while(1);
}




仿真可以看出，在没有用volatile时，即2处，程序不能进入v_IntOccured();
但在4处可以进入v_IntOccured();


2007.8.13 09:41 作者：wind 收藏 | 评论：0
结构体（1） 
分类:默认栏目什么是结构体？ 


　　简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以做为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。 




　　定义结构体使用struct修饰符，例如： 
struct test 
{ 
float a; 
int b; 
}; 
　　上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。 


　　由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。
test pn1; 
　　这样就定义了一test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作。 


　　注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存。 


　　结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。 


　　结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子：
#include    
#include    
using namespace std;  
  
struct test//定义一个名为test的结构体  
{  
    int a;//定义结构体成员a  
    int b;//定义结构体成员b  
};  
  
void main()      
{  
    test pn1;//定义结构体变量pn1  
    test pn2;//定义结构体变量pn2  
  
    pn2.a=10;//通过成员操作符.给结构体变量pn2中的成员a赋值  
    pn2.b=3;//通过成员操作符.给结构体变量pn2中的成员b赋值  
  
    pn1=pn2;//把pn2中所有的成员值复制给具有相同结构的结构体变量pn1  
    cout<    cout<  
    test *point;//定义结构指针  
  
    point=&pn2;//指针指向结构体变量pn2的内存地址  
    cout<    point->a=99;//通过结构指针修改结构体变量pn2成员a的值  
    cout<    cout<a<<"|"<b<    cin.get();  
} 
　　总之，结构体可以描述数组不能够清晰描述的结构，它具有数组所不具备的一些功能特性。
2007.8.12 20:31 作者：wind 收藏 | 评论：0
位段 
分类:默认栏目位段，将一个字节分为几段来存放几个信息。所谓位段是以位为单位定义长度的结构体类型中的成员。如：
struct packed-data{
unsigned a:2; 
unsigned b:6;
unsigned c:4;
unsigned d:4;
int I;
}data;
其中a,b,c,d分别占2位,6位,4位,4位。I为整型，占4 个字节。
其中a、b、c、d分别占2位、6位、4位、4位。i为整型。共占4个字节。也可以使各个位段不恰好占满一个字节。如：
　    　struct　packed-data
　　　　  {unsigned　a∶2；
            unsigned　b∶3；
            unsigned　c∶4；
            int　i；
　　　 　 }；
　　    struct　packed-data　data；
其中a、b、c共占9位，占1个字节多，不到2个字节。它的后面为int型，占2个字节。在a、b、c之后7位空间闲置不用，i从另一字节开头起存放。
对于位段成员的引用如下：
data.a = 
2;等，但要注意赋值时，不要超出位段定义的范围。如位段成员a定义为2位，最大值为3，即(11)2，所以data.a=5;就会取5的两个低位进行赋值，就得不到想要的值了。
关于位段的定义和引用，有几点重要说明：
①若某一个段要从另一个字开始存放，可以定义：
unsigned a:1;
unsigned b:2;
unsigned :0;
unsigned c:3; (另一单元)
使用长度为0的位段，作用就是使下一个位段从下一个存储单元开始存放。
②一个位段必须存放在用一个存储单元中，不能跨两个单元。
如：
struct T {
unsigned char a : 4;
unsigned char b : 6;
};
　　结构T的成员a在一个存储单元中，b则在另一个存储单元中。
③可以定义无名位段。如：
unsigned a:1;
unsigned :2; (这两位空间不用)
unsigned b:3;
④位段的长度不能大于存储单元的长度，也不能定义位段数组。 




2007.8.12 20:26 作者：wind 收藏 | 评论：0
不同编译器处理位段的差异 
分类:默认栏目CCS里面认位段是从高位开始的，而Keil和凌阳单片机的编译器UNSP IDE以及NIOS II 
IDE，C++Builder里认位段是从低位开始的
同样做一个结构体，在Keil、UNSP IDE、NIOS II IDE、C++Builder里要这样：
#define Uint unsigned int
typedef struct
{
 Uint bit0 : 1;
 Uint bit1 : 1;
 Uint bit2 : 1;
 Uint bit3 : 1;
 Uint bit4 : 1;
 Uint bit5 : 1;
 Uint bit6  : 1;
 Uint bit7  : 1;
 Uint bit8  : 1;
 Uint bit9  : 1;
 Uint bit10  : 1;
 Uint bit11  : 1;
 Uint bit12  : 1;
 Uint bit13  : 1;
 Uint bit14  : 1;
 Uint bit15  : 1;
}Bit;
而在CCS里就应该这样：
#define Uint unsigned int
typedef struct
{
 Uint bit15 : 1;
 Uint bit14 : 1;
 Uint bit13 : 1;
 Uint bit12 : 1;
 Uint bit11 : 1;
 Uint bit10 : 1;
 Uint bit9  : 1;
 Uint bit8  : 1;
 Uint bit7  : 1;
 Uint bit6  : 1;
 Uint bit5  : 1;
 Uint bit4  : 1;
 Uint bit3  : 1;
 Uint bit2  : 1;
 Uint bit1  : 1;
 Uint bit0  : 1;
}Bit;
2007.8.12 17:21 作者：wind 收藏 | 评论：1
在ccs下建立一个工程的步骤
分类:默认栏目建立一个工程的步骤：1.在C：ti或任意目录下建立工程文件名如###.pjt 
2.将dsp头文件拷到此文件夹下。将这些头文件添加到工程中，注意：有一个文件DSP281x_usDelay.asm特殊.由于它是asm文件，当在默认的文件类型下全选的时候可能不会选到它，要在文件类型列表里点All 
files然后全选。3。在工程下建立主函数C文件，并添加到工程中。4。添加F2812_EzDSP_RAM_lnk.cmd和DSP281x_Headers_nonBIOS.cmd文件　5。添加库文件在C:tic2000cgtoolslibrts2800_ml.6.编译运行。 




如果出现下面的错误
undefined                        first referenced
 symbol                              in file
---------                        ----------------
_main                            C:tic2000cgtoolslibrts2800_ml.lib
>>   error: symbol referencing errors - './Debug/sci7.out' not built
Build Complete,
  1 Errors, 0 Warnings, 0 Remarks.


这是因为缺少main 这个文件，只要将它添加到工程文件里!
 
2007.8.7 21:32 作者：wind 收藏 | 评论：0
DSP外部中断
分类:默认栏目要使用外部中断要从两方面进行准备：首先，在硬件上必须将中断信号引到DSP的外部中断引脚上。比如：FPGA的一个output发出中断请求信号那么就将这个管脚与DSP的XINT1相连，XINT1可以通过一个4.7k的电阻上拉到3.3v, 
 也可以不拉。其次是在软件上的配置：1.初始外部中断寄存器
void Xint1_init(void)
{
  DINT;
  XIntruptRegs.XINT1CR.bit.ENABLE=1;//使能外部中断
  XIntruptRegs.XINT1CR.bit.POLARITY=1;//中断产生在上升沿，若为0中断产生在下降沿
  EINT;
}
由于这是一个函数，所以也要有函数声明，函数调用，函数定义。
２　使能cpu INT1　中断
　　PieCtrlRegs.PIEIER1.bit.INTx4 = 1; //Enable all XINT1 interrupt
   IER |= 0x100; // Enable CPU INT
   IER |= 0x0001;  // enable PIEIER1, and INT1


3.编写中断服务程序，
interrupt void  Xint1_ISR(void)
{
 .......
   PieCtrlRegs.PIEACK.all|=0x0001;
}
4将中断服务程序入口地址赋给中断向量表
PieVectTable.XINT1=&Xint1_ISR;
总结起来使用外部中断的步骤如下：
1声明外部中断服务程序和外部中断初始化函数
void Xint1_init(void);
interrupt void Xint1_ISR(void);
2将中断服务程序入口地址赋给中断向量表
PieVectTable.XINT1=&Xint1_ISR;
3使能cpu INT1　中断
IER |= 0x0001;  // enable PIEIER1, and INT1
PieCtrlRegs.PIEIER1.bit.INTx4 = 1; //Enable all XINT1 interrupt
4. 在主函数体外定义专断初始化函数和中断服务程序
2007.8.7 21:30 作者：wind 收藏 | 评论：0
ti2812中用C语言来实现中断的说明
分类:默认栏目F2812中用C语言来实现中断的说明：
1.首先在.cmd中定位系统中断表：
MEMORY
{
PAGE 0 : 
......................................
PAGE 1 : 
......................................
   PIE_VECT   : origin = 0x000D00, length = 0x000100


......................................         
}




SECTIONS
{
   ................................... 
   PieVectTable      : > PIE_VECT,   PAGE = 1
.....................................
}
2.在C中制定该中断的结构体：
#pragma DATA_SECTION(PieVectTable,"PieVectTable");
struct PIE_VECT_TABLE PieVectTable;（在DSP28_GlobalVariableDefs.C中初始化）
3.用一组常数（按照中断向量的顺序）初始化该名字为PIE_VECT_TABLE的表：
typedef interrupt void(*PINT)(void);这里有些一问，一下应该为函数名？？


// Define Vector Table:
struct PIE_VECT_TABLE {


// Reset is never fetched from this table.  
// It will always be fetched from 0x3FFFC0 in either
// boot ROM or XINTF Zone 7 depending on the state of
// the XMP/MC input signal.  On the F2810 it is always
// fetched from boot ROM. 


      PINT     PIE1_RESERVED;  
      PINT     PIE2_RESERVED;
      PINT     PIE3_RESERVED;
      PINT     PIE4_RESERVED;
      PINT     PIE5_RESERVED;
      PINT     PIE6_RESERVED;
      PINT     PIE7_RESERVED;
      PINT     PIE8_RESERVED;
      PINT     PIE9_RESERVED;
      PINT     PIE10_RESERVED;
      PINT     PIE11_RESERVED;
      PINT     PIE12_RESERVED;
      PINT     PIE13_RESERVED;


// Non-Peripheral Interrupts:
      PINT     XINT13;    // XINT13
      PINT     TINT2;     // CPU-Timer2
      PINT     DATALOG;   // Datalogging interrupt
      PINT     RTOSINT;   // RTOS interrupt
      PINT     EMUINT;    // Emulation interrupt
      PINT     XNMI;      // Non-maskable interrupt
      PINT     ILLEGAL;   // Illegal operation TRAP
      PINT     USER0;     // User Defined trap 0
      PINT     USER1;     // User Defined trap 1
      PINT     USER2;     // User Defined trap 2
      PINT     USER3;     // User Defined trap 3
      PINT     USER4;     // User Defined trap 4
      PINT     USER5;     // User Defined trap 5
      PINT     USER6;     // User Defined trap 6
      PINT     USER7;     // User Defined trap 7
      PINT     USER8;     // User Defined trap 8
      PINT     USER9;     // User Defined trap 9
      PINT     USER10;    // User Defined trap 10
      PINT     USER11;    // User Defined trap 11
      
// Group 1 PIE Peripheral Vectors:
      PINT     PDPINTA;   // EV-A
      PINT     PDPINTB;   // EV-B
      PINT     rsvd1_3;
      PINT     XINT1;     
      PINT     XINT2;
      PINT     ADCINT;    // ADC
      PINT     TINT0;     // Timer 0
      PINT     WAKEINT;   // WD
           
// Group 2 PIE Peripheral Vectors:
      PINT     CMP1INT;   // EV-A
      PINT     CMP2INT;   // EV-A
      PINT     CMP3INT;   // EV-A
      PINT     T1PINT;    // EV-A
      PINT     T1CINT;    // EV-A
      PINT     T1UFINT;   // EV-A
      PINT     T1OFINT;   // EV-A
      PINT     rsvd2_8;
      
// Group 3 PIE Peripheral Vectors:
      PINT     T2PINT;    // EV-A
      PINT     T2CINT;    // EV-A
      PINT     T2UFINT;   // EV-A
      PINT     T2OFINT;   // EV-A
      PINT     CAPINT1;   // EV-A
      PINT     CAPINT2;   // EV-A
      PINT     CAPINT3;   // EV-A
      PINT     rsvd3_8;
      
// Group 4 PIE Peripheral Vectors:
      PINT     CMP4INT;   // EV-B
      PINT     CMP5INT;   // EV-B
      PINT     CMP6INT;   // EV-B
      PINT     T3PINT;    // EV-B
      PINT     T3CINT;    // EV-B
      PINT     T3UFINT;   // EV-B
      PINT     T3OFINT;   // EV-B
      PINT     rsvd4_8;      
     
// Group 5 PIE Peripheral Vectors:
      PINT     T4PINT;    // EV-B
      PINT     T4CINT;    // EV-B
      PINT     T4UFINT;   // EV-B
      PINT     T4OFINT;   // EV-B
      PINT     CAPINT4;   // EV-B
      PINT     CAPINT5;   // EV-B
      PINT     CAPINT6;   // EV-B
      PINT     rsvd5_8;      


// Group 6 PIE Peripheral Vectors:
      PINT     SPIRXINTA; // SPI-A
      PINT     SPITXINTA; // SPI-A
      PINT     rsvd6_3;
      PINT     rsvd6_4;
      PINT     MRINTA;    // McBSP-A
      PINT     MXINTA;    // McBSP-A
      PINT     rsvd6_7;
      PINT     rsvd6_8;
      
// Group 7 PIE Peripheral Vectors:
      PINT     rsvd7_1;
      PINT     rsvd7_2;
      PINT     rsvd7_3;
      PINT     rsvd7_4;
      PINT     rsvd7_5;
      PINT     rsvd7_6;
      PINT     rsvd7_7;
      PINT     rsvd7_8;


// Group 8 PIE Peripheral Vectors:
      PINT     rsvd8_1;
      PINT     rsvd8_2;
      PINT     rsvd8_3;
      PINT     rsvd8_4;
      PINT     rsvd8_5;
      PINT     rsvd8_6;
      PINT     rsvd8_7;
      PINT     rsvd8_8; 


// Group 9 PIE Peripheral Vectors:   
      PINT     RXAINT;    // SCI-A
      PINT     TXAINT;    // SCI-A
      PINT     RXBINT;    // SCI-B
      PINT     TXBINT;    // SCI-B
      PINT     ECAN0INTA; // eCAN
      PINT     ECAN1INTA; // eCAN
      PINT     rsvd9_7;
      PINT     rsvd9_8;


// Group 10 PIE Peripheral Vectors:
      PINT     rsvd10_1;
      PINT     rsvd10_2;
      PINT     rsvd10_3;
      PINT     rsvd10_4;
      PINT     rsvd10_5;
      PINT     rsvd10_6;
      PINT     rsvd10_7;
      PINT     rsvd10_8;
            
// Group 11 PIE Peripheral Vectors:
      PINT     rsvd11_1;
      PINT     rsvd11_2;
      PINT     rsvd11_3;
      PINT     rsvd11_4;
      PINT     rsvd11_5;
      PINT     rsvd11_6;
      PINT     rsvd11_7;
      PINT     rsvd11_8;


// Group 12 PIE Peripheral Vectors:
      PINT     rsvd12_1;
      PINT     rsvd12_2;
      PINT     rsvd12_3;
      PINT     rsvd12_4;
      PINT     rsvd12_5;
      PINT     rsvd12_6;
      PINT     rsvd12_7;
      PINT     rsvd12_8;
};
然后在使我们在.cmd文件中定义的表有以上属性：
extern struct PIE_VECT_TABLE PieVectTable;(在.h文件中）
4.初始化该表（在.c文件中）使之能够为主程序所使用：
const struct PIE_VECT_TABLE PieVectTableInit = {


      PIE_RESERVED,  // Reserved space
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   
      PIE_RESERVED,   




// Non-Peripheral Interrupts
      INT13_ISR,     // XINT13 or CPU-Timer 1
      INT14_ISR,     // CPU-Timer2
      DATALOG_ISR,   // Datalogging interrupt
      RTOSINT_ISR,   // RTOS interrupt
      EMUINT_ISR,    // Emulation interrupt
      NMI_ISR,       // Non-maskable interrupt
      ILLEGAL_ISR,   // Illegal operation TRAP
      USER0_ISR,     // User Defined trap 0
      USER1_ISR,     // User Defined trap 1
      USER2_ISR,     // User Defined trap 2
      USER3_ISR,     // User Defined trap 3
      USER4_ISR,     // User Defined trap 4
      USER5_ISR,     // User Defined trap 5
      USER6_ISR,     // User Defined trap 6
      USER7_ISR,     // User Defined trap 7
      USER8_ISR,     // User Defined trap 8
      USER9_ISR,     // User Defined trap 9
      USER10_ISR,    // User Defined trap 10
      USER11_ISR,    // User Defined trap 11


// Group 1 PIE Vectors
      PDPINTA_ISR,   // EV-A
      PDPINTB_ISR,   // EV-B
      rsvd_ISR,
      XINT1_ISR,     
      XINT2_ISR,
      ADCINT_ISR,    // ADC
      TINT0_ISR,     // Timer 0
      WAKEINT_ISR,   // WD


// Group 2 PIE Vectors
      CMP1INT_ISR,   // EV-A
      CMP2INT_ISR,   // EV-A
      CMP3INT_ISR,   // EV-A
      T1PINT_ISR,    // EV-A
      T1CINT_ISR,    // EV-A
      T1UFINT_ISR,   // EV-A
      T1OFINT_ISR,   // EV-A
      rsvd_ISR,
      
// Group 3 PIE Vectors
      T2PINT_ISR,    // EV-A
      T2CINT_ISR,    // EV-A
      T2UFINT_ISR,   // EV-A
      T2OFINT_ISR,   // EV-A
      CAPINT1_ISR,   // EV-A
      CAPINT2_ISR,   // EV-A
      CAPINT3_ISR,   // EV-A
      rsvd_ISR,
      
// Group 4 PIE Vectors
      CMP4INT_ISR,   // EV-B
      CMP5INT_ISR,   // EV-B
      CMP6INT_ISR,   // EV-B
      T3PINT_ISR,    // EV-B
      T3CINT_ISR,    // EV-B
      T3UFINT_ISR,   // EV-B
      T3OFINT_ISR,   // EV-B
      rsvd_ISR,      
     
// Group 5 PIE Vectors
      T4PINT_ISR,    // EV-B
      T4CINT_ISR,    // EV-B
      T4UFINT_ISR,   // EV-B
      T4OFINT_ISR,   // EV-B
      CAPINT4_ISR,   // EV-B
      CAPINT5_ISR,   // EV-B
      CAPINT6_ISR,   // EV-B
      rsvd_ISR,      


// Group 6 PIE Vectors
      SPIRXINTA_ISR,   // SPI-A
      SPITXINTA_ISR,   // SPI-A
      rsvd_ISR,
      rsvd_ISR,
      MRINTA_ISR,    // McBSP-A
      MXINTA_ISR,    // McBSP-A
      rsvd_ISR,
      rsvd_ISR,
      
// Group 7 PIE Vectors
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   


// Group 8 PIE Vectors
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      
// Group 9 PIE Vectors     
      SCIRXINTA_ISR, // SCI-A
      SCITXINTA_ISR, // SCI-A
      SCIRXINTB_ISR, // SCI-B
      SCITXINTB_ISR, // SCI-B
      ECAN0INTA_ISR, // eCAN
      ECAN1INTA_ISR, // eCAN
      rsvd_ISR,   
      rsvd_ISR,   
      
// Group 10 PIE Vectors
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
            
// Group 11 PIE Vectors
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   


// Group 12 PIE Vectors
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
      rsvd_ISR,   
};




//---------------------------------------------------------------------------
// InitPieVectTable: 
//---------------------------------------------------------------------------
// This function initializes the PIE vector table to a known state.
// This function must be executed after boot time.
//


void InitPieVectTable(void)
{
int16 i;
Uint32 *Source = (void *) &PieVectTableInit;
Uint32 *Dest = (void *) &PieVectTable;


EALLOW; 
for(i=0; i < 128; i++)
*Dest++ = *Source++; 
EDIS;


// Enable the PIE Vector Table
PieCtrl.PIECRTL.bit.ENPIE = 1; 


}
5.中断服务程序：
让以上的数值指向你所要的服务程序，例如：
PieVectTable.TINT2 = &ISRTimer2;
那么，ISRTimer2也就成了中断服务程序，
×××切记：一定要在主程序的开始先声明该程序：
interrupt void ISRTimer2(void);


.............
.............
然后按照您的需要编制该程序：
interrupt void ISRTimer2(void)
{
CpuTimer2.InterruptCount++;
}


2007.8.7 21:20 作者：wind 收藏 | 评论：0
关于F2812中用C语言来实现中断的说明
分类:默认栏目初始化该表（在.c文件中）使之能够为主程序所使用：
const struct PIE_VECT_TABLE PieVectTableInit = { 
      PIE_RESERVED,  // Reserved space
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
      PIE_RESERVED,  
// Non-Peripheral Interrupts
      INT13_ISR,     // XINT13 or CPU-Timer 1
      INT14_ISR,     // CPU-Timer2
      DATALOG_ISR,   // Datalogging interrupt
      RTOSINT_ISR,   // RTOS interrupt
      EMUINT_ISR,    // Emulation interrupt
      NMI_ISR,       // Non-maskable interrupt
      ILLEGAL_ISR,   // Illegal operation TRAP
      USER0_ISR,     // User Defined trap 0
      USER1_ISR,     // User Defined trap 1
      USER2_ISR,     // User Defined trap 2
      USER3_ISR,     // User Defined trap 3
      USER4_ISR,     // User Defined trap 4
      USER5_ISR,     // User Defined trap 5
      USER6_ISR,     // User Defined trap 6
      USER7_ISR,     // User Defined trap 7
      USER8_ISR,     // User Defined trap 8
      USER9_ISR,     // User Defined trap 9
      USER10_ISR,    // User Defined trap 10
      USER11_ISR,    // User Defined trap 11
// Group 1 PIE Vectors
      PDPINTA_ISR,   // EV-A
      PDPINTB_ISR,   // EV-B
      rsvd_ISR,
      XINT1_ISR,    
      XINT2_ISR,
      ADCINT_ISR,    // ADC
      TINT0_ISR,     // Timer 0
      WAKEINT_ISR,   // WD
// Group 2 PIE Vectors
      CMP1INT_ISR,   // EV-A
      CMP2INT_ISR,   // EV-A
      CMP3INT_ISR,   // EV-A
      T1PINT_ISR,    // EV-A
      T1CINT_ISR,    // EV-A
      T1UFINT_ISR,   // EV-A
      T1OFINT_ISR,   // EV-A
      rsvd_ISR,
      
// Group 3 PIE Vectors
      T2PINT_ISR,    // EV-A
      T2CINT_ISR,    // EV-A
      T2UFINT_ISR,   // EV-A
      T2OFINT_ISR,   // EV-A
 T2OFINT_ISR,   // EV-A
      CAPINT1_ISR,   // EV-A
      CAPINT2_ISR,   // EV-A
      CAPINT3_ISR,   // EV-A
      rsvd_ISR,
      
// Group 4 PIE Vectors
      CMP4INT_ISR,   // EV-B
      CMP5INT_ISR,   // EV-B
      CMP6INT_ISR,   // EV-B
      T3PINT_ISR,    // EV-B
      T3CINT_ISR,    // EV-B
      T3UFINT_ISR,   // EV-B
      T3OFINT_ISR,   // EV-B
      rsvd_ISR,      
    
// Group 5 PIE Vectors
      T4PINT_ISR,    // EV-B
      T4CINT_ISR,    // EV-B
      T4UFINT_ISR,   // EV-B
      T4OFINT_ISR,   // EV-B
      CAPINT4_ISR,   // EV-B
      CAPINT5_ISR,   // EV-B
CAPINT6_ISR,   // EV-B
      rsvd_ISR,      
// Group 6 PIE Vectors
      SPIRXINTA_ISR,   // SPI-A
      SPITXINTA_ISR,   // SPI-A
      rsvd_ISR,
      rsvd_ISR,
      MRINTA_ISR,    // McBSP-A
      MXINTA_ISR,    // McBSP-A
      rsvd_ISR,
      rsvd_ISR,
      
// Group 7 PIE Vectors
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
// Group 8 PIE Vectors
      rsvd_ISR,  
      rsvd_ISR,  
rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      
// Group 9 PIE Vectors    
      SCIRXINTA_ISR, // SCI-A
      SCITXINTA_ISR, // SCI-A
      SCIRXINTB_ISR, // SCI-B
      SCITXINTB_ISR, // SCI-B
      ECAN0INTA_ISR, // eCAN
      ECAN1INTA_ISR, // eCAN
      rsvd_ISR,  
      rsvd_ISR,  
      
// Group 10 PIE Vectors
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
  rsvd_ISR,  
            
// Group 11 PIE Vectors
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,  
// Group 12 PIE Vectors
      rsvd_ISR,  
      rsvd_ISR,  
      rsvd_ISR,