code_isr.c

3 phase motor driver source code with freescale MCU

 /***********************************************************************
 * HEADER_START                                                        *
 *                                                                     *
 *      Name:           Code_ISR                                       *
 *      Project:									                   *
 *      Description:    interrupt subroutines                          *
 *      Processor:      HC08MR24                                       *
 *      HW:                                                            *
 *      Revision:       0.1                                            *
 *      Date:           31th May 1999                                  *
 *      Compiler:       C crosscompiler HIWARE HICROSS+Version 5.0.6   *
 *      Author:         Libor Prokop(R30322), Radim Visinka            *
 *      Company:        Motorola SPS                                   *
 *                      Roznov System Application Laboratory           *
 *                      Roznov pod Radhostem, Czech Republic           *
 *      Security:       Confidential Proprietary                       *
 *      Note:           Positive polarity set in MOR register          *
 *                      when break with Hiwave all IGBTs are OFF!!!    *
 *                                                                     *
 * =================================================================== *
 * 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.                                  *
 * =================================================================== *
 *
 * HEADER_END
 */

/* DEFINITION_START */


/* Include Header Files */

#include <Mr24io.h>			 /* file contains global constants and
							   definitions */
/* Assembler Subroutine Definitions */

/* Constant Definitions */

/* Global Variables (External) - 8 bit */

/* Global Variables (External) - 16 bit */

/* Local Variables - 8 bit */

/* Local Variables - 16 bit */
			  

/* DEFINITION_END */


#pragma TRAP_PROC	
void SWI_Int(void)      /* software interrupt service routine */
    {
    while (1);          /* go to infinite loop for debugging */
	return;
    }

#pragma TRAP_PROC	    /* external interrupt service routine */
void IRQ1_Int(void)
    {
    while (1);          /* go to infinite loop for debugging */
	return;
    }

#pragma TRAP_PROC	    /* PLL interrupt service routine */
void PLL_Int(void)
    {
    while (1);          /* go to infinite loop for debugging */
	return;
    }

#pragma TRAP_PROC	    /* FAULT1 interrupt service routine */
void FAULT1_Int(void)
    {
    while (1);          /* go to infinite loop for debugging */
	return;
    }

#pragma TRAP_PROC	    /* FAULT2 interrupt service routine */
void FAULT2_Int(void)
    {
    fault();          /* fault interrupt */
	return;
    }

#pragma TRAP_PROC	    /* FAULT3 interrupt service routine */
void FAULT3_Int(void)
    {
    while (1);          /* go to infinite loop for debugging */
	return;
    }

#pragma TRAP_PROC	    /* FAULT4 interrupt service routine */
void FAULT4_Int(void)
    {
    while (1);          /* go to infinite loop for debugging */
	return;
    }

#pragma TRAP_PROC 
void PWMMC_Int(void)    /* PWM interrupt service routine */
	{ 
    PWMcalc ();          /* PWM reload interrupt */
	return;
    }

#pragma TRAP_PROC
void TIMACh0_Int(void)  /* timerA channel 0 interrupt service routine */
{ 
	while (1);          /* go to infinite loop for debugging */
	return;
}

#pragma TRAP_PROC
void TIMACh1_Int(void)  /* timerA channel 1 interrupt service routine */
{ 
	while (1);          /* go to infinite loop for debugging */
    return;
}
 
#pragma TRAP_PROC
void TIMACh2_Int(void)  /* timerA channel 2 interrupt service routine */
{ 
	while (1);          /* go to infinite loop for debugging */
	return;
}

#pragma TRAP_PROC
void TIMACh3_Int(void)  /* timerA channel 3 interrupt service routine */
{ 
	tacho();          /* tachogenerator interrupt */
    return;
}

#pragma TRAP_PROC 
void TIMAOv_Int(void)   /* timerA Overflow interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void TIMBCh0_Int(void)  /* timerB channel 0 interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void TIMBCh1_Int(void)  /* timerB channel 1 interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void TIMBOv_Int(void)   /* timerB Overflow interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void AD_Int(void)       /* A/D interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void SPIRec_Int(void)   /* SPI receiver interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void SPITr_Int(void)    /* SPI transmit. interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void SCIErr_Int(void)   /* SCI error interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void SCI_Int(void)      /* SCI interrupt service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}

#pragma TRAP_PROC 
void SCITr_Int(void)    /* SCI transmit service routine */
	{ 
	while (1);          /* go to infinite loop for debugging */
	return;
	}