ac.c

使用TMS320F2812实验三相交流异步电机调速的程序

//###########################################################################
//
// FILE:    ac.c
//
// TITLE:   DSP2812 Event Manager create SPWM to control a AC asynchronous motor.
//
// DATE:    2007.04.27
//
// AUTHOR:  ksy
//
// COMPANY: ****** Technology Co.,Ltd
//
// DESCRIPTION:
//
//          This program sets up the EVA timers (TIMER1) to generate
//          PWM1-6 waveforms to control a AC asynchronous motor SPWM test 
//			按键A正转,B反转
//###########################################################################

#include "DSP281x_Device.h"     // DSP281x Headerfile Include File
#include "DSP281x_Examples.h"   // DSP281x Examples Include File
#include "math.h"
#define PI 3.1415926            // define PI as π

// Prototype statements for functions found within this file.
interrupt void eva_timer1_isr(void);
void init_eva();
void InitAdc();
void delay_loop();

// Initialize Global variables
float M;          // 调制度
int16 N;          // 载波比(N=fcl/frl)
Uint16 fcl,frl;   // fcl:载波频率; frl:基波频率
Uint16 r1[1000],r2[1000],r3[1000];
Uint16 a[16];
Uint16 data,sum;
Uint16 cmpr,direction;
Uint16 IntCount,tpr;
Uint16 i,j,t;

void main(void)
{
// Initialize System Control:
   InitSysCtrl();
   EALLOW;
   SysCtrlRegs.HISPCP.all=0x03;// HSPCLK=SYSCLKOUT/2*3=150/(2*3)=25MHz(AD clock)
   EDIS;
   
// Initalize GPIO: 
   EALLOW;
   GpioMuxRegs.GPAMUX.all = 0x00FF; // EVA PWM 1-6 pins and set Cap1-3 to IO pins.
   GpioMuxRegs.GPBMUX.bit.CAP4Q1_GPIOB8=0; // A
   GpioMuxRegs.GPBMUX.bit.CAP5Q2_GPIOB9=0; // B
   GpioMuxRegs.GPADIR.all = 0x00FF; // Set IO pins to be input pins
   GpioMuxRegs.GPBDIR.all = 0x0;
   EDIS;
    
// Disable CPU interrupts 
   DINT;

// Initialize PIE control registers.
   InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:
   IER = 0x0000;
   IFR = 0x0000;

// Initialize the PIE vector table.
   InitPieVectTable(); 
   EALLOW;  // This is needed to write to EALLOW protected registers
   PieVectTable.T1PINT = &eva_timer1_isr;
   EDIS;   // This is needed to disable write to EALLOW protected registers

// Initialize EVA&ADC:
   init_eva();
   InitAdc();
   
// Enable PIE group 2 interrupt 4 for T1PINT
   PieCtrlRegs.PIEIER2.all = M_INT4;
   
// Enable CPU INT2 for T1PINT:
   IER |= M_INT2;

// Enable global Interrupts and higher priority real-time debug events:
   EINT;   // Enable Global interrupt INTM
   ERTM;   // Enable Global realtime interrupt DBGM 
   
   i=0;
   tpr=2775;               // timer period register
   t=tpr/1.9;
   fcl=4500;               // 4.5KHz 载波频率(由TIPR计算可得)
   M=0.9;		           // 调制度
   IntCount=0x0;
   direction=1;			   // 正转
   XwdataRegs.IO=0xFF;     // 关IO口发光二极管
   XwdataRegs.USB_CS=0xFF; // 关数码管显示

   for(;;)
   {
		if(GpioDataRegs.GPBDAT.bit.GPIOB8==0) //按键A
		direction = 1;     //正转(逆时针)
    	if(GpioDataRegs.GPBDAT.bit.GPIOB9==0) //按键B
    	direction = 0;     //反转(顺时针)
    	
   		if(cmpr<5)         // AD采样最小值时停掉电机
   		{
  			cmpr=1;
  		    EvaRegs.CMPR1 = 0;
	        EvaRegs.CMPR2 = 0;
	        EvaRegs.CMPR3 = 0;
  	    }
  	    else
  	    {
  	       frl=cmpr;       // 基波频率(0-51Hz)
   		   N=fcl/frl;	   // 正弦波周期
  	       if(direction ==1)
  	       {
   		      for(j=0;j<N;j++)
   		      {
   			      r1[j]=t*(1+M*sin(j*2*PI/N+2*PI/3));
        	      r2[j]=t*(1+M*sin(j*2*PI/N));
        	      r3[j]=t*(1+M*sin(j*2*PI/N-2*PI/3));
   		      }
   		   }
   		   else if(direction ==0)
   		   {
				for(j=0;j<N;j++)
   		      	{
   			      r1[j]=t*(1+M*sin(j*2*PI/N));
        	      r2[j]=t*(1+M*sin(j*2*PI/N+2*PI/3));
        	      r3[j]=t*(1+M*sin(j*2*PI/N-2*PI/3));
   		      	}  		   
   		   }
   		}
   }
}

interrupt void eva_timer1_isr(void)
{
	Uint16 k;
    IntCount++;
    i++;
   	if(IntCount>1) // 中断2次采样一次AD
   	{
   		AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;   //启动SEQ1
   		IntCount=0;
		while(AdcRegs.ADCST.bit.SEQ1_BSY!=0){;}//等待AD转换完成
		a[0]=AdcRegs.ADCRESULT0>>4;
		a[1]=AdcRegs.ADCRESULT1>>4;
		a[2]=AdcRegs.ADCRESULT2>>4;
		a[3]=AdcRegs.ADCRESULT3>>4;
		a[4]=AdcRegs.ADCRESULT4>>4;
		a[5]=AdcRegs.ADCRESULT5>>4;
		a[6]=AdcRegs.ADCRESULT6>>4;
		a[7]=AdcRegs.ADCRESULT7>>4;
		a[8]=AdcRegs.ADCRESULT8>>4;
		a[9]=AdcRegs.ADCRESULT9>>4;
		a[10]=AdcRegs.ADCRESULT10>>4;
		a[11]=AdcRegs.ADCRESULT11>>4;
		a[12]=AdcRegs.ADCRESULT12>>4;
		a[13]=AdcRegs.ADCRESULT13>>4;
		a[14]=AdcRegs.ADCRESULT14>>4;
		a[15]=AdcRegs.ADCRESULT15>>4;
		for(k=0;k<16;k++)
		{
			sum=sum+a[k];
    	}
    	data=sum/16;  // AD采样值
    	cmpr=data/80; // cmpr|max=4096/80=51;(12 bits ADC)
    	sum=0;
    }

	if(i>N)
		i=0;
	EvaRegs.CMPR1 = r1[i];
	EvaRegs.CMPR2 = r2[i];
	EvaRegs.CMPR3 = r3[i];

    // Enable more interrupts from this timer
    EvaRegs.EVAIMRA.bit.T1PINT = 1;
 
    // Note: To be safe, use a mask value to write to the entire
    // EVAIFRA register.  Writing to one bit will cause a read-modify-write
    // operation that may have the result of writing 1's to clear 
    // bits other then those intended. 
    EvaRegs.EVAIFRA.all = BIT7;
 
    // Acknowledge interrupt to receive more interrupts from PIE group 2
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP2;
}

void init_eva()
{
// Initalize EVA Timer1&Configure PWM1-PWM6
	EvaRegs.T1PR = tpr;            // period=2775×2/25M=222us (连续增减)
	EvaRegs.T1CNT = 0;             // Timer1 counter
	EvaRegs.GPTCONA.bit.T1CMPOE=1; // enable timer compare
	EvaRegs.GPTCONA.bit.T1PIN=1;   // timer compare output
    EvaRegs.EVAIMRA.bit.T1PINT = 1;// enable Timer1 period interrupt
	EvaRegs.EVAIFRA.bit.T1PINT=1;  // clear Timer1 period interrupt flag
/****************************************************
  TMODE = continuous up/down count
  Input clock prescaler= X/1 (X=HSPCLK)=25MHz
  Timer enable ; Timer compare enable
*****************************************************/
	EvaRegs.T1CON.all = 0x0842;   
	
  // Enable compare for PWM1-PWM6
	EvaRegs.CMPR1 = 500;
	EvaRegs.CMPR2 = 500;
	EvaRegs.CMPR3 = 500;
 
	EvaRegs.ACTRA.all = 0x0666;   // PWM1,2,3,4,5,6
	EvaRegs.DBTCONA.all = 0x05FC; // 死区1us (1/(150M/32))*5
	EvaRegs.COMCONA.all = 0x8E00; // Enable full compare 1010 0110 0000 0000
} 

void InitAdc(void)
{
	extern void DSP28x_usDelay(Uint32 Count);
	
	AdcRegs.ADCTRL1.bit.RESET=1;      //Reset ADC
	delay_loop(2);
	AdcRegs.ADCTRL1.bit.RESET=0;      //No reset
	AdcRegs.ADCTRL1.bit.SUSMOD=3;     //在仿真暂停时停止
	AdcRegs.ADCTRL1.bit.ACQ_PS=0;
	AdcRegs.ADCTRL1.bit.CPS=0;        // AD_clock=HSPCLK/1=25MHz
	AdcRegs.ADCTRL1.bit.CONT_RUN=0;
	AdcRegs.ADCTRL1.bit.SEQ_CASC=1;   //级联模式(SEQ mode)
//***********ADC上电顺序:**************	
	AdcRegs.ADCTRL3.bit.ADCBGRFDN=0x3;//Power up bandgap/reference circuitry
	DELAY_US(8000L);                  //(5ms)Delay before powering up rest of ADC
	AdcRegs.ADCTRL3.bit.ADCPWDN=1;    //Power up rest of ADC
	DELAY_US(20L);                    //(20us)Delay after powering up ADC
//*************************************
	AdcRegs.ADCTRL3.bit.ADCCLKPS=0;   //ADC module clock = HSPCLK/1= 25MHz/(1)= 25MHz
	AdcRegs.ADCTRL3.bit.SMODE_SEL=0;  //顺序采样方式
	AdcRegs.ADCMAXCONV.bit.MAX_CONV1=0x07;
	AdcRegs.ADCCHSELSEQ1.all=0x2222;  //Select ADCINA2
	AdcRegs.ADCCHSELSEQ2.all=0x2222;  //Select ADCINA2
	AdcRegs.ADCCHSELSEQ3.all=0x2222;  //Select ADCINA2
	AdcRegs.ADCCHSELSEQ4.all=0x2222;  //Select ADCINA2	
	AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;   //启动SEQ1(启动AD转换)
}	

void delay_loop(Uint16 count )
{
    long      n;
    for (n = 0; n < count; n++) {}
}

//===========================================================================
// No more.
//===========================================================================