example_280xadcsoc.c

AD转换 数据采集 串口读数 定时器控制采样频率

#include "DSP280x_Device.h"                 // DSP280x Headerfile Include File
#include "DSP280x_Examples.h"               // DSP280x Examples Include File

// Prototype statements for functions found within this file.

interrupt void xint1_isr(void);
void mn_text(void);
void Into_lowpower30(void);
void adc_text(void);
void Write_memory(void);

  //Global variables used in this example:
 
 Uint16 Biancheng_counter=6;
 Uint16 Biancheng_val=8400;
 Uint32 ConversionCount=0;
 Uint32 Memory_address=0;
 Uint16 ad_flag=1;
 Uint32 adrut;
 Uint16 chufa_count=0;
 
 BOOL Biancheng_ok=FALSE;//TRUE;
 BOOL Caiji_ok=FALSE;
 BOOL low_mode=FALSE;
 
 main() 
 {

// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
   InitSysCtrl();

// For this example, set HSPCLK to SYSCLKOUT / 8 (12.5Mhz assuming 100Mhz SYSCLKOUT)
   EALLOW;
   SysCtrlRegs.HISPCP.all = 0x1;  // HSPCLK = SYSCLKOUT/8  配置为0x01就有问题
   EDIS;
   
// Step 2. Initialize GPIO: 

   InitGpio();
// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts 
   DINT;

   InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:
   IER = 0x0000;
   IFR = 0x0000;
   
   InitPieVectTable();
   
   EALLOW;  // This is needed to write to EALLOW protected register
  
   PieVectTable.XINT1 = &xint1_isr;
   EDIS;    // This is needed to disable write to EALLOW protected registers
   
   

// Step 5. User specific code, enable interrupts:  
   PieCtrlRegs.PIECTRL.bit.ENPIE = 1;          // Enable the PIE block
   PieCtrlRegs.PIEIER1.all=0x80;              //Enable PIE Gropu 1 WAKEINT8in PIE6,PIE Gropu 1 INT4
   
   IER |= M_INT1;                              // Enable CPU Interrupt 1
   EINT;                                        // Enable Global interrupt INTM
   ERTM;                                      // Enable Global realtime interrupt DBGM
  
   MemCopy(&RamfuncsLoadStart, &RamfuncsLoadEnd, &RamfuncsRunStart);

// Call Flash Initialization to setup flash waitstates
// This function must reside in RAM
   InitFlash();
   mn_text(); 
 } 

#pragma CODE_SECTION(mn_text, "ramfuncs");   
void mn_text(void)  
 {
  Into_lowpower30();                          //Low power
   PieCtrlRegs.PIEIER1.all=0x08;
  /* 用while{}语句会出错*/
   do                                         //等待编程
     {
       NOP;
     } while(Biancheng_ok);
   
   //开模拟板电源
   DELAY_US(5000L);//delay
   
   InitAdc();         // For this example, init the ADC
   
   DELAY_US(5000L);//delay
   GpioDataRegs.GPBCLEAR.bit.GPIO34=1;            //开LP2985
   //采集标志
   GpioDataRegs.GPBSET.bit.GPIO33=1;            //采集时小灯亮
   GpioDataRegs.GPBSET.bit.GPIO32=1;            //MWE置高
   
  
   PieCtrlRegs.PIEIER1.all=0x88; 
   // Start SEQ1
   AdcRegs.ADCTRL2.all = 0x2000;
 
   for(;;)
   {
     
      if(Caiji_ok==FALSE) // Wait for ADC 
     {
        while (AdcRegs.ADCST.bit.INT_SEQ1== 0) {} // Wait for interrupt
       AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;
        
        adc_text();
     }
     else
     {
        while(low_mode)
         {
           GpioDataRegs.GPBCLEAR.bit.GPIO33=1;      //采集结束小灯灭
           Into_lowpower30();
           low_mode=FALSE;
           EALLOW;
           GpioCtrlRegs.GPADIR.all=0x0003FFFF;  // 0-17  outputS,18-29 30 31 inputs(avoid memory IO and GPIO)
           EDIS;
         }
      } 
    }
 
}

#pragma CODE_SECTION(adc_text, "ramfuncs");
 void  adc_text(void)                  //Sample reach  156kHZ(max)   ACQ_PS=0  ADCCLKPS=0 CPS=0
{
   /*推地址*/
   GpioDataRegs.GPADAT.all=Memory_address;
   
	
	/*WE\置低*/
    GpioDataRegs.GPBCLEAR.bit.GPIO32=1;          //设置WE\管脚为低电平,即写有效
    /*读结果寄存器的值*/
    adrut=AdcRegs.ADCRESULT0;
    /*读数	*/
    
    GpioDataRegs.GPADAT.all=((adrut<<14)&0x3FFC0000)|Memory_address;//AD 结果寄存器是从高位开始存的
    
    if(Memory_address==262144)        //使存储器循环存储256K
	  {
		Memory_address=0;
	  }
	else
	  {
		Memory_address++;
	  }
  
   switch(ad_flag)
    {
      
      case 1:                                      //高速采集高速循环写
         { 
           if(adrut>=Biancheng_val)                //判断是否触发
             {
                chufa_count++;
                
                if(chufa_count==8)                //连续8次大于编程值认为触发
                  {
                    ad_flag=2;
                    ConversionCount++;/////触发以后才开始计数  记250K
                  }
             }
           else
              {
                chufa_count=0;
              }
                                                                   
           break;
         }
         
     case 2:                                           //高速采集高速写
         {
           if(ConversionCount<196607)                  //高频占192K
             {
               ConversionCount++;
             }
           else
             {
               ad_flag=3;
               ConversionCount++;
             }
           break;
         }
         
     case 3:                                              //低速写
         {
           if(ConversionCount<256000) //负延迟6K
           {
             ConversionCount++;
             
             DELAY_US(1000L);
           }
           else
           {
             EALLOW;
             SysCtrlRegs.PCLKCR0.bit.ADCENCLK = 0;    // ADC
             EDIS;
            /* Power off*/
             AdcRegs.ADCTRL3.all = 0x0000;              
             low_mode=TRUE;
             Caiji_ok=TRUE;
             ConversionCount=0;                        //清零，此变量在读数时计数
           }
           
           break;
         }
    }
    
    //DELAY_US(1000L);                              //延迟
    /*设置WE\管脚为高电平,即写进存储器*/
    GpioDataRegs.GPBSET.bit.GPIO32=1;           
  
  return;
}

#pragma CODE_SECTION(Into_lowpower30, "ramfuncs");
void Into_lowpower30(void)                    //进入低功耗模式
 { 
    EALLOW;
	SysCtrlRegs.LPMCR0.bit.LPM=1;              //1=STANDBY mode  2=Halt mode
	EDIS;
	
//	IDLE;
//	DELAY_US(500L);
	
	PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;    // Acknowledge this interrupt to 
    return;	                                           //get more from group 1
 }


#pragma CODE_SECTION(xint1_isr, "ramfuncs");
interrupt void xint1_isr(void)
 { 
   int TRX=0;

   if(Biancheng_counter<6)
     {
      Biancheng_counter++;
      Biancheng_val=Biancheng_val<<1;         //原来的值右移1位即 D5至D6，D4至D5，D3至D4
                                              //D2至D3，D1至D2，D0至D1
     //读GPIO_TRX
      TRX=GpioDataRegs.GPADAT.bit.GPIO30;     //将送来的编程位赋给TRX
      Biancheng_val=Biancheng_val|TRX;       //TRX送到Biancheng_val的最低位
     
     if(Biancheng_counter==6)
       { 
         Biancheng_val=Biancheng_val<<10;       //Biancheng_val的低5位放到高5位
         
         Biancheng_ok=FALSE;
       }
     }
   else
     /*读数为存储器推地址*/
     {
       /*判断发OE*/
       GpioDataRegs.GPBSET.bit.GPIO33=1;        
       GpioDataRegs.GPADAT.all=0x40000000|Memory_address;  //推地址
       
	   if(Memory_address==262144)             // 使地址可以循环 
	     {
		   Memory_address=0;
	     }
	   else
	     {
		  Memory_address++;
	     }   
	   ConversionCount++;
	     if(ConversionCount>=262144)          
	    {
	     
	     low_mode=TRUE;
	     ConversionCount=0;
	     
	    }
	             
     }
  
  PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;    // Acknowledge this interrupt to 
  
  GpioDataRegs.GPBCLEAR.bit.GPIO33=1;
  return;	                                           
 }
//===========================================================================
// No more.
//===========================================================================