mylib.c

使用芯片为TI公司的DSP2812。该程序用以完成对直流电机的控制

#include "DSP28_Device.h"
//#include "Flash.h"
//#define FLASH 
/*
#define PWM1 GpioDataRegs.GPADAT.bit.GPIOA0   //PWM1
#define PWM2 GpioDataRegs.GPADAT.bit.GPIOA1   //PWM2
#define PWM3 GpioDataRegs.GPADAT.bit.GPIOA2   //PWM3
#define PWM4 GpioDataRegs.GPADAT.bit.GPIOA3   //PWM4
#define PWM5 GpioDataRegs.GPADAT.bit.GPIOA4   //PWM5
#define	PWM6 GpioDataRegs.GPADAT.bit.GPIOA5   //PWM6
#define	PWM7 GpioDataRegs.GPBDAT.bit.GPIOB0   //PWM7
#define	PWM8 GpioDataRegs.GPBDAT.bit.GPIOB1   //PWM8
#define PWM9 GpioDataRegs.GPBDAT.bit.GPIOB2   //PWM9
#define START GpioDataRegs.GPBDAT.bit.GPIOB8  // Cap4
#define DIR   GpioDataRegs.GPBDAT.bit.GPIOB9 // Cap5
#define V112 GpioDataRegs.GPADAT.bit.GPIOA8   
#define V113 GpioDataRegs.GPADAT.bit.GPIOA9    
#define V114 GpioDataRegs.GPADAT.bit.GPIOA10   
#define ON 1
#define OFF 0		
#define A 1
#define B 2
#define C 3
#define SMALL 4
#define MIDDLE 5
#define LARGE 6
*/
/*************************************************/
/*                                               */
/* The procedure CURRENTswitches SRD             */
/*   current limits.                             */
/*                                               */
/* Designed by Dr. K.Shuang                      */
/* Date 2006-3-16                                */
/* Modified by:                                  */
/* Date                                          */
/*                                               */
/*************************************************/
void current(int value)
{
    switch(value)
    {
        case SMALL:
            PWM8 = OFF;
            PWM9 = OFF;
            break;
        case MIDDLE:
            PWM8 = ON;
            PWM9 = OFF;
            break;
        case LARGE:
            PWM8 = ON;
            PWM9 = ON;
            break;
        default:
            break;
    }
}

/*************************************************/
/*                                               */
/* The procedure SRD switches SRD coils          */
/*                                               */
/*                                               */
/* Designed by Dr. K.Shuang                      */
/* Date 2006-3-16                                */
/* Modified by:                                  */
/* Date                                          */
/*                                               */
/*************************************************/
void srd(int phase,int status)
{
    switch(phase)
    {
       case A:
           if(status==ON)
           {
               PWM1 = ON;
               PWM4 = ON;
           } else
           {
               PWM1 = OFF;
               PWM4 = OFF;
           }
           break;
       case B:
           if(status==ON)
           {
               PWM2 = ON;
               PWM5 = ON;
           } else
           {
               PWM2 = OFF;
               PWM5 = OFF;
           }
           break;
       case C:
           if(status==ON)
           {
               PWM3 = ON;
               PWM6 = ON;
           } else
           {
               PWM3 = OFF;
               PWM6 = OFF;
           }
           break;
    }
}

/*************************************************/
/*                                               */
/* The function POSITION measures position       */
/* sensors, and return position code.            */
/*                                               */
/* Designed by Dr. K.Shuang                      */
/* Date 2006-3-16                                */
/* Modified by:                                  */
/* Date                                          */
/*                                               */
/*************************************************/
int position(void)
{
   int status = 0;

   if(V113) status |= 0x4;
   if(V114) status |= 0x2;
   if(V112) status |= 0x1;
   return(status);
}

/*************************************************/
/*                                               */
/* The procedure BRAKE colse the brake resister  */
/*                                               */
/*                                               */
/* Designed by Dr. K.Shuang                      */
/* Date 2006-3-20                                */
/* Modified by:                                  */
/* Date                                          */
/*                                               */
/*************************************************/
void brake(int status)
{
   PWM7 = status;
}

/*************************************************/
/*                                               */
/* The function uses to delay the cycle time     */
/*                                               */
/*                                               */
/* Designed by Dr. K.Shuang                      */
/* Date 2006-3-20                                */
/* Modified by:                                  */
/* Date                                          */
/*                                               */
/*************************************************/
void Delay(int circle)
{
   int i, j;

   for (i=0;i<circle;i++)
     for(j=0;j<200;j++)
        asm("     NOP");
}

/*************************************************/
/*                                               */
/* The procedure makes the SRD  rotating         */
/*  clockwise or anti-clockwise                  */
/*                                               */
/* Designed by Dr. K.Shuang                      */
/* Date 2006-3-20                                */
/* Modified by:                                  */
/* Date                                          */
/*                                               */
/*************************************************/
void StartUp(int pW)
{
    int pos;
    pos = position();
    if(DIR)
    {
        switch(pos)
        {
            case 5:
               srd(B,OFF);   // Phase B 
               srd(C,OFF);   // Phase C 
               srd(A,ON);    // Phase A
               Delay(pW);
               break;
            case 3: 
               srd(A,OFF);   // Phase A
               srd(B,OFF);   // Phase B 
               srd(C,ON);   // Phase C 
               Delay(pW); 
               break;
            case 6: 
               srd(A,OFF);   // Phase A 
               srd(C,OFF);   // Phase C 
               srd(B,ON);    // Phase B 
               Delay(pW); 
               break;
        }
    } else
    {
        switch(pos)
        {
            case 2: 
               srd(A,OFF);   // Phase A 
               srd(C,OFF);   // Phase C 
               srd(B,ON);    // Phase B 
               Delay(pW); 
               break;
            case 1: 
               srd(A,OFF);   // Phase A 
               srd(B,OFF);   // Phase B 
               srd(C,ON);    // Phase C 
               Delay(pW); 
               break;
            case 4: 
               srd(B,OFF);   // Phase B 
               srd(C,OFF);   // Phase C 
               srd(A,ON);    // Phase A 
               Delay(pW); 
               break;
        }
    }
}