acindmainstartware.c

U15873EE1V0AN00 aplication note

	#endif

	/*** Timer 10 (TM10) initialization **********************************************************/
	PRM02 = 1 ; /* f m = f /4 */
	NRC10 = 0x03 ; /* Selects noise elimination clock */
	TUM0 = 0x80 ; /* Selects UDC mode A*/
	PRM10 = 0x07 ; /* Select operation mode 4 */
	SESA10 = 0x00 ; /* Selects falling edge */
	TMC10 = 0x40 ; /* Starts count */

	}/*end of hwinit*/

 /*------------------------------------------------------------------------- 
 * Function:    setVFprofile
 * Description:  sets amplitude and frequency of PWM sine wave
 *                according to given VF profile for motor
 * Parameter:	None
 * Returns:     None
 ---------------------------------------------------------------------------*/
void setVFprofile(UINT16 setSpeed)
	{

   if(setSpeed<MIN_SPEED)
      setSpeed=MIN_SPEED; /*limit minimum speed of motor F_BOOST*/

   /*Determine sine table increment (frequency) based on demanded speed */
   tableInc = ((SINE_TABLE_SIZE * setSpeed * MAX_FREQ)/
                  (PWM_UPDATE_RATE * MAX_SET_SPEED));

   /*Determine amplitude based on demanded speed */
   amplitude = ((CM3_DATA * setSpeed)/(2 * MAX_SET_SPEED));
   
   if (amplitude < MIN_AMPLITUDE)
      /*limit minimum amplitude of motor voltage (V_BOOST)*/ 
      amplitude = MIN_AMPLITUDE; 

	} /*end of ainit*/

/*------------------------------------------------------------------------- 
 * Function:    displayStartWare
 * Description:  LED display sub-routine 
 *		displays in units of 100rpm on two 7 segment displays
 * Parameter:	data (display data)
 * Returns:     None
 --------------------------------------------------------------------------*/
void displayStartWare(UINT32 rpmData)
   {
   UINT8 bcdData[2];

   /*convert rpm data to BCD*/
   bcdData[0] = (rpmData/1000)%10; /*number of thousands - max 9*/

   bcdData[1] = (((rpmData - (bcdData[0]*1000))/100)%10); /*hundreds - max 9*/

   LED_HI = sevenSeg[bcdData[0]]; /*write thousands to most sig. display digit*/

   LED_LO = sevenSeg[bcdData[1]]; /*write huns to least sig. display digit*/
   
   return;
   }/*end of displayStartWare()*/


/*------------------------------------------------------------------------- 
 * Function:    getDigitalOrderedSpeed
 * Description: reads P2 switches for digital ordered speed
 * Parameter:	None
 * Returns:     orderedSpeed (0-MAX_FREQ)
 ---------------------------------------------------------------------------*/
UINT16 getDigitalOrderedSpeed( void )
  {
  UINT8 digitalSpeed;
  UINT16 orderedSpeed; /*scaled ordered speed */
   
   digitalSpeed = (P2 & 0x0C); /*read switches*/
   
   switch(digitalSpeed)
    {
    case 0x00:  speedDemandAv = 192; /*1000 rpm*/
    break;
    
    case 0x04:  speedDemandAv = 383; /*2000 rpm*/
    break;
    
    case 0x08:  speedDemandAv = 575; /*3000 rpm*/
    break;
    
    case 0x0C:  speedDemandAv = 767; /*4000 rpm*/
    break;
    
    default:  speedDemandAv = 0; /*0 rpm*/
    break;
    }
    
   orderedSpeed = ((speedDemandAv*MAX_RPM)/MAX_ADC_READING); /*in units of rpm*/
   
   return(orderedSpeed);

   }


/*------------------------------------------------------------------------- 
 * Function:    getOrderedSpeed
 * Description: reads ADC input for speed demand and calcs running average
 * Parameter:	None
 * Returns:     orderedSpeed (0-MAX_FREQ)
 ---------------------------------------------------------------------------*/
UINT16 getAnalogOrderedSpeed( void )
   {
   static int i=0;
   int j;
   UINT16 orderedSpeed; /*scaled ordered speed */
   
   
   if(i==(SPEED_READS-1))    /*if max no of points reached*/
      i=0;                    /*reset read pointer*/
	 
   speedDemand[i++]=(ADCR01 & 0x03ff);   /*read ADC for speed demand (mask lower 10 bits)*/
                                         
   for(j=0;j<SPEED_READS;j++)     /*add all readings together*/
      {
      speedDemandAv+=speedDemand[j];
      }

   speedDemandAv/= SPEED_READS; /*calculate average of ADC reads*/
   
   orderedSpeed = ((speedDemandAv*MAX_RPM)/MAX_ADC_READING); /*in units of rpm*/
   
   /*start ADC Conversion for when we return to this ISR*/
   ADSCM00 = 0x9801; /*select mode, A/D polling mode channel ANI01*/

   return(orderedSpeed);

   }

/*------------------------------------------------------------------------- 
 * Function:    getActualSpeed
 * Description:  reads Timer10 and calculates actual speed of motor
 * Parameter:	None
 * Returns:     actualSpeed (Hz)
 ---------------------------------------------------------------------------*/
UINT16 getActualSpeed( void )
	{
   static UINT16 previousEncoder =0;
   SINT16 encoderDiff=0;
	UINT16 currentEncoder;
   UINT16 rpmActual =0;                /*actual speed in rpm*/

	/******Current Speed Calculation********************/
                               
	/*Read Encoder to determine speed*/
	currentEncoder = TM10;

	if (direction==CCW) /*count will increment*/
		encoderDiff = (currentEncoder - previousEncoder);

	else /*motor direction CW and count will decrement*/
		encoderDiff = (previousEncoder - currentEncoder);
		
	if((encoderDiff<0)||(encoderDiff>(MAX_TM10_COUNT/2)))
		/*TMA01 has gone through zero*/
		{
		if (direction==CW)
			encoderDiff = ((MAX_TM10_COUNT - currentEncoder) + previousEncoder + 1);

		else
			encoderDiff = ((MAX_TM10_COUNT - previousEncoder) + currentEncoder + 1);
		}

	/*convert encoder value to RPM*/
	rpmActual=((encoderDiff * SAMPLE_RATE * 60)/ MAX_ENCODER_PULSES);

   /*current reading becomes previous reading*/
	previousEncoder = currentEncoder;

   return(rpmActual);  /*In Hz*/

   }

 /*------------------------------------------------------------------------- 
 * Function:    PIControl
 * Description:  modifies speed error (RPM) using P I coefficients
 * Parameter:	None
 * Returns:     PI speed demand
 ---------------------------------------------------------------------------*/
UINT16 PIControl(SINT32 speedError)
	{
	SINT32 proportional, integral;
   static SINT32 errorIntegral=0;
   SINT32 pi, speedDemand;

   proportional = KP(speedError);  /*calculate proportional term*/

   integral = KI(errorIntegral+=speedError); /*calculate integral term*/
      
   pi = proportional + integral;   /* calc PI product*/
   

   /*convert PI result from units of rpm to MAX_SET_SPEED scale*/
   speedDemand = ((pi * MAX_SET_SPEED)/MAX_RPM);

   if(speedDemand > MAX_SET_SPEED)
      speedDemand = MAX_SET_SPEED;  /*limit max value to max speed*/

   else if(speedDemand < 0)
      speedDemand = 0;  /*limit min value to 0*/
      
   return((UINT16)speedDemand);
   }
 

/****************************************************************************** 
 * Function:    basicConfig
 * Description: Performs the basic system configuration, particularly 
 *              settings of the PLL generator, internal bus spees and the 
 *              prescalers
 * Parameter:	None
 * Returns:     None
 *****************************************************************************/
void  basicConfig(void)
	{
	// Initialize CKC register
	// Bit 5: TBCS - Selects time base counter clock
	// 		0: TBC clock fxx/256
	// 		1: TBC clock fxx/512
	// Bit 3: CESEL - Specifies X1/X2 pin functions
	// 		0: crystal/resonator connected to X1-X2 pins
	//			1: external clock input at X1 pin
	// Bit 2 to 0: CKDIV2 to CKDIV0 - clock division in PLL mode
	unsigned char tempCKC = 0; 
	#ifdef PLL_MODE
		#if (PLL_DIV == 1)
			#if (PLL_MUL == 10)
			tempCKC |= 0x07;
			#elif (PLL_MUL == 5)
			tempCKC |= 0x03;
			#elif (PLL_MUL == 1)
			// bits 2-0 remain zero
			#else
			#error "No valid PLL factor defined."
			#endif
		#elif (PLL_DIV == 2)
			#if (PLL_MUL == 10)
			tempCKC |= 0x03;
			#elif (PLL_MUL == 5)
			tempCKC |= 0x01;
			#else
			#error "No valid PLL factor defined."
			#endif
		#endif
	PHCMD = tempCKC;
	CKC = tempCKC;
	#endif

	// Initialize VSWC register depending on the system freq.
	#if (SYS_FREQ < 25000000)
		VSWC = 0x11;
	#elif (SYS_FREQ < 33000000)
		VSWC = 0x12;
	#else // SYS_FREQ >= 33000000
		VSWC = 0x14;
	#endif

	} /*end of basicConfig*/



/*end of file*/