pwmcalc.c

3 phase motor driver source code with freescale MCU

/*
 * Project:		 	3-PHASE AC DRIVE
 *
 * Microcontroller: Motorola MC68HC908MR24 
 *
 * Module:			PWMCALC.C
 * Revision/Date:	2.0 / February 2000 
 * Description:		This routine is 2nd level ISR responding to 
 *					PWM interrupt.
 *					Input:	New waveform parameters Incval and Amplitude 
 *					Output:	Load 3 PWM registers PVAL1, PVAL3, PVAL5 
 *
 * Compiler:		Hiware08 Compiler
 *
 * Author:			Radim VISINKA
 * Company:			MOTOROLA SPS
 *					Motorola Czech Systems Laboratories 
 *					Roznov pod Radhostem, Czech Republic 
 *
 * ===================================================================
 *
 * Copyright (c):	MOTOROLA Inc.,1999, All rights reserved.
 *
 * ====================================================================
 * THIS SOFTWARE IS PROVIDED BY MOTOROLA RSAL "AS IS" AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MOTOROLA RSAL OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 */


/* DEFINITION_START */


/* Include Header Files */
#include "MR24IO.H"			/* file contains input/output file */
#include "CONST.H"			/* file contains global constants and
							   definitions */
#include <3rdhquad.h>	 	/* contains wave table for one quadrant*/ 		
							/* 3rdhquad.h for sine wave with third harmonic */	


/* Global Variables (External) - 8 bit */
extern unsigned char Amplitude;	/* 0 to 255 gives 0 to 100% modulation*/

/* Global Variables (External) - 16 bit */
extern signed int Table_inc;		/* increment value for wave pointer update*/	

/* Local Variables - 8 bit */
unsigned char Table_value;		/* Value read from wave table */

/* Local Variables - 16 bit */
unsigned int Wave_ptr_a = 0;	/* wave pointer for phase A */	   
unsigned int Wave_ptr_b;		/* wave pointer for phase B */
unsigned int Wave_ptr_c;		/* wave pointer for phase C */
unsigned int Quad_ptr;			/* quadrant pointer for phase A */
unsigned int Pwmmod_wave;		/* wave modulus */

			  
/* DEFINITION_END */
			   	   

void PWMcalc (void)
 	{			

	COPCTL=0x00;				/* service COP */
  	PCTL1 &= 0xef;  			/* clear PWMF bit */	  	  
  

/* PHASE A */	

	if (Wave_ptr_a < 0x4000)		/* QUADRANT 1 */
	{
	  Quad_ptr = (Wave_ptr_a)<<2;				/* calculate quadrant pointer
	  											   from wave pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL1 = (Pwmmod_wave>>8) + (PWM_MODULUS/2);	
												/* update PVAL1 register 
											   	   for QUADRANT 1 */
	}
		
	else if (Wave_ptr_a < 0x7fff)	/* QUADRANT 2 */
	{
	  Quad_ptr = (32767 - Wave_ptr_a)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */			
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL1 = (Pwmmod_wave>>8) + (PWM_MODULUS/2);
												/* update PVAL1 register 
											       for QUADRANT 2 */
	}
		
	else if (Wave_ptr_a < 0xbfff)	/* QUADRANT 3 */
	{
	  Quad_ptr = (Wave_ptr_a-0x7fff)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL1 = (PWM_MODULUS/2) - (Pwmmod_wave>>8);
												/* update PVAL1 register 
											       for QUADRANT 3 */
	}
			
	else  	/* (Wave_ptr_a < 0xffff)    QUADRANT 4 */			   
	{
	  Quad_ptr = (0xffff - Wave_ptr_a)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL1 = (PWM_MODULUS/2) - (Pwmmod_wave>>8);
												/* update PVAL1 register 
											       for QUADRANT 4 */
	}
								
	/* PVAL2 is updated automaticaly because of COMPLEMENTARY PWM MODE */


/* PHASE B */	

	Wave_ptr_b = Wave_ptr_a + 0x5555;

	if (Wave_ptr_b < 0x4000)		/* QUADRANT 1 */
	{
	  Quad_ptr = Wave_ptr_b<<2;					/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */			
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL3 = (Pwmmod_wave>>8) + (PWM_MODULUS/2);
												/* update PVAL3 register 
											       for QUADRANT 1 */
	}
		
	else if (Wave_ptr_b < 0x7fff)	/* QUADRANT 2 */
	{
	  Quad_ptr = (32767 - Wave_ptr_b)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */			
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL3 = (Pwmmod_wave>>8) + (PWM_MODULUS/2);
												/* update PVAL3 register 
											   	   for QUADRANT 2 */
	}
		
	else if (Wave_ptr_b < 0xbfff)	/* QUADRANT 3 */
	{
	  Quad_ptr = (Wave_ptr_b - 0x7fff)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL3 = (PWM_MODULUS/2) - (Pwmmod_wave>>8);
												/* update PVAL3 register 
											       for QUADRANT 3 */
	}
			
	else  	/* (Wave_ptr_b < 0xffff)    QUADRANT 4 */			   
	{
	  Quad_ptr = (0xffff - Wave_ptr_b)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL3 = (PWM_MODULUS/2) - (Pwmmod_wave>>8);
												/* update PVAL3 register 
											       for QUADRANT 4 */
	}
									
	/* PVAL4 is updated automaticaly because of COMPLEMENTARY PWM MODE */



/* PHASE C */	

	Wave_ptr_c = Wave_ptr_a + 0xaaaa;

	if (Wave_ptr_c < 0x4000)		/* QUADRANT 1 */
	{
	  Quad_ptr = Wave_ptr_c<<2;					/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */			
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL5 = (Pwmmod_wave>>8) + (PWM_MODULUS/2);
												/* update PVAL5 register 
											   	   for QUADRANT 1 */
	}
		
	else if (Wave_ptr_c < 0x7fff)	/* QUADRANT 2 */
	{
	  Quad_ptr = (32767 - Wave_ptr_c)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */			
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL5 = (Pwmmod_wave>>8) + (PWM_MODULUS/2);
												/* update PVAL5 register 
											   	   for QUADRANT 2 */
	}
		
	else if (Wave_ptr_c < 0xbfff)	/* QUADRANT 3 */
	{
	  Quad_ptr = (Wave_ptr_c - 0x7fff)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL5 = (PWM_MODULUS/2) - (Pwmmod_wave>>8);
												/* update PVAL5 register 
											   	   for QUADRANT 3 */
	}
			
	else  	/* (Wave_ptr_c < 0xffff)  QUADRANT 4 */			   
	{
	  Quad_ptr = (0xffff - Wave_ptr_c)<<2;		/* quadrant pointer */
	  Table_value = (wavequad[Quad_ptr>>8]); 	/* fetch value from table */
	  Pwmmod_wave = (Table_value * Amplitude);	/* scale by Amplitude */		
	  PVAL5 = (PWM_MODULUS/2) - (Pwmmod_wave>>8);
												/* update PVAL5 register 
											   	   for QUADRANT 4 */
	}
								
	/* PVAL6 is updated automaticaly because of COMPLEMENTARY PWM MODE */


	Wave_ptr_a += Table_inc;		/* load new wave pointer for phase A */	
	PCTL1 |= 0x02;				/* set LDOK bit */
				
	}