lpc17xx_qei.c

Go to the documentation of this file.

/***********************************************************************/
/* Peripheral group ----------------------------------------------------------- */
/* Includes ------------------------------------------------------------------- */
#include "lpc17xx_qei.h"
#include "lpc17xx_clkpwr.h"


/* If this source file built with example, the LPC17xx FW library configuration
 * file in each example directory ("lpc17xx_libcfg.h") must be included,
 * otherwise the default FW library configuration file must be included instead
 */
#ifdef __BUILD_WITH_EXAMPLE__
#include "lpc17xx_libcfg.h"
#else
#include "lpc17xx_libcfg_default.h"
#endif /* __BUILD_WITH_EXAMPLE__ */


#ifdef _QEI

/* Private Types -------------------------------------------------------------- */
typedef union {
    QEI_CFG_Type bmQEIConfig;
    uint32_t ulQEIConfig;
} QEI_CFGOPT_Type;

/* Public Functions ----------------------------------------------------------- */
/*********************************************************************/
void QEI_Reset(LPC_QEI_TypeDef *QEIx, uint32_t ulResetType)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_RESET(ulResetType));

    QEIx->QEICON = ulResetType;
}

/*********************************************************************/
void QEI_Init(LPC_QEI_TypeDef *QEIx, QEI_CFG_Type *QEI_ConfigStruct)
{

    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_DIRINV(QEI_ConfigStruct->DirectionInvert));
    CHECK_PARAM(PARAM_QEI_SIGNALMODE(QEI_ConfigStruct->SignalMode));
    CHECK_PARAM(PARAM_QEI_CAPMODE(QEI_ConfigStruct->CaptureMode));
    CHECK_PARAM(PARAM_QEI_INVINX(QEI_ConfigStruct->InvertIndex));

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

    /* As default, peripheral clock for QEI module
     * is set to FCCLK / 2 */
    CLKPWR_SetPCLKDiv(CLKPWR_PCLKSEL_QEI, CLKPWR_PCLKSEL_CCLK_DIV_1);

    // Reset all remaining value in QEI peripheral
    QEIx->QEICON = QEI_CON_RESP | QEI_CON_RESV | QEI_CON_RESI;
    QEIx->QEIMAXPOS = 0x00;
    QEIx->CMPOS0 = 0x00;
    QEIx->CMPOS1 = 0x00;
    QEIx->CMPOS2 = 0x00;
    QEIx->INXCMP = 0x00;
    QEIx->QEILOAD = 0x00;
    QEIx->VELCOMP = 0x00;
    QEIx->FILTER = 0x00;
    // Disable all Interrupt
    QEIx->QEIIEC = QEI_IECLR_BITMASK;
    // Clear all Interrupt pending
    QEIx->QEICLR = QEI_INTCLR_BITMASK;
    // Set QEI configuration value corresponding to its setting up value
    QEIx->QEICONF = ((QEI_CFGOPT_Type *)QEI_ConfigStruct)->ulQEIConfig;
}


/*********************************************************************/
void QEI_DeInit(LPC_QEI_TypeDef *QEIx)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));

    /* Turn off clock and power for QEI module */
    CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCQEI, DISABLE);
}


/*****************************************************************************/
void QEI_ConfigStructInit(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;
}


/*********************************************************************/
FlagStatus QEI_GetStatus(LPC_QEI_TypeDef *QEIx, uint32_t ulFlagType)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_STATUS(ulFlagType));
    return ((QEIx->QEISTAT & ulFlagType) ? SET : RESET);
}

/*********************************************************************/
uint32_t QEI_GetPosition(LPC_QEI_TypeDef *QEIx)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    return (QEIx->QEIPOS);
}

/*********************************************************************/
void QEI_SetMaxPosition(LPC_QEI_TypeDef *QEIx, uint32_t ulMaxPos)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    QEIx->QEIMAXPOS = ulMaxPos;
}

/*********************************************************************/
void QEI_SetPositionComp(LPC_QEI_TypeDef *QEIx, uint8_t bPosCompCh, uint32_t ulPosComp)
{
    uint32_t *tmp;

    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_COMPPOS_CH(bPosCompCh));
    tmp = (uint32_t *) (&(QEIx->CMPOS0) + bPosCompCh * 4);
    *tmp = ulPosComp;

}

/*********************************************************************/
uint32_t QEI_GetIndex(LPC_QEI_TypeDef *QEIx)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    return (QEIx->INXCNT);
}

/*********************************************************************/
void QEI_SetIndexComp(LPC_QEI_TypeDef *QEIx, uint32_t ulIndexComp)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    QEIx->INXCMP = ulIndexComp;
}

/*********************************************************************/
void QEI_SetTimerReload(LPC_QEI_TypeDef *QEIx, QEI_RELOADCFG_Type *QEIReloadStruct)
{
    uint64_t pclk;

    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_TIMERRELOAD(QEIReloadStruct->ReloadOption));

    if (QEIReloadStruct->ReloadOption == QEI_TIMERRELOAD_TICKVAL) {
        QEIx->QEILOAD = QEIReloadStruct->ReloadValue - 1;
    } else {
        pclk = (uint64_t)CLKPWR_GetPCLK(CLKPWR_PCLKSEL_QEI);
        pclk = (pclk /(1000000/QEIReloadStruct->ReloadValue)) - 1;
        QEIx->QEILOAD = (uint32_t)pclk;
    }
}

/*********************************************************************/
uint32_t QEI_GetTimer(LPC_QEI_TypeDef *QEIx)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    return (QEIx->QEITIME);
}

/*********************************************************************/
uint32_t QEI_GetVelocity(LPC_QEI_TypeDef *QEIx)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    return (QEIx->QEIVEL);
}

/*********************************************************************/
uint32_t QEI_GetVelocityCap(LPC_QEI_TypeDef *QEIx)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    return (QEIx->QEICAP);
}

/*********************************************************************/
void QEI_SetVelocityComp(LPC_QEI_TypeDef *QEIx, uint32_t ulVelComp)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    QEIx->VELCOMP = ulVelComp;
}

/*********************************************************************/
void QEI_SetDigiFilter(LPC_QEI_TypeDef *QEIx, uint32_t ulSamplingPulse)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    QEIx->FILTER = ulSamplingPulse;
}

/*********************************************************************/
FlagStatus QEI_GetIntStatus(LPC_QEI_TypeDef *QEIx, uint32_t ulIntType)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_INTFLAG(ulIntType));

    return((QEIx->QEIINTSTAT & ulIntType) ? SET : RESET);
}

/*********************************************************************/
void QEI_IntCmd(LPC_QEI_TypeDef *QEIx, uint32_t ulIntType, FunctionalState NewState)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_INTFLAG(ulIntType));
    CHECK_PARAM(PARAM_FUNCTIONALSTATE(NewState));

    if (NewState == ENABLE) {
        QEIx->QEIIES = ulIntType;
    } else {
        QEIx->QEIIEC = ulIntType;
    }
}


/*********************************************************************/
void QEI_IntSet(LPC_QEI_TypeDef *QEIx, uint32_t ulIntType)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_INTFLAG(ulIntType));

    QEIx->QEISET = ulIntType;
}

/*********************************************************************/
void QEI_IntClear(LPC_QEI_TypeDef *QEIx, uint32_t ulIntType)
{
    CHECK_PARAM(PARAM_QEIx(QEIx));
    CHECK_PARAM(PARAM_QEI_INTFLAG(ulIntType));

    QEIx->QEICLR = ulIntType;
}


/*********************************************************************/
uint32_t QEI_CalculateRPM(LPC_QEI_TypeDef *QEIx, uint32_t ulVelCapValue, uint32_t ulPPR)
{
    uint64_t rpm, clock, Load, edges;

    // Get current Clock rate for timer input
    clock = (uint64_t)CLKPWR_GetPCLK(CLKPWR_PCLKSEL_QEI);
    // Get Timer load value (velocity capture period)
    Load  = (uint64_t)(QEIx->QEILOAD + 1);
    // Get Edge
    edges = (uint64_t)((QEIx->QEICONF & QEI_CONF_CAPMODE) ? 4 : 2);
    // Calculate RPM
    rpm = ((clock * ulVelCapValue * 60) / (Load * ulPPR * edges));

    return (uint32_t)(rpm);
}


#endif /* _QEI */

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