rt-thread/bsp/nxp/lpc/lpc408x/Libraries/Drivers/source/lpc_qei.c

/**********************************************************************
* $Id$      lpc_qei.c           2011-06-02
*//**
* @file     lpc_qei.c
* @brief    Contains all functions support for QEI firmware library
*           on LPC
* @version  1.0
* @date     02. June. 2011
* @author   NXP MCU SW Application Team
* 
* Copyright(C) 2011, NXP Semiconductor
* All rights reserved.
*
***********************************************************************
* Software that is described herein is for illustrative purposes only
* which provides customers with programming information regarding the
* products. This software is supplied "AS IS" without any warranties.
* NXP Semiconductors assumes no responsibility or liability for the
* use of the software, conveys no license or title under any patent,
* copyright, or mask work right to the product. NXP Semiconductors
* reserves the right to make changes in the software without
* notification. NXP Semiconductors also make no representation or
* warranty that such application will be suitable for the specified
* use without further testing or modification.
* Permission to use, copy, modify, and distribute this software and its
* documentation is hereby granted, under NXP Semiconductors'
* relevant copyright in the software, without fee, provided that it
* is used in conjunction with NXP Semiconductors microcontrollers.  This
* copyright, permission, and disclaimer notice must appear in all copies of
* this code.
**********************************************************************/

/* Peripheral group ----------------------------------------------------------- */
/** @addtogroup QEI
 * @{
 */
#ifdef __BUILD_WITH_EXAMPLE__
#include "lpc_libcfg.h"
#else
#include "lpc_libcfg_default.h"
#endif /* __BUILD_WITH_EXAMPLE__ */
#ifdef _QEI

/* Includes ------------------------------------------------------------------- */
#include "lpc_qei.h"
#include "lpc_clkpwr.h"

/* Private Types -------------------------------------------------------------- */
/** @defgroup QEI_Private_Types QEI Private Types
 * @{
 */

/**
 * @brief QEI configuration union type definition
 */
typedef union {
    QEI_CFG_Type bmQEIConfig;
    uint32_t ulQEIConfig;
} QEI_CFGOPT_Type;

/**
 * @}
 */

LPC_QEI_TypeDef* QEI_GetPointer(uint8_t qeiId);


/* Public Functions ----------------------------------------------------------- */
/** @addtogroup QEI_Public_Functions
 * @{
 */

/*********************************************************************//**
 * @brief       Get the point to typedef of QEI component
 * @param[in]   qeiId           The Id of the expected QEI component
 *                              It should be 0 (zero) always with LPC
 * @return      None
 **********************************************************************/
LPC_QEI_TypeDef* QEI_GetPointer(uint8_t qeiId)
{
    LPC_QEI_TypeDef* pQei = NULL;

    if(qeiId == 0)
    {
        pQei = LPC_QEI;
    }

    return pQei;
}


/*********************************************************************//**
 * @brief       Resets value for each type of QEI value, such as velocity,
 *              counter, position, etc..
 * @param[in]   qeiId           The Id of the expected QEI component
 *                              It should be 0 (zero) always with LPC
 *
 * @param[in]   ulResetType     QEI Reset Type, should be one of the following:
 *                              - QEI_RESET_POS: Reset Position Counter
 *                              - QEI_RESET_POSOnIDX: Reset Position Counter on Index signal
 *                              - QEI_RESET_VEL: Reset Velocity
 *                              - QEI_RESET_IDX: Reset Index Counter
 * @return      None
 **********************************************************************/
void QEI_Reset(uint8_t qeiId, uint32_t ulResetType)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    pQei->CON = ulResetType;
}

/*********************************************************************//**
 * @brief       Initializes the QEI peripheral according to the specified
*               parameters in the QEI_ConfigStruct.
* @param[in]    qeiId           The Id of the expected QEI component
*                               It should be 0 (zero) always with LPC
*
* @param[in]    QEI_ConfigStruct    Pointer to a QEI_CFG_Type structure
*                    that contains the configuration information for the
*                    specified QEI peripheral
 * @return      None
 **********************************************************************/
void QEI_Init(uint8_t qeiId, QEI_CFG_Type *QEI_ConfigStruct)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    /* Set up clock and power for QEI module */
    CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCQEI, ENABLE);

    // Reset all remaining value in QEI peripheral

    pQei->MAXPOS = 0x00;
    pQei->CMPOS0 = 0x00;
    pQei->CMPOS1 = 0x00;
    pQei->CMPOS2 = 0x00;
    pQei->INXCMP0 = 0x00;
    pQei->VELCOMP = 0x00;

    pQei->LOAD = 0x00;
    pQei->CON = QEI_CON_RESP | QEI_CON_RESV | QEI_CON_RESI;

    pQei->FILTERPHA = 0x00;
    pQei->FILTERPHB = 0x00;
    pQei->FILTERINX = 0x00;

    // Disable all Interrupt
    pQei->IEC = QEI_IECLR_BITMASK;

    // Clear all Interrupt pending
    pQei->CLR = QEI_INTCLR_BITMASK;

    // Set QEI configuration value corresponding to its setting up value
    pQei->CONF = ((QEI_CFGOPT_Type *)QEI_ConfigStruct)->ulQEIConfig;
}


/*********************************************************************//**
 * @brief       De-initializes the QEI peripheral registers to their
 *                  default reset values.
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @return      None
 **********************************************************************/
void QEI_DeInit(uint8_t qeiId)
{
    /* Turn off clock and power for QEI module */
    CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCQEI, DISABLE);
}


/*****************************************************************************//**
* @brief        Fills each QIE_InitStruct member with its default value:
*               - DirectionInvert = QEI_DIRINV_NONE
*               - SignalMode = QEI_SIGNALMODE_QUAD
*               - CaptureMode = QEI_CAPMODE_4X
*               - InvertIndex = QEI_INVINX_NONE
* @param[in]    QIE_InitStruct Pointer to a QEI_CFG_Type structure
*                    which will be initialized.
* @return       None
*******************************************************************************/
void QEI_GetCfgDefault(QEI_CFG_Type *QIE_InitStruct)
{
    QIE_InitStruct->CaptureMode = QEI_CAPMODE_4X;
    QIE_InitStruct->DirectionInvert = QEI_DIRINV_NONE;
    QIE_InitStruct->InvertIndex = QEI_INVINX_NONE;
    QIE_InitStruct->SignalMode = QEI_SIGNALMODE_QUAD;
}


/*********************************************************************//**
 * @brief       Check whether if specified flag status is set or not
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulFlagType  Status Flag Type, should be one of the following:
 *                          - QEI_STATUS_DIR: Direction Status
 * @return      New Status of this status flag (SET or RESET)
 **********************************************************************/
FlagStatus QEI_GetStatus(uint8_t qeiId, uint32_t ulFlagType)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    return ((pQei->STAT & ulFlagType) ? SET : RESET);
}

/*********************************************************************//**
 * @brief       Get current position value in QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @return      Current position value of QEI peripheral
 **********************************************************************/
uint32_t QEI_GetPosition(uint8_t qeiId)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    return (pQei->POS);
}

/*********************************************************************//**
 * @brief       Set max position value for QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulMaxPos    Max position value to set
 * @return      None
 **********************************************************************/
void QEI_SetMaxPosition(uint8_t qeiId, uint32_t ulMaxPos)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    pQei->MAXPOS = ulMaxPos;
}

/*********************************************************************//**
 * @brief       Set position compare value for QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   bPosCompCh  Compare Position channel, should be:
 *                          - QEI_COMPPOS_CH_0: QEI compare position channel 0
 *                          - QEI_COMPPOS_CH_1: QEI compare position channel 1
 *                          - QEI_COMPPOS_CH_2: QEI compare position channel 2
 * @param[in]   ulPosComp   Compare Position value to set
 * @return      None
 **********************************************************************/
void QEI_SetPositionComp(uint8_t qeiId, uint8_t bPosCompCh, uint32_t ulPosComp)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);
    uint32_t *tmp;

    tmp = (uint32_t *) (&(pQei->CMPOS0) + bPosCompCh * 4);
    *tmp = ulPosComp;
}

/*********************************************************************//**
 * @brief       Get current index counter of QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @return      Current value of QEI index counter
 **********************************************************************/
uint32_t QEI_GetIndex(uint8_t qeiId)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    return (pQei->INXCNT);
}

/*********************************************************************//**
 * @brief       Set value for index compare in QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulIndexComp     Compare Index Value to set
 * @return      None
 **********************************************************************/
void QEI_SetIndexComp(uint8_t qeiId, uint32_t ulIndexComp)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    pQei->INXCMP0 = ulIndexComp;
}

/*********************************************************************//**
 * @brief       Set timer reload value for QEI peripheral. When the velocity timer is
 *              over-flow, the value that set for Timer Reload register will be loaded
 *              into the velocity timer for next period. The calculated velocity in RPM
 *              therefore will be affect by this value.
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   QEIReloadStruct QEI reload structure
 * @return      None
 **********************************************************************/
void QEI_SetTimerReload(uint8_t qeiId, QEI_RELOADCFG_Type *QEIReloadStruct)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);
    uint64_t pclk;


    if (QEIReloadStruct->ReloadOption == QEI_TIMERRELOAD_TICKVAL)
    {
        pQei->LOAD = QEIReloadStruct->ReloadValue - 1;
    }
    else
    {
#if 1
        pclk = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);

        pclk = (pclk /(1000000/QEIReloadStruct->ReloadValue)) - 1;

        pQei->LOAD = (uint32_t)pclk;
#else
        ld = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);

        if (ld/1000000 > 0)
        {
            ld /= 1000000;
            ld *= QEIReloadStruct->ReloadValue;
            ld -= 1;
        }
        else
        {
            ld *= QEIReloadStruct->ReloadValue;
            ld /= 1000000;
            ld -= 1;
        }

        pQei->LOAD = ld;
#endif
    }
}

/*********************************************************************//**
 * @brief       Get current timer counter in QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @return      Current timer counter in QEI peripheral
 **********************************************************************/
uint32_t QEI_GetTimer(uint8_t qeiId)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    return (pQei->TIME);
}

/*********************************************************************//**
 * @brief       Get current velocity pulse counter in current time period
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @return      Current velocity pulse counter value
 **********************************************************************/
uint32_t QEI_GetVelocity(uint8_t qeiId)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    return (pQei->VEL);
}

/*********************************************************************//**
 * @brief       Get the most recently measured velocity of the QEI. When
 *              the Velocity timer in QEI is over-flow, the current velocity
 *              value will be loaded into Velocity Capture register.
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @return      The most recently measured velocity value
 **********************************************************************/
uint32_t QEI_GetVelocityCap(uint8_t qeiId)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    return (pQei->CAP);
}

/*********************************************************************//**
 * @brief       Set Velocity Compare value for QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulVelComp       Compare Velocity value to set
 * @return      None
 **********************************************************************/
void QEI_SetVelocityComp(uint8_t qeiId, uint32_t ulVelComp)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    pQei->VELCOMP = ulVelComp;
}

/*********************************************************************//**
 * @brief       Set value of sampling count for the digital filter in
 *              QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulSamplingPulse Value of sampling count to set
 * @return      None
 **********************************************************************/
void QEI_SetDigiFilter(uint8_t qeiId, st_Qei_FilterCfg FilterVal)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    pQei->FILTERPHA = FilterVal.PHA_FilterVal;
    pQei->FILTERPHB = FilterVal.PHB_FilterVal;
    pQei->FILTERINX = FilterVal.INX_FilterVal;
}

/*********************************************************************//**
 * @brief       Check whether if specified interrupt flag status in QEI
 *              peripheral is set or not
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulIntType       Interrupt Flag Status type, should be:
                - QEI_INTFLAG_INX_Int: index pulse was detected interrupt
                - QEI_INTFLAG_TIM_Int: Velocity timer over flow interrupt
                - QEI_INTFLAG_VELC_Int: Capture velocity is less than compare interrupt
                - QEI_INTFLAG_DIR_Int: Change of direction interrupt
                - QEI_INTFLAG_ERR_Int: An encoder phase error interrupt
                - QEI_INTFLAG_ENCLK_Int: An encoder clock pulse was detected interrupt
                - QEI_INTFLAG_POS0_Int: position 0 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS1_Int: position 1 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS2_Int: position 2 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_REV_Int: Index compare value is equal to the current
                                        index count interrupt
                - QEI_INTFLAG_POS0REV_Int: Combined position 0 and revolution count interrupt
                - QEI_INTFLAG_POS1REV_Int: Combined position 1 and revolution count interrupt
                - QEI_INTFLAG_POS2REV_Int: Combined position 2 and revolution count interrupt
 * @return      New State of specified interrupt flag status (SET or RESET)
 **********************************************************************/
FlagStatus QEI_GetIntStatus(uint8_t qeiId, uint32_t ulIntType)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    return((pQei->INTSTAT & ulIntType) ? SET : RESET);
}

/*********************************************************************//**
 * @brief       Enable/Disable specified interrupt in QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulIntType       Interrupt Flag Status type, should be:
                - QEI_INTFLAG_INX_Int: index pulse was detected interrupt
                - QEI_INTFLAG_TIM_Int: Velocity timer over flow interrupt
                - QEI_INTFLAG_VELC_Int: Capture velocity is less than compare interrupt
                - QEI_INTFLAG_DIR_Int: Change of direction interrupt
                - QEI_INTFLAG_ERR_Int: An encoder phase error interrupt
                - QEI_INTFLAG_ENCLK_Int: An encoder clock pulse was detected interrupt
                - QEI_INTFLAG_POS0_Int: position 0 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS1_Int: position 1 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS2_Int: position 2 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_REV_Int: Index compare value is equal to the current
                                        index count interrupt
                - QEI_INTFLAG_POS0REV_Int: Combined position 0 and revolution count interrupt
                - QEI_INTFLAG_POS1REV_Int: Combined position 1 and revolution count interrupt
                - QEI_INTFLAG_POS2REV_Int: Combined position 2 and revolution count interrupt
 * @param[in]   NewState        New function state, should be:
 *                              - DISABLE
 *                              - ENABLE
 * @return      None
 **********************************************************************/
void QEI_IntCmd(uint8_t qeiId, uint32_t ulIntType, FunctionalState NewState)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    if (NewState == ENABLE)
    {
        pQei->IES = ulIntType;
    }
    else
    {
        pQei->IEC = ulIntType;
    }
}


/*********************************************************************//**
 * @brief       Sets (forces) specified interrupt in QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulIntType       Interrupt Flag Status type, should be:
                - QEI_INTFLAG_INX_Int: index pulse was detected interrupt
                - QEI_INTFLAG_TIM_Int: Velocity timer over flow interrupt
                - QEI_INTFLAG_VELC_Int: Capture velocity is less than compare interrupt
                - QEI_INTFLAG_DIR_Int: Change of direction interrupt
                - QEI_INTFLAG_ERR_Int: An encoder phase error interrupt
                - QEI_INTFLAG_ENCLK_Int: An encoder clock pulse was detected interrupt
                - QEI_INTFLAG_POS0_Int: position 0 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS1_Int: position 1 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS2_Int: position 2 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_REV_Int: Index compare value is equal to the current
                                        index count interrupt
                - QEI_INTFLAG_POS0REV_Int: Combined position 0 and revolution count interrupt
                - QEI_INTFLAG_POS1REV_Int: Combined position 1 and revolution count interrupt
                - QEI_INTFLAG_POS2REV_Int: Combined position 2 and revolution count interrupt
 * @return      None
 **********************************************************************/
void QEI_IntSet(uint8_t qeiId, uint32_t ulIntType)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    pQei->SET = ulIntType;
}

/*********************************************************************//**
 * @brief       Clear (force) specified interrupt (pending) in QEI peripheral
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulIntType       Interrupt Flag Status type, should be:
                - QEI_INTFLAG_INX_Int: index pulse was detected interrupt
                - QEI_INTFLAG_TIM_Int: Velocity timer over flow interrupt
                - QEI_INTFLAG_VELC_Int: Capture velocity is less than compare interrupt
                - QEI_INTFLAG_DIR_Int: Change of direction interrupt
                - QEI_INTFLAG_ERR_Int: An encoder phase error interrupt
                - QEI_INTFLAG_ENCLK_Int: An encoder clock pulse was detected interrupt
                - QEI_INTFLAG_POS0_Int: position 0 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS1_Int: position 1 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_POS2_Int: position 2 compare value is equal to the
                                        current position interrupt
                - QEI_INTFLAG_REV_Int: Index compare value is equal to the current
                                        index count interrupt
                - QEI_INTFLAG_POS0REV_Int: Combined position 0 and revolution count interrupt
                - QEI_INTFLAG_POS1REV_Int: Combined position 1 and revolution count interrupt
                - QEI_INTFLAG_POS2REV_Int: Combined position 2 and revolution count interrupt
 * @return      None
 **********************************************************************/
void QEI_IntClear(uint8_t qeiId, uint32_t ulIntType)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    pQei->CLR = ulIntType;
}


/*********************************************************************//**
 * @brief       Calculates the actual velocity in RPM passed via velocity
 *              capture value and Pulse Per Round (of the encoder) value
 *              parameter input.
 * @param[in]    qeiId           The Id of the expected QEI component
 *                               It should be 0 (zero) always with LPC
 *
 * @param[in]   ulVelCapValue   Velocity capture input value that can
 *                              be got from QEI_GetVelocityCap() function
 * @param[in]   ulPPR           Pulse per round of encoder
 * @return      The actual value of velocity in RPM (Round per minute)
 **********************************************************************/
uint32_t QEI_CalculateRPM(uint8_t qeiId, uint32_t ulVelCapValue, uint32_t ulPPR)
{
    LPC_QEI_TypeDef* pQei = QEI_GetPointer(qeiId);

    uint64_t rpm, clock, Load, edges;

    // Get current Clock rate for timer input
    clock = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);

    // Get Timer load value (velocity capture period)
    Load  = (uint64_t)(pQei->LOAD + 1);

    // Get Edge
    edges = (uint64_t)((pQei->CONF & QEI_CONF_CAPMODE) ? 4 : 2);

    // Calculate RPM
    rpm = ((clock * ulVelCapValue * 60) / (Load * ulPPR * edges));

    return (uint32_t)(rpm);
}


/**
 * @}
 */

#endif /*_QEI*/

/**
 * @}
 */

/* --------------------------------- End Of File ------------------------------ */