开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
Example_281xAdcSeq_ovdTest.c
资源名称：TMS320F2812-EVM.rar　[点击查看]
上传用户：qingfan3
上传日期：2014-10-27
资源大小：31439k
文件大小：9k
源码类别：

DSP编程

开发平台：

C/C++

Example_281xAdcSeq_ovdTest.c：源码内容
  1. //###########################################################################
  2. //
  3. // FILE:   Example_281xAdcSeq_ovdTest.c
  4. //
  5. // TITLE:  DSP281x ADC Seq Override mode Test.
  6. //
  7. // ASSUMPTIONS:
  8. //
  9. //          This program requires the DSP281x V1.00 header files.  
  10. //          As supplied, this project is configured for "boot to H0" operation.  
  11. // 
  12. //          Make sure the CPU clock speed is properly defined in 
  13. //          DSP281x_Examples.h before compiling this example.
  14. //
  15. //          Connect the signal to be converted to Channel A0.
  16. //
  17. // DESCRIPTION:    
  18. //
  19. //          Channel A0 is converted forever and logged in a buffer (SampleTable)
  20. //          Using sequencer1 in sequencer override mode. Sequencer is Sequential mode
  21. //          with sample rate of 1/(3*40ns) =8.3MHz
  22. //
  23. //          Open a memory window to SampletTable to observe the buffer
  24. //          RUN for a while and stop and see the table contents.
  25. //
  26. //          Watch Variables:
  27. //             SampleTable - Log of converted values.
  28. //             XF          - Toggles on every ADC sequencer flag
  29. //
  30. //###########################################################################
  31. //
  32. // Original source by: S.S.
  33. //
  34. //  Ver | dd mmm yyyy | Who  | Description of changes
  35. // =====|=============|======|===============================================
  36. //  1.00| 11 Sep 2003 | L.H. | Updated for DSP281x Release - First Release
  37. //###########################################################################
  39. #include "DSP281x_Device.h"     // DSP281x Headerfile Include File
  40. #include "DSP281x_Examples.h"   // DSP281x Examples Include File
  41.   
  42. // Determine when the shift to right justify the data takes place
  43. // Only one of these should be defined as 1.  
  44. // The other two should be defined as 0.
  45. #define POST_SHIFT   0  // Shift results after the entire sample table is full
  46. #define INLINE_SHIFT 1  // Shift results as the data is taken from the results regsiter
  47. #define NO_SHIFT     0  // Do not shift the results 
  48.   
  49. // ADC start parameters
  50. #define ADC_MODCLK 0x3   // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 = 150/(2*3)     = 25MHz
  51. #define ADC_CKPS   0x0   // ADC module clock = HSPCLK/1      = 25MHz/(1)     = 25MHz
  52. #define ADC_SHCLK  0x1   // S/H width in ADC module periods                  = 2 ADC cycle
  53. #define AVG        1000  // Average sample limit
  54. #define ZOFFSET    0x00  // Average Zero offset
  55. #define BUF_SIZE   1024  // Sample buffer size
  57. // Global variable for this example
  58. Uint16 SampleTable[BUF_SIZE];
  61. main() 
  62. {
  63.    Uint16 i;
  64.    Uint16 array_index;                     
  67. // Step 1. Initialize System Control:
  68. // PLL, WatchDog, enable Peripheral Clocks
  69. // This example function is found in the DSP281x_SysCtrl.c file.
  70.    InitSysCtrl();
  71.       
  72. // Specific clock setting for this example:      
  73.    EALLOW;
  74.    SysCtrlRegs.HISPCP.all = ADC_MODCLK; // HSPCLK = SYSCLKOUT/ADC_MODCLK
  75.    EDIS;
  77. // Step 2. Initialize GPIO: 
  78. // This example function is found in the DSP281x_Gpio.c file and
  79. // illustrates how to set the GPIO to it's default state.
  80. // InitGpio();  // Skipped for this example  
  81. // Enable the pins as XF pin as output
  82.    EALLOW;
  83.    GpioMuxRegs.GPFMUX.bit.XF_GPIOF14 = 1;  //enable XF pin on GPOF14
  84.    EDIS;
  86. // Step 3. Clear all interrupts and initialize PIE vector table:
  87. // Disable CPU interrupts 
  88.    DINT;
  90. // Initialize the PIE control registers to their default state.
  91. // The default state is all PIE interrupts disabled and flags
  92. // are cleared.  
  93. // This function is found in the DSP281x_PieCtrl.c file.
  94.    InitPieCtrl();
  96. // Disable CPU interrupts and clear all CPU interrupt flags:
  97.    IER = 0x0000;
  98.    IFR = 0x0000;
  100. // Initialize the PIE vector table with pointers to the shell Interrupt 
  101. // Service Routines (ISR).  
  102. // This will populate the entire table, even if the interrupt
  103. // is not used in this example.  This is useful for debug purposes.
  104. // The shell ISR routines are found in DSP281x_DefaultIsr.c.
  105. // This function is found in DSP281x_PieVect.c.
  106.    InitPieVectTable();
  108. // Step 4. Initialize all the Device Peripherals:
  109. // This function is found in DSP281x_InitPeripherals.c
  110. // InitPeripherals(); // Not required for this example
  111.    InitAdc();         // For this example, init the ADC
  113. // Specific ADC setup for this example:
  114.    AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK;  // Sequential mode: Sample rate   = 1/[(2+ACQ_PS)*ADC clock in ns]
  115.     //                     = 1/(3*40ns) =8.3MHz
  116.     // If Simultaneous mode enabled: Sample rate = 1/[(3+ACQ_PS)*ADC clock in ns]
  117.    AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS;     
  118.    AdcRegs.ADCTRL1.bit.SEQ_CASC = 1;        // 1  Cascaded mode
  119.    AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x0;
  120.    AdcRegs.ADCTRL1.bit.CONT_RUN = 1;       // Setup continuous run
  122.    AdcRegs.ADCTRL1.bit.SEQ_OVRD = 1;       // Enable Sequencer override feature
  123.    AdcRegs.ADCCHSELSEQ1.all = 0x0;         // Initialize all ADC channel selects to A0
  124.    AdcRegs.ADCCHSELSEQ2.all = 0x0;
  125.    AdcRegs.ADCCHSELSEQ3.all = 0x0;
  126.    AdcRegs.ADCCHSELSEQ4.all = 0x0;
  127.    AdcRegs.ADCMAXCONV.bit.MAX_CONV1 = 0x7;  // convert and store in 8 results registers 
  130. // Step 5. User specific code, enable interrupts:
  133. // Clear SampleTable
  134.    for (i=0; i<BUF_SIZE; i++)
  135.    {
  136.      SampleTable[i] = 0;
  137.    }
  139. // Start SEQ1
  140.    AdcRegs.ADCTRL2.all = 0x2000;
  141.   
  142.    while(1)
  143.    {  // Take ADC data and log them in SampleTable array
  144.      
  145.      // Initalize the array index.  This points to the current
  146.      // location within the SampleTable
  147.      array_index = 0;
  148.      
  149.      for (i=0; i<(BUF_SIZE/16); i++)
  150.      {
  151.        // Wait for INT1
  152.        while (AdcRegs.ADCST.bit.INT_SEQ1== 0){}
  153.        asm(" setc XF ");                 // Set XF for monitoring  -optional
  155.        AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;
  157. #if INLINE_SHIFT
  158.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT0)>>4);
  159.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT1)>>4);
  160.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT2)>>4);
  161.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT3)>>4);
  162.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT4)>>4);
  163.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT5)>>4);
  164.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT6)>>4);
  165.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT7)>>4);
  166.        
  167. #endif //-- INLINE_SHIFT
  168.      
  169. #if NO_SHIFT || POST_SHIFT
  171.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT0));
  172.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT1));                            
  173.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT2));                            
  174.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT3));                            
  175.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT4));                            
  176.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT5));                            
  177.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT6));                            
  178.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT7));                            
  179.             
  180. #endif //-- NO_SHIFT || POST_SHIFT
  182.        while (AdcRegs.ADCST.bit.INT_SEQ1== 0){}
  183.      asm(" clrc XF ");            // Clear XF for monitoring  -optional
  184.        AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;
  186. #if INLINE_SHIFT
  188.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT8)>>4);
  189.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT9)>>4);              
  190.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT10)>>4);              
  191.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT11)>>4);              
  192.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT12)>>4);              
  193.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT13)>>4);              
  194.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT14)>>4);              
  195.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT15)>>4);               
  196.                                       
  197. #endif //-- INLINE_SHIFT              
  198.                                       
  199. #if NO_SHIFT || POST_SHIFT            
  200.                                       
  201.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT8));
  202.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT9));              
  203.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT10));              
  204.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT11));              
  205.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT12));              
  206.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT13));              
  207.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT14));              
  208.        SampleTable[array_index++]= ( (AdcRegs.ADCRESULT15));              
  209. #endif // -- NO_SHIFT || POST_SHIFT 
  211. }
  214. #if POST_SHIFT
  215.     // For post shifting, shift the ADC results 
  216.     // in the SampleTable buffer after the buffer is full.
  217.     for (i=0; i<BUF_SIZE; i++)
  218.     {
  219.       SampleTable[i] = ((SampleTable[i]) >>4);
  220.     }
  221. #endif // -- POST_SHIFT    
  222.     
  223.     asm(" clrc XF ");
  224.   }
  225. }
  227. //===========================================================================
  228. // No more.
  229. //===========================================================================
  231.