sci.c

是用于开关磁阻电机的位置伺服控制的C语言源代码,基于CCS的开发环境.希望可以对你有所帮助.

#include "C240.h" 
/* define constant value */         
#define FALSE 0
#define TRUE  1
#define VELOCITY_CONST 1562500  
/* define variable */
unsigned int IA_max,IB_max,IC_max;   /* MAX limit for current */
unsigned int IA_min,IB_min,IC_min;   /* MIN limit for current */
unsigned int ADC_channel;            /* Channel for A/D convert */
int display_times;                   /* accumulation for display */
int TX_times;
int T3overflow_counter;              /* T3 overflow times */
int input_state;
int sign_state=TRUE; 
int RXdata_state=FALSE;
int dot_state;  
int CAP1_flag;                       
int inputdata_num;
int key_state;  
unsigned int input_value; 
unsigned int input_dotbit;
unsigned int position_value; 
unsigned int position_dotbit;
unsigned int position;
unsigned int velocity_value; 
unsigned int velocity_dotbit; 
unsigned int int_position;
int display_order=1;        /* 1 while display velocity ,2 while display current ,3 while display input data */
/* define Input/Output variable value */
ioport unsigned int port0,port1,port2,port3,port4,port5; 
/* define structure type and variable value */  
struct CAP_INT
	{
	 unsigned int PA_value;
	 unsigned int CAP_value;
	 unsigned long delta_count;
	 struct CAP_INT * next;
	};
struct CAP_INT * CAP_p;
/*********************************************/
/* Creat circle linkage table */
struct CAP_INT * creat_link()
{
 int i;
 struct CAP_INT * h,* p;             /* pointer h point to virtual value  */
 h=(struct CAP_INT *)malloc(sizeof(struct CAP_INT));
 h->next=h;
 for(i=1;i<=5;i++)
 	{
  	p=(struct CAP_INT *)malloc(sizeof(struct CAP_INT));
  	p->PA_value=0;
  	p->CAP_value=0;
  	p->delta_count=0;
  	p->next=h->next;
  	h->next=p;
 	}
 return (h);          /* return head pointer */
}                                                 
/*********************************************/                  

/*********************************************/                  
void dsp_setup() 
{
 unsigned int temp;
 /*********************************************/
 /* Disable watchdog timer */
 /*********************************************/
 temp = WDCR;
 temp = temp|0x68;
 WDCR = temp;
 /*********************************************/
 /* initialize PLL module (20 MHz XTAL1) */
 /*********************************************/
 CKCR1 = 0x60;      	/* crystal=20MHz CPUCLK = 20MHz */
                    	/* and 1x PLL mult ratio */
 CKCR0 = 0xc3;      	/* low–power mode 0, */
                    	/* ACLK enabled, */
                    	/* PLL enabled, */
                    	/* SYSCLK=CPUCLK/2 */
 SYSCR = 0x40c0; 
 
 XINT1CR=0x8007;
}
 

/* Initiate the event management register */
void eventmgr_init()
{
 
 GPTCON=0x0442;  
 /* Initialize T1 */
 T1PER=0x0fa0;     		  /* Period is 200us */
 T1CMP=0x07d0;
 T1CON=0x9042;
 /* Initialize T2 */
 T2PER=0x0190;     		  /* Period is 20us */
 T2CON=0x9040;  
 /* Setup shared pins */
 OCRA = 0xf800;     	  /* pins IOPB0–IOPB3 & IOPA0–IOPA2 to I/O pins */
 OCRB = 0x00f1;      	  /* pins are: ADSOC, XF, /BIO, CAP1–CAP4 */ 
 PADATDIR = 0x0701
 ; 	  /* outputs IOPA0–IOPA2, set low */
 PBDATDIR = 0x0707; 	  /* outputs IOPB0–IOPB2, set high */
  /* Initialize T3 */
 T3CNT=0x0;
 T3PER=0xffff;
 T3CON=0x9440;            /* Prescaler=/16 */
 /* Setup capture units */
 CAPCON = 0x0;    	      /* reset capture control register */
 CAPFIFO= 0x0ff;         /* Clear FIFO’s */
 CAPCON = 0xa6c0;         /* enable #1, use Timer3, both edges */    
  
}

/********************************************************** */
/* READ CAPTURE FIFO REGISTERS 
/* This routine is used to read the data from the capture FIFO
/* registers.
/*
/* inputs: capture = which FIFO to read?
/* range = 1–3
/* outputs fifo_data =
/* range = 0–65535
/********************************************************* */
unsigned int read_fifo(int capture)
{
 unsigned int fifo_data;
 int fifo_status;
 if (capture == 1) 
	{
	 do {
		fifo_data = FIFO1;                /* read value */
		fifo_status = CAPFIFO & 0x0300;   /* read status register, mask bits */
		} 
	 while (fifo_status != 0);
	}
 else 
		fifo_data = 0xffff;    	          /* error, not a valid capture */
 return fifo_data;
}
/* ISR for GPT1 interrupt */
void c_int2()
{
 
 IFR=0x0002;                       /* clear CPU interrupt flag */
 IFRA=0x7ff;
 display_times++; 
 TX_times++;
}
 
/* ISR for GPT3 interrupt */
void c_int3()
{
 IFR=0x0004;                       /* clear CPU interrupt flag */
 IFRB=0x0ff;                  /* clear interrupt flag */
 T3overflow_counter++;
}


/* ISR for CAP unit interrupt */
void c_int4()
{
 int groupc_flags;
 int capture; 
 struct CAP_INT * p;
 IFR=0x0008;                         /* clear CPU interrupt flag */
 groupc_flags = IFRC; 
 p=CAP_p;                        
 CAP_p=CAP_p->next;
 if (groupc_flags & 0x1)              /* read event manger interrupt */ 
 	{ 
 	 /* capture #1 */
 	 IFRC = 0xff;                    /* clear flag register */
	 capture = 1;
	 PADATDIR=CAP_p->PA_value;		
	 }                  
 else
	{
	 /* not a valid capture */
	 IFRC = 0xff;
	 capture = 0;
	} 
 CAP_p->CAP_value = read_fifo(capture); /* read FIFO */
 CAP_p->delta_count = 65535*T3overflow_counter + CAP_p->CAP_value - p->CAP_value;   
 T3overflow_counter=0;
 position=position+75;        /* accumulate position */

}

/*************************************/  
 
/* drive SRM */
void drive_SRM()
{
 static unsigned int clock_PAvalue[6]={0x0704,0x0706,0x0702,0x0703,0x0701,0x0705};
 static unsigned int anticlock_PAvalue[6]={0x0706,0x0704,0x0705,0x0701,0x0703,0x0702};
 int i;
 struct CAP_INT * p;
 CAP_p=creat_link();
 p=CAP_p->next;
 if (sign_state) 				/* drive SRM */
     {
      PADATDIR=0x0702; 
      for(i=0;i<=5;i++)
    	{
     	 p->PA_value=anticlock_PAvalue[i];
 	   	 p->delta_count=0;
         p=p->next;
     	} 
     }        
 else
     {
      PADATDIR=0x0704;
      for(i=0;i<=5;i++)
          {
           p->PA_value=clock_PAvalue[i];
           p->delta_count=0;
           p=p->next;
     	  }
   	 }

} 

/* stop SRM */
void stop_SRM(stop_phase,stop_position,stop_sign)
int stop_phase,stop_sign;
unsigned int stop_position;
{
 static int phase1[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 static int phase2[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 CAPCON=0x0600;
 if (stop_sign)
 	switch(stop_position)
 	{case 1:IA_max=phase1[stop_position];
 	        IC_max=phase2[stop_position];
 	        PADATDIR=0x0705;
 	 case 2:IC_max=phase1[stop_position];
 	        IB_max=phase2[stop_position];
 	        PADATDIR=0x0706;
 	 case 3:IB_max=phase1[stop_position];
 	        IA_max=phase2[stop_position];
 	        PADATDIR=0x0703;
 	}
 else
 	switch(stop_position)
 	{case 1:IA_max=phase1[stop_position];
 	        IB_max=phase2[stop_position];
 	        PADATDIR=0x0703;
 	 case 2:IB_max=phase1[stop_position];
 	        IC_max=phase2[stop_position];
 	        PADATDIR=0x0706;
 	 case 3:IC_max=phase1[stop_position];
 	        IA_max=phase2[stop_position];
 	        PADATDIR=0x0705;
 	}
}
/*********************************************/                  
void keyboard_ISR() 
{
 unsigned int scan_in;
 port0=0x0f;
 scan_in=port5;
 while ((scan_in & 0x0f)!=0x0f)
 	{
 	} 
 
 if (key_state==1)
 	{  
 	 drive_SRM(); 
 	 key_state=0;
 	}
 else
 	{