epower_28x_interrupt.c.bak

在TI的TMSF2812平台上

/* 
   FILE:    Epower_28x_Interrupt.c
  
   TITLE:   Interrupt Program(Compute).
   
   AUTHOR:  Xu Kangping  
  
   DESCRIPTION:
  
            This file define interrupt function about DSP2812 to compute the
            parameter about eletric power.
  
            The Epower_28x headerfiles are required to build this file.
         
            Watch Variables:
                   
*/

#include "Epower_28x.h"

/* 定义AD实时采样值，缓冲区为2 */
extern int adc_ua[2];
extern int adc_ub[2];
extern int adc_uc[2];
extern int adc_ia[2];
extern int adc_ib[2];
extern int adc_ic[2];

/* define the ADC conversion output */
extern int adcdata_ua[256];
extern int adcdata_ub[256];
extern int adcdata_uc[256];
extern int adcdata_ia[256];
extern int adcdata_ib[256];
extern int adcdata_ic[256];

/* define the data to carry out FFT */
extern int fftdata_ua[1024];
extern int fftdata_ub[1024];
extern int fftdata_uc[1024];
extern int fftdata_ia[1024];
extern int fftdata_ib[1024];
extern int fftdata_ic[1024];

/* 定义用于实时插值的纪录时间的数组 */
extern Uint32 adcdata_time[800];

/* 定义用于实时插值时起始点时间的纪录值 */
extern Uint32 adcdata_timef;

/* 定义电压、电流的总的值 */
extern long sum_ui[6];

/* 定义电压、电流的平均值 */
extern int z_ui[6];

/* 定义电压UA变量 */
extern int xxua_old;

/* 数据数组的指针 */
extern Uint16 fftn;						// 定义进行FFT采集的数据数组的指针
extern Uint16 timen;					// 定义AD采集时记录时间数组的指针
extern Uint16 tempn;					// 定义AD实时采集的缓冲区数组的指针
extern Uint16 samplen;					// 定义AD采集数据数组的指针

/* 程序运算的标志符 */
extern Uint16 phaze;					// 定义CAP捕捉到下降沿时的标志变量(用于AD插值运算)
extern Uint16 sampleflag;				// 定义CAP捕捉到下降沿时的标志变量(用于FFT取数)
extern Uint16 fftstart;					// 定义FFT开始运算标志变量
extern Uint16 fftflag;					// 外部运算FFT标志符
extern Uint16 adcflag;					// 定义ADC第一次采集的标志变量
extern Uint16 capflag;					// 定义CAP第一次捕获的标志变量
extern Uint16 samplen_temp;				// 定义实时插值时是否插值的标志量
extern Uint16 sample_cap;				// 定义第一次捕获用于采集插值的标志符

/* 程序运算的变量 */
extern Uint16 dcyc;						// 定义FFT的采样时间
extern Uint16 cyclen;					// 定义CAP捕捉的电网周期值
extern Uint16 samplen_1;				// 定义实时插值的初始计数值
extern Uint16 samplen_2;				// 定义FFT取值时上次指针量
extern Uint32 up_t_old;					// 定义CAP捕捉时上次捕获值
extern int32 realtime;					// 定义FFT取值的时间序列
extern Uint16 arc;						// 定义补偿中断采集和过零点之间的相角差




/* define the interrupt function McbspRxFifoIsr() */
interrupt void McbspRxFifoIsr(void)
{
    int time1,time2;
    int xua,xub,xuc,xia,xib,xic;
    Uint16 cycle;
    Uint32 up_t_new,up_t_new1;
    int xxua;
    Uint16 tempn_1;
    Uint32 time_temp;
    Uint16 arc_temp;
    Uint16 i;
    
    arc_temp = EvbRegs.T3CNT;
    
    GpioDataRegs.GPBDAT.bit.GPIOB15 = 1;
	
	if(adcflag == 0)
	{
	    McbspaRegs.MFFRX.bit.RXFIFO_RESET = 0;  // Reset Receive channel
        McbspaRegs.MFFRX.bit.RXFIFO_RESET = 1;  // Enable Receive channel
        
        EvbRegs.CAPCONB.bit.CAPRES = 0;
        EvbRegs.T4CNT = 0x0000;
        EvbRegs.T4CON.bit.TENABLE = 1;
        adcflag = 1;
	}
	else
	{
    	adcdata_time[timen] = ReadCpuTimer0Counter();
    	
    	/* sample the real data and the real_time */
    	xua = McbspaRegs.DRR1.all;
        xub = McbspaRegs.DRR1.all;
        xuc = McbspaRegs.DRR1.all;
        xia = McbspaRegs.DRR1.all;
        xib = McbspaRegs.DRR1.all;
        xic = McbspaRegs.DRR1.all;

		/* 捕获单元检测下降沿用于检测A相电压频率 */
		if(EvbRegs.CAPFIFOB.bit.CAP4FIFO > 0)
		{
			up_t_new = EvbRegs.CAP4FIFO;					// 取得捕获时间
			
			if(up_t_new < up_t_old)							// 与上次捕获时间求差
			{
				if(EvbRegs.CAPFIFOB.bit.CAP4FIFO == 1)
				{
					cycle = up_t_new +65536 - up_t_old; 
				}
				else
				{
					up_t_new1 = EvbRegs.CAP4FIFO;
				}
			}
			else
			{
				if(EvbRegs.CAPFIFOB.bit.CAP4FIFO == 1)
				{
					cycle = up_t_new - up_t_old;
				}
				else
				{
					up_t_new1 = EvbRegs.CAP4FIFO;
				}
			}
			
			if(capflag == 0)								// 第一次捕获
			{
				up_t_old = up_t_new;
				cyclen = 23438;
				capflag = 1;
				sample_cap = 1;
				
				phaze = 1;
			}
			else											// 其他的捕获
			{
				if((cycle > 20926)&&(cycle < 26634))		// 20926(56Hz) 26634(44Hz)
				{
					cyclen = cycle;
					up_t_old = up_t_new;
					
					phaze = 1;
				}
			}
		}
		/* 捕获单元检测程序段结束 */

		sum_ui[0] += xua;
		sum_ui[1] += xub;
		sum_ui[2] += xuc;
		sum_ui[3] += xia;
		sum_ui[4] += xib;
		sum_ui[5] += xic;
    	
    	xua -= z_ui[0];
		xub -= z_ui[1];
		xuc -= z_ui[2];
		xia -= z_ui[3];
		xib -= z_ui[4];
		xic -= z_ui[5];
    	
    	xxua = xua;
		
		adc_ua[tempn] = xua;
		adc_ub[tempn] = xub;
		adc_uc[tempn] = xuc;
		adc_ia[tempn] = xia;
		adc_ib[tempn] = xib;
		adc_ic[tempn] = xic;
		
		if(capflag == 0)
    	{
        	for(i=0;i<6;i++) z_ui[i] = 0;
        	for(i=0;i<6;i++) sum_ui[i] = 0;
    	}

		/* 第一次捕获后进行采集插值程序 */
		if(sampleflag == 1)
		{
			if(samplen == samplen_1)	// 过零点开始新的采集
			{
				if(adcdata_time[timen] < realtime)
				{
					realtime -= adcdata_time[timen];
					time_temp = ReadCpuTimer0Counter();
					time_temp = adcdata_time[timen] - time_temp;
					ReloadCpuTimer0();
					StartCpuTimer0();
        			adcdata_timef = ReadCpuTimer0Counter() + time_temp;
        			timen = 0;
					adcdata_time[timen] = 0;
					
					samplen_temp = 0;
				}
				else
				{
					if(adcdata_time[timen] == realtime)
                	{
						adcdata_ua[samplen] = adc_ua[tempn];
                    	adcdata_ub[samplen] = adc_ub[tempn];
                    	adcdata_uc[samplen] = adc_uc[tempn];
                    	adcdata_ia[samplen] = adc_ia[tempn];
                    	adcdata_ib[samplen] = adc_ib[tempn];
						adcdata_ic[samplen] = adc_ic[tempn];
						
						realtime = dcyc;
						time_temp = ReadCpuTimer0Counter();
						time_temp = adcdata_time[timen] - time_temp;
						ReloadCpuTimer0();
        				StartCpuTimer0();
						adcdata_timef = ReadCpuTimer0Counter() + time_temp;
						timen = 0;
						adcdata_time[timen] = 0;
                	}
                	else
                	{
                		time1 = realtime - adcdata_time[timen - 1];
                    	time2 = adcdata_time[timen] - adcdata_time[timen - 1];

                    	if(tempn == 0) tempn_1 = 1;
                    	else tempn_1 = 0;

                    	adcdata_ua[samplen] = (adc_ua[tempn] - adc_ua[tempn_1])*time1/time2 + adc_ua[tempn_1];
                    	adcdata_ub[samplen] = (adc_ub[tempn] - adc_ub[tempn_1])*time1/time2 + adc_ub[tempn_1];
                    	adcdata_uc[samplen] = (adc_uc[tempn] - adc_uc[tempn_1])*time1/time2 + adc_uc[tempn_1];
                    	adcdata_ia[samplen] = (adc_ia[tempn] - adc_ia[tempn_1])*time1/time2 + adc_ia[tempn_1];
                		adcdata_ib[samplen] = (adc_ib[tempn] - adc_ib[tempn_1])*time1/time2 + adc_ib[tempn_1];
                		adcdata_ic[samplen] = (adc_ic[tempn] - adc_ic[tempn_1])*time1/time2 + adc_ic[tempn_1];
                	
                		realtime = dcyc + realtime - adcdata_time[timen];
                		time_temp = ReadCpuTimer0Counter();
						time_temp = adcdata_time[timen] - time_temp;
                		ReloadCpuTimer0();
        				StartCpuTimer0();
						adcdata_timef = ReadCpuTimer0Counter() + time_temp;
						timen = 0;
						adcdata_time[timen] = 0;
                	}