EQEP

Table of Contents

• Features Supported
• SysConfig Features
• Features NOT Supported
• Important Usage Guidelines
• Example Usage
• API

The eQEP driver provides API to configure eQEP module. Below are the high level features supported by the driver.

Features Supported

• Configuration of position counter and control unit for position and direction measurement
• Configuration of unit time base for speed and frequency measurement
• Configuration of quadrature edge capture unit for low-speed measurement
• Configuration of watchdog timer for detecting stalls

SysConfig Features

Note

It is strongly recommend to use SysConfig where it is available instead of using direct SW API calls. This will help simplify the SW application and also catch common mistakes early in the development cycle.

SysConfig can be used to configure below parameters apart from common configuration like Clock, MPU, RAT and others.

• EQEP instances and pin mux configurations.

Features NOT Supported

NA

Important Usage Guidelines

NA

Example Usage

Include the below file to access the APIs

#include <drivers/eqep.h>

EQEP Interrupt Registration

    int32_t             status = SystemP_SUCCESS;
    HwiP_Params         hwiPrms;
 
    /* Register & enable interrupt */
    HwiP_Params_init(&hwiPrms);
    hwiPrms.intNum      = CONFIG_EQEP0_INTR;
    hwiPrms.callback    = &App_eqepIntrISR;
    hwiPrms.isPulse     = CONFIG_EQEP0_INTR_IS_PULSE;
    status              = HwiP_construct(&gEqepHwiObject, &hwiPrms);
    DebugP_assert(status == SystemP_SUCCESS);

EQEP Quadrature Mode Position Measurement Configuration

    /* Configure the decoder for quadrature mode, counting rising edge
      (that is, 1x resolution) */
    EQEP_setDecoderConfig(gEqepBaseAddr, (EQEP_CONFIG_1X_RESOLUTION |
                                        EQEP_CONFIG_QUADRATURE |
                                        EQEP_CONFIG_NO_SWAP));
 
    /* Configure the position counter to reset on an index event */
    EQEP_setPositionCounterConfig(gEqepBaseAddr, EQEP_POSITION_RESET_IDX,
                                  CSL_EQEP_QPOSCNT_QPOSCNT_MAX);
 
    /* Configure the position counter to be latched on rising edge index */
    EQEP_setLatchMode(gEqepBaseAddr, EQEP_LATCH_RISING_INDEX);
 
    /* Enable EQEP Module and Interrupt */
    EQEP_enableModule(gEqepBaseAddr);
    EQEP_enableInterrupt(gEqepBaseAddr, EQEP_INT_INDEX_EVNT_LATCH);

EQEP Quadrature Mode Frequency Measurement Configuration

    /* Configure the decoder for up-count mode, counting both rising and
       falling edges (that is, 2x resolution) */
    EQEP_setDecoderConfig(gEqepBaseAddr, (EQEP_CONFIG_2X_RESOLUTION |
                                          EQEP_CONFIG_UP_COUNT |
                                          EQEP_CONFIG_NO_SWAP));
 
    /* Configure the position counter to reset on an unit timeout event */
    EQEP_setPositionCounterConfig(gEqepBaseAddr,
                                  EQEP_POSITION_RESET_UNIT_TIME_OUT,
                                  CSL_EQEP_QPOSCNT_QPOSCNT_MAX);
 
    /* Enable the unit timer, setting the frequency to EQEP_UNIT_TIMEOUT_FREQ */
    EQEP_enableUnitTimer(gEqepBaseAddr, (CONFIG_EQEP0_FCLK / (EQEP_UNIT_TIMEOUT_FREQ)));
 
    /* Configure the position counter to be latched on a unit time out */
    EQEP_setLatchMode(gEqepBaseAddr, EQEP_LATCH_UNIT_TIME_OUT);
 
    /* Enable the EQEP module */
    EQEP_enableModule(gEqepBaseAddr);
 
    /* Configure and enable the edge-capture unit. The capture clock divider is
       SYSCLKOUT/128. The unit-position event divider is QCLK/8. */
    EQEP_setCaptureConfig(gEqepBaseAddr, EQEP_CAPTURE_CLK_DIV_128,
                          EQEP_UNIT_POS_EVNT_DIV_8);
    EQEP_enableCapture(gEqepBaseAddr);
 
    /* Enable unit timeout interrupt. */
    EQEP_enableInterrupt(gEqepBaseAddr, EQEP_INT_UNIT_TIME_OUT);

EQEP Interrupt Service Routine

    intStatus = EQEP_getInterruptStatus(gEqepBaseAddr);
    intEnabled = EQEP_getEnabledInterrupt(gEqepBaseAddr);
    if (((intStatus & EQEP_INT_INDEX_EVNT_LATCH) != 0) &&
        ((intEnabled & EQEP_INT_INDEX_EVNT_LATCH) != 0))
    {
        /* Get the position latch count */
        if (gEqepIsrCnt < EQEP_EVENT_CNT)
        {
            gEqepPosCnt[gEqepIsrCnt] = EQEP_getIndexPositionLatch(gEqepBaseAddr);
        }
        if (gEqepIsrCnt == (EQEP_EVENT_CNT - 1))
        {
            EQEP_disableInterrupt(gEqepBaseAddr, EQEP_INT_ALL);
            SemaphoreP_post(&gEqepSyncSem);
        }
        gEqepIsrCnt++;
    }
    if (((intStatus & EQEP_INT_UNIT_TIME_OUT) != 0) &&
        ((intEnabled & EQEP_INT_UNIT_TIME_OUT) != 0))
    {
        /* Get the position latch count */
        if (gEqepIsrCnt < EQEP_EVENT_CNT)
        {
            gEqepPosCnt[gEqepIsrCnt] = EQEP_getPositionLatch(gEqepBaseAddr);
        }
        if (gEqepIsrCnt == (EQEP_EVENT_CNT - 1))
        {
            EQEP_disableInterrupt(gEqepBaseAddr, EQEP_INT_ALL);
            SemaphoreP_post(&gEqepSyncSem);
        }
        gEqepIsrCnt++;
    }
 
    /* Clear EQEP Interrupt. */
    EQEP_clearInterruptStatus(gEqepBaseAddr, EQEP_INT_ALL);

EQEP Interrupt De-Registration

    HwiP_destruct(&gEqepHwiObject);

API

APIs for EQEP