GPTIMER

Table of Contents

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

The General-Purpose Timer driver provides APIs to configure the available timer modules in multiple modes.

Features Supported

• Interrupts generated on overflow, compare, and capture
• Free-running 32-bit upward counter
• Compare and capture modes
• Autoreload mode
• Start/stop mode
• Programmable divider clock source (2 exponent n, where n = [0-8])
• Dedicated input trigger for capture mode and dedicated output trigger/PWM signal
• On-the-fly read/write register

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.

• Set mode of operation of the timer
• Enable/Disable and Set counter Prescaler
• Enable/Disable Auto reload Mode and set Auto reload Value
• Enable Interrupt and Assign User Callback
• Set Compare value when Compare Match mode is set
• Set Counter mode and Capture event when Timer configured to capture input
• Set PWM output Trigger mode and Compare Value in PWM mode
• Set Default Output Polarity in PWM mode
• Set Output Pin Modulation in PWM mode

Features NOT Supported

• Atomic 64-bit timer value read of cascaded timers
• Smart-idle with wake-up mode

Example Usage

Include the below file to access the APIs

#include <drivers/gp_timer.h>

Instance Open Example

    GPTIMER_Params         params;
 
    /* Initialize parameters */
    GPTIMER_Params_init(&params);
 
    params.enablePrescaler = false,
    params.cntPrescaler = 0,
    params.oneShotMode = false,
    params.cntReloadVal = 0,
    params.overflowMaskCount = 0,
    params.counterInitVal = 0,
 
    /* Update object Parameters mode settings */
    gGpTimerObjects[CONFIG_GPTIMER0].timerConfigMode = GPTIMER_MODE_CONFIG_FREE_RUN;
    gGpTimerObjects[CONFIG_GPTIMER0].overflowCallbackFunction = NULL,
    gGpTimerObjects[CONFIG_GPTIMER0].compareMatchCallbackFunction = NULL,
    gGpTimerObjects[CONFIG_GPTIMER0].captureCallbackFunction = NULL,
 
    gGpTimerHandle = GPTIMER_open(CONFIG_GPTIMER0, &params);
    DebugP_assert(gGpTimerHandle != NULL);

Instance Close Example

    GPTIMER_close(gGpTimerHandle);

GPTIMER configuration in Free Running Mode without interrupt

 
void gptimer_free_run_no_interrupt(void)
{
 
    uint32_t conifgMode;
    conifgMode = GPTIMER_MODE_CONFIG_FREE_RUN;
 
    GPTIMER_setTimerConfigMode(gGpTimerHandle, conifgMode,
                               (void *)NULL);
    /* Start the Timer */
    GPTIMER_start(gGpTimerHandle);
 
}
 

GPTIMER configuration in Free Running Mode with interrupt

 
void overflowCallback(GPTIMER_Handle handle)
{
    /* Post Semaphore */
    SemaphoreP_post(&overflowSemObj);
}
 
void gptimer_free_run_interrupt(void)
{
 
    uint32_t conifgMode;
    conifgMode = GPTIMER_MODE_CONFIG_FREE_RUN;
 
    SemaphoreP_constructBinary(&overflowSemObj, 0);
 
    GPTIMER_setTimerConfigMode(gGpTimerHandle, conifgMode,
                               (void *)NULL);
    /* Add Callback */
    GPTIMER_setCallbackFxn(gGpTimerHandle, overflowCallback, NULL, NULL);
    /* Start the Timer */
    GPTIMER_start(gGpTimerHandle);
    /* Pend Semaphore */
    SemaphoreP_pend(&overflowSemObj, SystemP_WAIT_FOREVER);
 
    SemaphoreP_destruct(&overflowSemObj);
 
}
 

GPTIMER configuration in Output Compare Mode

 
void compareMatchCallback(GPTIMER_Handle handle)
{
    /* Post Semaphore */
    SemaphoreP_post(&compareMatchSemObj);
}
 
void gptimer_output_compare_interrupt(void)
{
    SemaphoreP_constructBinary(&compareMatchSemObj, 0);
 
    uint32_t conifgMode;
 
    conifgMode = GPTIMER_MODE_CONFIG_OUTPUT_COMPARE;
    compareConfig.cntCompareValComp = (0x017D7840U);
 
    GPTIMER_setTimerConfigMode(gGpTimerHandle, conifgMode,
                               (void *)(&compareConfig));
    /* Add Callback */
    GPTIMER_setCallbackFxn(gGpTimerHandle, NULL, compareMatchCallback, NULL);
    /* Start the TImer */
    GPTIMER_start(gGpTimerHandle);
    /* Pend Semaphore */
    SemaphoreP_pend(&compareMatchSemObj, SystemP_WAIT_FOREVER);
 
    SemaphoreP_destruct(&compareMatchSemObj);
}
 

GPTIMER configuration in Input Capture Mode

 
void CaptureCallbackUser(GPTIMER_Handle handle)
{
    /* Post Semaphore */
    SemaphoreP_post(&captureSemObj);
}
 
void gptimer_input_capture_interrupt(void)
{
    SemaphoreP_constructBinary(&captureSemObj, 0);
 
    uint32_t conifgMode;
 
    conifgMode = GPTIMER_MODE_CONFIG_INPUT_CAPTURE;
    inputCaptureConfig.captureMode = GPTIMER_INPUT_CAPTURE_MODE_SECOND;
    inputCaptureConfig.captureEventMode = GPTIMER_INPUT_CAPTURE_EVENT_EDGE;
 
    GPTIMER_setTimerConfigMode(gGpTimerHandle, conifgMode,
                              (void *)(&inputCaptureConfig));
    /* Add Callback */
    GPTIMER_setCallbackFxn(gGpTimerHandle, NULL, NULL, CaptureCallbackUser);
    /* Start the Timer */
    GPTIMER_start(gGpTimerHandle);
    /* Pend Semaphore */
    SemaphoreP_pend(&captureSemObj, SystemP_WAIT_FOREVER);
 
    SemaphoreP_destruct(&captureSemObj);
}
 

GPTIMER configuration in PWM Generation Mode

 
void gptimer_pwm_gen(void)
{
 
    uint32_t conifgMode;
 
    conifgMode = GPTIMER_MODE_CONFIG_PWM_GEN;
 
    pwmConfig.trigOutputPWMMode = GPTIMER_PWM_OUT_OVERFLOW_MATCH_TRIGGER,
    pwmConfig.defaultPWMOutSetting = GPTIMER_PWM_OUT_PIN_DEFAULT_0,
    pwmConfig.cntCompareValPWM = 4294954795,
    pwmConfig.outputModulationType = GPTIMER_PWM_OUT_PIN_MODULATION_TOGGLE,
 
    GPTIMER_setTimerConfigMode(gGpTimerHandle, conifgMode,
                              (void *)(&pwmConfig));
 
    /* Start the Timer */
    GPTIMER_start(gGpTimerHandle);
 
}
 

API

APIs for GPTIMER