hal_ftm_cap.c

最新版IAR FOR ARM（EWARM）5.11中的代码例子

/************************************************************************/
/*                                                                      */
/*    Copyright (C) 2006 Oki Electric Industry Co., LTD.                */
/*                                                                      */
/*    System Name    :  ML675050 series                                 */
/*    Module Name    :  ML675050 FTM_CAP HAL program                    */
/*    File   Name    :  hal_ftm_cap.c                                   */
/*    Date           :  2005/01/23 initial version                      */
/*                                                                      */
/************************************************************************/
#include "common.h"

#if defined(__arm)
#include "ml675050.h"
#elif defined(_WIN32)
#include "ml675050sim.h"
#else
#error COMPILER ERROR
#endif

#include "hal_state.h"
#include "hal_common.h"
#include "hal_interrupt.h"
#include "hal_ftm_cap.h"


/******************************/
/*     Private defines        */
/******************************/
/*--------- function ---------*/
static void _cap0_handler(void);

/******************************/
/*     Public defines         */
/******************************/
static volatile uint16_t int_flg = 0;		    /* cap interrupt count flag */
static volatile uint16_t pulse_start_time ;	/* first captured time */
static volatile uint16_t pulse_end_time ;	    /* second captured time */

FP cap0_handler = _cap0_handler;

/************************************************************************/
/*                                                                      */
/*  Function Name   : HALCap_FtmCapInit                                 */
/*  Input           : struct ML675050_FtmCap                            */
/*  Output          : int16_t HAL_OK(1)                                 */
/*                            HAL_PARAM_ERROR(-2)                       */
/*  Note            : Initialize ftm_cap.                               */
/*                                                                      */
/************************************************************************/
void HALCap_FtmCapInit(void)
{
    OkiCLib_write16(FTM0CON,FTM0CON_CAP | FTMCON_FTMCLK16);   /* Ftm0 mode set. */
    OkiCLib_write16(FTM0IER, FTM0IER_CMOIE_CAPIE);           /* Ftm0 interrupt enable .*/
	OkiCLib_write16(FTM0IOLV, 0x01) ;                        /* set rising edge to capture trigger */
    OkiCLib_write16(FTM0R, 0x00);                            /* set CAP cycle */
	OkiCLib_write16(FTM0ST, 0x0001) ;                        /* cap interrupt request clear */

	OkiCLib_write16(FTM1CON,FTM1CON_PWM | FTMCON_FTMCLK16);   /* Ftm1 mode set. */
    OkiCLib_write16(FTM1C, VALUE_OF_FTMnR);                  /* Ftm1 interrupt cycle.*/
	OkiCLib_write16(FTM1IOLV, 0x01) ;                        /* set PWM out */
	OkiCLib_write16(FTM1GR, VALUE_OF_FTMnGR);                /* set PWM duty */

}

/************************************************************************/
/*                                                                      */
/*  Function Name   : HALCap_FtmCapStart                                */
/*  Input           : start 1: start  0: stop.                          */
/*  Output          : int16_t HAL_OK(1)                                 */
/*                            HAL_PARAM_ERROR(-2)                       */
/*  Note            :   ftm_cap start or stop.                          */
/*                                                                      */
/************************************************************************/
int16_t HALCap_FtmCapStart(uint16_t start)
{
	int16_t rtnVal = HAL_OK;

    if (start == 1) {
        OkiCLib_write16(FTMEN, 0x03);       /* CAP start. */
    }
    else {
        OkiCLib_write16(FTMDIS, 0x03);      /* CAP stop. */
    }

	return rtnVal;
}
/************************************************************************/
/*                                                                      */
/*  Function Name   : HALCap_FtmCapGet                                  */
/*  Input           : ML675050_CapParam *cap_param                      */
/*  Output          : int16_t HAL_OK(1)                                 */
/*                            HAL_PARAM_ERROR(-2)                       */
/*  Note            :   ftm_cap get.                                    */
/*                                                                      */
/************************************************************************/
int16_t HALCap_FtmCapGet(ML675050_CapParam *cap_param)
{
    int16_t rtnVal = HAL_OK;

	if (cap_param == NULL) {
        rtnVal = HAL_PARAM_ERROR;
    }

    if(rtnVal == HAL_OK){
		cap_param->start_time = pulse_start_time;
		cap_param->end_time = pulse_end_time;
	}
	
	return rtnVal;
}

/************************************************************************/
/*                                                                      */
/*  Function Name   : _cap_handler                                      */
/*  Input           : void                                              */
/*  Output          : void                                              */
/*                                                                      */
/*  Note : CAP handler.                                                 */
/*                                                                      */
/************************************************************************/
static void _cap0_handler(void)
{
    /* clear cap interrupt */
    OkiCLib_set16bit(FTM0ST,FTM0ST_CM_CAPEV);

    if(int_flg == 0)
    {
		/* save captured time to global variable A */
		pulse_start_time = OkiCLib_read16(FTM0GR) ;	
		int_flg = 1 ;
		
		/* set falling edge */
		OkiCLib_write16(FTM0IOLV, 0x0002) ;
	}
	else
	{
		/* save captured time to global variable B */
		pulse_end_time = OkiCLib_read16(FTM0GR) ;
		if(OkiCLib_read16(FTM0ST) & 0x2){
			pulse_end_time += 0xFFFF ;
		}
		int_flg = 2 ;
		
		/* disable cap1 interrupt */
		OkiCLib_clr16bit(FTM0IER, 0x1) ;

		CALL_BACK_TABLE[INT_FTM0](CALLBACK_STATE_CAP);
	}

    /* clear overflow interrupt */
    OkiCLib_set16bit(FTM0ST,FTM0ST_OVF);
}