timer.h

Go to the documentation of this file.

/******************************************************************************
*  Filename:       timer.h
*  Revised:        2015-11-03 09:54:47 +0100 (Tue, 03 Nov 2015)
*  Revision:       44933
*
*  Copyright (c) 2015 - 2016, Texas Instruments Incorporated
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions are met:
*
*  1) Redistributions of source code must retain the above copyright notice,
*     this list of conditions and the following disclaimer.
*
*  2) Redistributions in binary form must reproduce the above copyright notice,
*     this list of conditions and the following disclaimer in the documentation
*     and/or other materials provided with the distribution.
*
*  3) Neither the name of the ORGANIZATION nor the names of its contributors may
*     be used to endorse or promote products derived from this software without
*     specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
*  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
*  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
*  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
*  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
*  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
*  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/

//****************************************************************************
//
//
//****************************************************************************

#ifndef __GPT_H__
#define __GPT_H__

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif

#include <stdbool.h>
#include <stdint.h>
#include <inc/hw_ints.h>
#include <inc/hw_types.h>
#include <inc/hw_memmap.h>
#include <inc/hw_gpt.h>
#include <driverlib/interrupt.h>
#include <driverlib/debug.h>

//*****************************************************************************
//
// Support for DriverLib in ROM:
// This section renames all functions that are not "static inline", so that
// calling these functions will default to implementation in flash. At the end
// of this file a second renaming will change the defaults to implementation in
// ROM for available functions.
//
// To force use of the implementation in flash, e.g. for debugging:
// - Globally: Define DRIVERLIB_NOROM at project level
// - Per function: Use prefix "NOROM_" when calling the function
//
//*****************************************************************************
#if !defined(DOXYGEN)
    #define TimerConfigure                  NOROM_TimerConfigure
    #define TimerLevelControl               NOROM_TimerLevelControl
    #define TimerStallControl               NOROM_TimerStallControl
    #define TimerWaitOnTriggerControl       NOROM_TimerWaitOnTriggerControl
    #define TimerIntRegister                NOROM_TimerIntRegister
    #define TimerIntUnregister              NOROM_TimerIntUnregister
    #define TimerMatchUpdateMode            NOROM_TimerMatchUpdateMode
    #define TimerIntervalLoadMode           NOROM_TimerIntervalLoadMode
#endif

//*****************************************************************************
//
// Values that can be passed to TimerConfigure as the ui32Config parameter.
//
//*****************************************************************************
#define TIMER_CFG_ONE_SHOT        0x00000021  // Full-width one-shot timer
#define TIMER_CFG_ONE_SHOT_UP     0x00000031  // Full-width one-shot up-count timer
#define TIMER_CFG_PERIODIC        0x00000022  // Full-width periodic timer
#define TIMER_CFG_PERIODIC_UP     0x00000032  // Full-width periodic up-count timer
#define TIMER_CFG_SPLIT_PAIR      0x04000000  // Two half-width timers
#define TIMER_CFG_A_ONE_SHOT      0x00000021  // Timer A one-shot timer
#define TIMER_CFG_A_ONE_SHOT_UP   0x00000031  // Timer A one-shot up-count timer
#define TIMER_CFG_A_PERIODIC      0x00000022  // Timer A periodic timer
#define TIMER_CFG_A_PERIODIC_UP   0x00000032  // Timer A periodic up-count timer
#define TIMER_CFG_A_CAP_COUNT     0x00000003  // Timer A event counter
#define TIMER_CFG_A_CAP_COUNT_UP  0x00000013  // Timer A event up-counter
#define TIMER_CFG_A_CAP_TIME      0x00000007  // Timer A event timer
#define TIMER_CFG_A_CAP_TIME_UP   0x00000017  // Timer A event up-count timer
#define TIMER_CFG_A_PWM           0x0000000A  // Timer A PWM output
#define TIMER_CFG_B_ONE_SHOT      0x00002100  // Timer B one-shot timer
#define TIMER_CFG_B_ONE_SHOT_UP   0x00003100  // Timer B one-shot up-count timer
#define TIMER_CFG_B_PERIODIC      0x00002200  // Timer B periodic timer
#define TIMER_CFG_B_PERIODIC_UP   0x00003200  // Timer B periodic up-count timer
#define TIMER_CFG_B_CAP_COUNT     0x00000300  // Timer B event counter
#define TIMER_CFG_B_CAP_COUNT_UP  0x00001300  // Timer B event up-counter
#define TIMER_CFG_B_CAP_TIME      0x00000700  // Timer B event timer
#define TIMER_CFG_B_CAP_TIME_UP   0x00001700  // Timer B event up-count timer
#define TIMER_CFG_B_PWM           0x00000A00  // Timer B PWM output

//*****************************************************************************
//
// Values that can be passed to TimerIntEnable, TimerIntDisable, and
// TimerIntClear as the ui32IntFlags parameter, and returned from
// TimerIntStatus.
//
//*****************************************************************************
#define TIMER_TIMB_DMA            0x00002000  // TimerB DMA Done interrupt
#define TIMER_TIMB_MATCH          0x00000800  // TimerB match interrupt
#define TIMER_CAPB_EVENT          0x00000400  // CaptureB event interrupt
#define TIMER_CAPB_MATCH          0x00000200  // CaptureB match interrupt
#define TIMER_TIMB_TIMEOUT        0x00000100  // TimerB time out interrupt
#define TIMER_TIMA_DMA            0x00000020  // TimerA DMA Done interrupt
#define TIMER_TIMA_MATCH          0x00000010  // TimerA match interrupt
#define TIMER_CAPA_EVENT          0x00000004  // CaptureA event interrupt
#define TIMER_CAPA_MATCH          0x00000002  // CaptureA match interrupt
#define TIMER_TIMA_TIMEOUT        0x00000001  // TimerA time out interrupt

//*****************************************************************************
//
// Values that can be passed to TimerControlEvent as the ui32Event parameter.
//
//*****************************************************************************
#define TIMER_EVENT_POS_EDGE      0x00000000  // Count positive edges
#define TIMER_EVENT_NEG_EDGE      0x00000404  // Count negative edges
#define TIMER_EVENT_BOTH_EDGES    0x00000C0C  // Count both edges

//*****************************************************************************
//
// Values that can be passed to most of the timer APIs as the ui32Timer
// parameter.
//
//*****************************************************************************
#define TIMER_A                   0x000000FF  // Timer A
#define TIMER_B                   0x0000FF00  // Timer B
#define TIMER_BOTH                0x0000FFFF  // Timer Both

//*****************************************************************************
//
// Values that can be passed to GPTSynchronize as the ui32Timers parameter
//
//*****************************************************************************
#define TIMER_0A_SYNC             0x00000001  // Synchronize Timer 0A
#define TIMER_0B_SYNC             0x00000002  // Synchronize Timer 0B
#define TIMER_1A_SYNC             0x00000004  // Synchronize Timer 1A
#define TIMER_1B_SYNC             0x00000008  // Synchronize Timer 1B
#define TIMER_2A_SYNC             0x00000010  // Synchronize Timer 2A
#define TIMER_2B_SYNC             0x00000020  // Synchronize Timer 2B
#define TIMER_3A_SYNC             0x00000040  // Synchronize Timer 3A
#define TIMER_3B_SYNC             0x00000080  // Synchronize Timer 3B

//*****************************************************************************
//
// Values that can be passed to TimerMatchUpdateMode
//
//*****************************************************************************
#define TIMER_MATCHUPDATE_NEXTCYCLE  0x00000000 // Apply match register on next cycle
#define TIMER_MATCHUPDATE_TIMEOUT    0x00000001 // Apply match register on next timeout

//*****************************************************************************
//
// Values that can be passed to TimerIntervalLoad
//
//*****************************************************************************
#define TIMER_INTERVALLOAD_NEXTCYCLE  0x00000000 // Load TxR register with the value in the TxILR register on the next clock cycle
#define TIMER_INTERVALLOAD_TIMEOUT    0x00000001 // Load TxR register with the value in the TxILR register on next timeout

//*****************************************************************************
//
// API Functions and prototypes
//
//*****************************************************************************

#ifdef DRIVERLIB_DEBUG
//*****************************************************************************
//
//
//*****************************************************************************
static bool
TimerBaseValid(uint32_t ui32Base)
{
    return((ui32Base == GPT0_BASE) || (ui32Base == GPT1_BASE) ||
           (ui32Base == GPT2_BASE) || (ui32Base == GPT3_BASE));
}
#endif

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerEnable(uint32_t ui32Base, uint32_t ui32Timer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    //
    // Enable the timer(s) module.
    //
    HWREG(ui32Base + GPT_O_CTL) |= ui32Timer & (GPT_CTL_TAEN | GPT_CTL_TBEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerDisable(uint32_t ui32Base, uint32_t ui32Timer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    //
    // Disable the timer module.
    //
    HWREG(ui32Base + GPT_O_CTL) &= ~(ui32Timer &
                                     (GPT_CTL_TAEN | GPT_CTL_TBEN));
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerConfigure(uint32_t ui32Base, uint32_t ui32Config);

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerLevelControl(uint32_t ui32Base, uint32_t ui32Timer,
                              bool bInvert);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerEventControl(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Event)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    //
    // Set the event type.
    //
    ui32Timer &= GPT_CTL_TAEVENT_M | GPT_CTL_TBEVENT_M;
    HWREG(ui32Base + GPT_O_CTL) = ((HWREG(ui32Base + GPT_O_CTL) & ~ui32Timer) |
                                   (ui32Event & ui32Timer));
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerStallControl(uint32_t ui32Base, uint32_t ui32Timer,
                              bool bStall);

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerWaitOnTriggerControl(uint32_t ui32Base, uint32_t ui32Timer,
                                      bool bWait);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerPrescaleSet(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));
    ASSERT(ui32Value < 256);

    //
    // Set the timer A prescaler if requested.
    //
    if(ui32Timer & TIMER_A)
    {
        HWREG(ui32Base + GPT_O_TAPR) = ui32Value;
    }

    //
    // Set the timer B prescaler if requested.
    //
    if(ui32Timer & TIMER_B)
    {
        HWREG(ui32Base + GPT_O_TBPR) = ui32Value;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
TimerPrescaleGet(uint32_t ui32Base, uint32_t ui32Timer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    //
    // Return the appropriate prescale value.
    //
    return((ui32Timer == TIMER_A) ? HWREG(ui32Base + GPT_O_TAPR) :
           HWREG(ui32Base + GPT_O_TBPR));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerPrescaleMatchSet(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));
    ASSERT(ui32Value < 256);

    //
    // Set the timer A prescale match if requested.
    //
    if(ui32Timer & TIMER_A)
    {
        HWREG(ui32Base + GPT_O_TAPMR) = ui32Value;
    }

    //
    // Set the timer B prescale match if requested.
    //
    if(ui32Timer & TIMER_B)
    {
        HWREG(ui32Base + GPT_O_TBPMR) = ui32Value;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
TimerPrescaleMatchGet(uint32_t ui32Base, uint32_t ui32Timer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B));

    //
    // Return the appropriate prescale match value.
    //
    return((ui32Timer == TIMER_A) ? HWREG(ui32Base + GPT_O_TAPMR) :
           HWREG(ui32Base + GPT_O_TBPMR));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerLoadSet(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    //
    // Set the timer A load value if requested.
    //
    if(ui32Timer & TIMER_A)
    {
        HWREG(ui32Base + GPT_O_TAILR) = ui32Value;
    }

    //
    // Set the timer B load value if requested.
    //
    if(ui32Timer & TIMER_B)
    {
        HWREG(ui32Base + GPT_O_TBILR) = ui32Value;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
TimerLoadGet(uint32_t ui32Base, uint32_t ui32Timer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B));

    //
    // Return the appropriate load value.
    //
    return((ui32Timer == TIMER_A) ? HWREG(ui32Base + GPT_O_TAILR) :
           HWREG(ui32Base + GPT_O_TBILR));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
TimerValueGet(uint32_t ui32Base, uint32_t ui32Timer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B));

    //
    // Return the appropriate timer value.
    //
    return((ui32Timer == TIMER_A) ? HWREG(ui32Base + GPT_O_TAR) :
           HWREG(ui32Base + GPT_O_TBR));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerMatchSet(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    //
    // Set the timer A match value if requested.
    //
    if(ui32Timer & TIMER_A)
    {
        HWREG(ui32Base + GPT_O_TAMATCHR) = ui32Value;
    }

    //
    // Set the timer B match value if requested.
    //
    if(ui32Timer & TIMER_B)
    {
        HWREG(ui32Base + GPT_O_TBMATCHR) = ui32Value;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
TimerMatchGet(uint32_t ui32Base, uint32_t ui32Timer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B));

    //
    // Return the appropriate match value.
    //
    return((ui32Timer == TIMER_A) ? HWREG(ui32Base + GPT_O_TAMATCHR) :
           HWREG(ui32Base + GPT_O_TBMATCHR));
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerIntRegister(uint32_t ui32Base, uint32_t ui32Timer,
                             void (*pfnHandler)(void));

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerIntUnregister(uint32_t ui32Base, uint32_t ui32Timer);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerIntEnable(uint32_t ui32Base, uint32_t ui32IntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));

    //
    // Enable the specified interrupts.
    //
    HWREG(ui32Base + GPT_O_IMR) |= ui32IntFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerIntDisable(uint32_t ui32Base, uint32_t ui32IntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));

    //
    // Disable the specified interrupts.
    //
    HWREG(ui32Base + GPT_O_IMR) &= ~(ui32IntFlags);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
TimerIntStatus(uint32_t ui32Base, bool bMasked)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));

    //
    // Return either the interrupt status or the raw interrupt status as
    // requested.
    //
    return(bMasked ? HWREG(ui32Base + GPT_O_MIS) :
           HWREG(ui32Base + GPT_O_RIS));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerIntClear(uint32_t ui32Base, uint32_t ui32IntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ui32Base));

    //
    // Clear the requested interrupt sources.
    //
    HWREG(ui32Base + GPT_O_ICLR) = ui32IntFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerSynchronize(uint32_t ui32Base, uint32_t ui32Timers)
{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == GPT0_BASE);

    //
    // Synchronize the specified timers.
    //
    HWREG(ui32Base + GPT_O_SYNC) = ui32Timers;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerCcpCombineEnable(uint32_t ui32Base)
{
    // Check the arguments
    ASSERT(TimerBaseValid(ui32Base));

    // Set the bit
    HWREG(ui32Base + GPT_O_ANDCCP) |= GPT_ANDCCP_CCP_AND_EN;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
TimerCcpCombineDisable(uint32_t ui32Base)
{
    // Check the arguments
    ASSERT(TimerBaseValid(ui32Base));

    // Clear the bit
    HWREG(ui32Base + GPT_O_ANDCCP) &= ~(GPT_ANDCCP_CCP_AND_EN);
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerMatchUpdateMode(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Mode);

//*****************************************************************************
//
//
//*****************************************************************************
extern void TimerIntervalLoadMode(uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Mode);

//*****************************************************************************
//
// Support for DriverLib in ROM:
// Redirect to implementation in ROM when available.
//
//*****************************************************************************
#if !defined(DRIVERLIB_NOROM) && !defined(DOXYGEN)
    #include <driverlib/rom.h>
    #ifdef ROM_TimerConfigure
        #undef  TimerConfigure
        #define TimerConfigure                  ROM_TimerConfigure
    #endif
    #ifdef ROM_TimerLevelControl
        #undef  TimerLevelControl
        #define TimerLevelControl               ROM_TimerLevelControl
    #endif
    #ifdef ROM_TimerStallControl
        #undef  TimerStallControl
        #define TimerStallControl               ROM_TimerStallControl
    #endif
    #ifdef ROM_TimerWaitOnTriggerControl
        #undef  TimerWaitOnTriggerControl
        #define TimerWaitOnTriggerControl       ROM_TimerWaitOnTriggerControl
    #endif
    #ifdef ROM_TimerIntRegister
        #undef  TimerIntRegister
        #define TimerIntRegister                ROM_TimerIntRegister
    #endif
    #ifdef ROM_TimerIntUnregister
        #undef  TimerIntUnregister
        #define TimerIntUnregister              ROM_TimerIntUnregister
    #endif
    #ifdef ROM_TimerMatchUpdateMode
        #undef  TimerMatchUpdateMode
        #define TimerMatchUpdateMode            ROM_TimerMatchUpdateMode
    #endif
    #ifdef ROM_TimerIntervalLoadMode
        #undef  TimerIntervalLoadMode
        #define TimerIntervalLoadMode           ROM_TimerIntervalLoadMode
    #endif
#endif

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

#endif // __GPT_H__

//*****************************************************************************
//
//
//*****************************************************************************