[timer.h] Timer

Functions
static void	TimerEnable (uint32_t ui32Base, uint32_t ui32Timer)
	Enables the timer(s). More...
static void	TimerDisable (uint32_t ui32Base, uint32_t ui32Timer)
	Disables the timer(s). More...
void	TimerConfigure (uint32_t ui32Base, uint32_t ui32Config)
	Configures the timer(s). More...
void	TimerLevelControl (uint32_t ui32Base, uint32_t ui32Timer, bool bInvert)
	Controls the output level. More...
static void	TimerEventControl (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Event)
	Controls the event type. More...
void	TimerStallControl (uint32_t ui32Base, uint32_t ui32Timer, bool bStall)
	Controls the stall handling. More...
void	TimerWaitOnTriggerControl (uint32_t ui32Base, uint32_t ui32Timer, bool bWait)
	Controls the wait on trigger handling. More...
static void	TimerPrescaleSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
	Set the timer prescale value. More...
static uint32_t	TimerPrescaleGet (uint32_t ui32Base, uint32_t ui32Timer)
	Get the timer prescale value. More...
static void	TimerPrescaleMatchSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
	Set the timer prescale match value. More...
static uint32_t	TimerPrescaleMatchGet (uint32_t ui32Base, uint32_t ui32Timer)
	Get the timer prescale match value. More...
static void	TimerLoadSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
	Sets the timer load value. More...
static uint32_t	TimerLoadGet (uint32_t ui32Base, uint32_t ui32Timer)
	Gets the timer load value. More...
static uint32_t	TimerValueGet (uint32_t ui32Base, uint32_t ui32Timer)
	Gets the current timer value. More...
static void	TimerMatchSet (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Value)
	Sets the timer match value. More...
static uint32_t	TimerMatchGet (uint32_t ui32Base, uint32_t ui32Timer)
	Gets the timer match value. More...
void	TimerIntRegister (uint32_t ui32Base, uint32_t ui32Timer, void(*pfnHandler)(void))
	Registers an interrupt handler for the timer interrupt in the dynamic interrupt table. More...
void	TimerIntUnregister (uint32_t ui32Base, uint32_t ui32Timer)
	Unregisters an interrupt handler for the timer interrupt in the dynamic interrupt table. More...
static void	TimerIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)
	Enables individual timer interrupt sources. More...
static void	TimerIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)
	Disables individual timer interrupt sources. More...
static uint32_t	TimerIntStatus (uint32_t ui32Base, bool bMasked)
	Gets the current interrupt status. More...
static void	TimerIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)
	Clears timer interrupt sources. More...
static void	TimerSynchronize (uint32_t ui32Base, uint32_t ui32Timers)
	Synchronizes the counters in a set of timers. More...
static void	TimerCcpCombineEnable (uint32_t ui32Base)
	Enables AND'ing of the CCP outputs from Timer A and Timer B. More...
static void	TimerCcpCombineDisable (uint32_t ui32Base)
	Disables AND'ing of the CCP outputs from Timer A and Timer B. More...
void	TimerMatchUpdateMode (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Mode)
	Sets the Match Register Update mode. More...
void	TimerIntervalLoadMode (uint32_t ui32Base, uint32_t ui32Timer, uint32_t ui32Mode)
	Sets the Interval Load mode. More...

Detailed Description

Introduction

The timer API provides a set of functions for using the general-purpose timer module.

The timer module contains four timer blocks with the following functional options:

• Operating modes:
  • 16-bit with 8-bit prescaler or 32-bit programmable one-shot timer.
  • 16-bit with 8-bit prescaler or 32-bit programmable periodic timer.
  • Two capture compare PWM pins (CCP) for each 32-bit timer.
  • 24-bit input-edge count or 24-bit time-capture modes.
  • 24-bit PWM mode with software-programmable output inversion of the PWM signal.
  • Count up or down.
• Daisy chaining of timer modules allows a single timer to initiate multiple timing events.
• Timer synchronization allows selected timers to start counting on the same clock cycle.
• User-enabled stalling when the System CPU asserts a CPU Halt flag during debug.
• Ability to determine the elapsed time between the assertion of the timer interrupt and entry into the interrupt service routine.

Each timer block provides two half-width timers/counters that can be configured to operate independently as timers or event counters or to operate as a combined full-width timer. The timers provide 16-bit half-width timers and a 32-bit full-width timer. For the purposes of this API, the two half-width timers provided by a timer block are referred to as TimerA and TimerB, and the full-width timer is referred to as TimerA.

When in half-width mode, the timer can also be configured for event capture or as a pulse width modulation (PWM) generator. When configured for event capture, the timer acts as a counter. It can be configured to count either the time between events or the events themselves. The type of event being counted can be configured as a positive edge, a negative edge, or both edges. When a timer is configured as a PWM generator, the input signal used to capture events becomes an output signal, and the timer drives an edge-aligned pulse onto that signal.

Control is also provided over interrupt sources and events. Interrupts can be generated to indicate that an event has been captured, or that a certain number of events have been captured. Interrupts can also be generated when the timer has counted down to 0 or when the timer matches a certain value.

Timer configuration is handled by TimerConfigure(), which performs the high level setup of the timer module; that is, it is used to set up full- or half-width modes, and to select between PWM, capture, and timer operations.

API

The API functions can be grouped like this:

Functions to perform timer control:

• TimerConfigure()
• TimerEnable()
• TimerDisable()
• TimerLevelControl()
• TimerWaitOnTriggerControl()
• TimerEventControl()
• TimerStallControl()
• TimerIntervalLoadMode()
• TimerMatchUpdateMode()
• TimerCcpCombineDisable()
• TimerCcpCombineEnable()

Functions to manage timer content:

• TimerLoadSet()
• TimerLoadGet()
• TimerPrescaleSet()
• TimerPrescaleGet()
• TimerMatchSet()
• TimerMatchGet()
• TimerPrescaleMatchSet()
• TimerPrescaleMatchGet()
• TimerValueGet()
• TimerSynchronize()

Functions to manage the interrupt handler for the timer interrupt:

• TimerIntRegister()
• TimerIntUnregister()

The individual interrupt sources within the timer module are managed with:

• TimerIntEnable()
• TimerIntDisable()
• TimerIntStatus()
• TimerIntClear()

Function Documentation

TimerCcpCombineDisable()

static void TimerCcpCombineDisable ( uint32_t  ui32Base )

inlinestatic

Disables AND'ing of the CCP outputs from Timer A and Timer B.

Parameters

ui32Base

is the base address of the timer module.

Returns

None

{
    // Check the arguments
    ASSERT(TimerBaseValid(ui32Base));

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

Here is the call graph for this function:

TimerCcpCombineEnable()

static void TimerCcpCombineEnable ( uint32_t  ui32Base )

inlinestatic

Enables AND'ing of the CCP outputs from Timer A and Timer B.

Parameters

ui32Base

is the base address of the timer module.

Returns

None

{
    // Check the arguments
    ASSERT(TimerBaseValid(ui32Base));

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

TimerConfigure()

void TimerConfigure	(	uint32_t	ui32Base,
		uint32_t	ui32Config
	)

Configures the timer(s).

This function configures the operating mode of the timer(s). The timer module is disabled before being configured and is left in the disabled state.

The timers are comprised of two 16-bit timers that can operate independently or be concatenated to form a 32-bit timer.

Note

If the timers are used independently the length of timer can be extended to 24 bit by use of an 8 bit prescale register set using TimerPrescaleSet().

When configuring for full-width timer ui32Config is set as one of the following values:

• TIMER_CFG_ONE_SHOT : Full-width one-shot timer.
• TIMER_CFG_ONE_SHOT_UP : Full-width one-shot timer that counts up instead of down.
• TIMER_CFG_PERIODIC : Full-width periodic timer.
• TIMER_CFG_PERIODIC_UP : Full-width periodic timer that counts up instead of down.

When configuring for a pair of half-width timers, each timer is separately configured. The timers are configured by setting ui32Config to the bitwise OR of one of each of the following three:

• Use half-width timers:
  • TIMER_CFG_SPLIT_PAIR
• Timer A:
  • TIMER_CFG_A_ONE_SHOT : Half-width one-shot timer
  • TIMER_CFG_A_ONE_SHOT_UP : Half-width one-shot timer that counts up instead of down.
  • TIMER_CFG_A_PERIODIC : Half-width periodic timer
  • TIMER_CFG_A_PERIODIC_UP : Half-width periodic timer that counts up instead of down.
  • TIMER_CFG_A_CAP_COUNT : Half-width edge count capture
  • TIMER_CFG_A_CAP_COUNT_UP : Half-width edge count capture that counts up instead of down.
  • TIMER_CFG_A_CAP_TIME : Half-width edge time capture
  • TIMER_CFG_A_CAP_TIME_UP : Half-width edge time capture that counts up instead of down.
  • TIMER_CFG_A_PWM : Half-width PWM output
• Timer B:
  • Same as Timer A but using TIMER_CFG_B_* instead.

Parameters

ui32Base	is the base address of the timer module.
ui32Config	is the configuration for the timer.

Returns

None

Referenced by TimerDisable().

{
    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Config == TIMER_CFG_ONE_SHOT) ||
           (ui32Config == TIMER_CFG_ONE_SHOT_UP) ||
           (ui32Config == TIMER_CFG_PERIODIC) ||
           (ui32Config == TIMER_CFG_PERIODIC_UP) ||
           ((ui32Config & 0xFF000000) == TIMER_CFG_SPLIT_PAIR));
    ASSERT(((ui32Config & 0xFF000000) != TIMER_CFG_SPLIT_PAIR) ||
           ((((ui32Config & 0x000000FF) == TIMER_CFG_A_ONE_SHOT) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_ONE_SHOT_UP) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_PERIODIC) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_PERIODIC_UP) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_CAP_COUNT) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_CAP_COUNT_UP) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_CAP_TIME) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_CAP_TIME_UP) ||
             ((ui32Config & 0x000000FF) == TIMER_CFG_A_PWM)) &&
            (((ui32Config & 0x0000FF00) == TIMER_CFG_B_ONE_SHOT) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_ONE_SHOT_UP) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_PERIODIC) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_PERIODIC_UP) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_CAP_COUNT) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_CAP_COUNT_UP) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_CAP_TIME) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_CAP_TIME_UP) ||
             ((ui32Config & 0x0000FF00) == TIMER_CFG_B_PWM))));

    // Disable the timers.
    HWREG(ui32Base + GPT_O_CTL) &= ~(GPT_CTL_TAEN | GPT_CTL_TBEN);

    // Set the global timer configuration.
    HWREG(ui32Base + GPT_O_CFG) = ui32Config >> 24;

    // Set the configuration of the A and B timers. Note that the B timer
    // configuration is ignored by the hardware in 32-bit modes.
    HWREG(ui32Base + GPT_O_TAMR) = (ui32Config & 0xFF) | GPT_TAMR_TAPWMIE;
    HWREG(ui32Base + GPT_O_TBMR) =
        ((ui32Config >> 8) & 0xFF) | GPT_TBMR_TBPWMIE;
}

TimerDisable()

static void TimerDisable ( uint32_t  ui32Base, uint32_t  ui32Timer  )

inlinestatic

Disables the timer(s).

This function disables operation of the timer module.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to disable. Must be one of: TIMER_A TIMER_B TIMER_BOTH

Returns

None

{
    // 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));
}

Here is the call graph for this function:

TimerEnable()

static void TimerEnable ( uint32_t  ui32Base, uint32_t  ui32Timer  )

inlinestatic

Enables the timer(s).

This function enables operation of the timer module. The timer must be configured before it is enabled.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to enable. Must be one of: TIMER_A TIMER_B TIMER_BOTH

Returns

None

{
    // 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);
}

TimerEventControl()

static void TimerEventControl ( uint32_t  ui32Base, uint32_t  ui32Timer, uint32_t  ui32Event  )

inlinestatic

Controls the event type.

This function configures the signal edge(s) that triggers the timer when in capture mode.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to be adjusted; must be one of: TIMER_A TIMER_B TIMER_BOTH
ui32Event	specifies the type of event; must be one of: TIMER_EVENT_POS_EDGE TIMER_EVENT_NEG_EDGE TIMER_EVENT_BOTH_EDGES

Returns

None

{
    // 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));
}

Here is the call graph for this function:

TimerIntClear()

static void TimerIntClear ( uint32_t  ui32Base, uint32_t  ui32IntFlags  )

inlinestatic

Clears timer interrupt sources.

The specified timer interrupt sources are cleared, so that they no longer assert. This function must be called in the interrupt handler to keep the interrupt from being triggered again immediately upon exit.

Note

Due to write buffers and synchronizers in the system it may take several clock cycles from a register write clearing an event in a module and until the event is actually cleared in the NVIC of the system CPU. It is recommended to clear the event source early in the interrupt service routine (ISR) to allow the event clear to propagate to the NVIC before returning from the ISR. At the same time, an early event clear allows new events of the same type to be pended instead of ignored if the event is cleared later in the ISR. It is the responsibility of the programmer to make sure that enough time has passed before returning from the ISR to avoid false re-triggering of the cleared event. A simple, although not necessarily optimal, way of clearing an event before returning from the ISR is:

1. Write to clear event (interrupt source). (buffered write)
2. Dummy read from the event source module. (making sure the write has propagated)
3. Wait two system CPU clock cycles (user code or two NOPs). (allowing cleared event to propagate through any synchronizers)

Parameters

ui32Base

is the base address of the timer module.

ui32IntFlags

is a bit mask of the interrupt sources to be cleared. The parameter must be the bitwise OR of any combination of the following: TIMER_CAPB_EVENT : Capture B event interrupt. TIMER_CAPB_MATCH : Capture B match interrupt. TIMER_TIMB_TIMEOUT : Timer B timeout interrupt. TIMER_CAPA_EVENT : Capture A event interrupt. TIMER_CAPA_MATCH : Capture A match interrupt. TIMER_TIMA_TIMEOUT : Timer A timeout interrupt.

Returns

None

{
    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));

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

TimerIntDisable()

static void TimerIntDisable ( uint32_t  ui32Base, uint32_t  ui32IntFlags  )

inlinestatic

Disables individual timer interrupt sources.

This function disables the indicated timer interrupt sources. Only the sources that are enabled can be reflected to the processor interrupt; disabled sources have no effect on the processor.

Parameters

ui32Base

is the base address of the timer module.

ui32IntFlags

is the bit mask of the interrupt sources to be disabled. The parameter must be the bitwise OR of any combination of the following: TIMER_CAPB_EVENT : Capture B event interrupt. TIMER_CAPB_MATCH : Capture B match interrupt. TIMER_TIMB_TIMEOUT : Timer B timeout interrupt. TIMER_CAPA_EVENT : Capture A event interrupt. TIMER_CAPA_MATCH : Capture A match interrupt. TIMER_TIMA_TIMEOUT : Timer A timeout interrupt.

Returns

None

{
    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));

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

TimerIntEnable()

static void TimerIntEnable ( uint32_t  ui32Base, uint32_t  ui32IntFlags  )

inlinestatic

Enables individual timer interrupt sources.

This function enables the indicated timer interrupt sources. Only the sources that are enabled can be reflected to the processor interrupt; disabled sources have no effect on the processor.

Parameters

ui32Base

is the base address of the timer module.

ui32IntFlags

is the bit mask of the interrupt sources to be enabled. The parameter must be the bitwise OR of any combination of the following: TIMER_CAPB_EVENT : Capture B event interrupt. TIMER_CAPB_MATCH : Capture B match interrupt. TIMER_TIMB_TIMEOUT : Timer B timeout interrupt. TIMER_CAPA_EVENT : Capture A event interrupt. TIMER_CAPA_MATCH : Capture A match interrupt. TIMER_TIMA_TIMEOUT : Timer A timeout interrupt.

Returns

None

{
    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));

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

TimerIntervalLoadMode()

void TimerIntervalLoadMode	(	uint32_t	ui32Base,
		uint32_t	ui32Timer,
		uint32_t	ui32Mode
	)

Sets the Interval Load mode.

This function controls when the Timer Register and Prescale Snap-shot (if used) are updated.

Timer Register (TAR/TBR) is updated when Interval Load Register (TAILR/TBILR) is written and the Prescale Snap-shot (TAPS/TBPS) is updated when Prescale Register (TAPR/TBPR) is written depending on the mode of operation.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to configure; must be one of: TIMER_A TIMER_B TIMER_BOTH
ui32Mode	sets the mode: TIMER_INTERVALLOAD_NEXTCYCLE : Update Timer Register and Prescale Snap-shot on next clock cycle after writing Interval Load Register or Prescale Register, respectively. TIMER_INTERVALLOAD_TIMEOUT : Update Timer Register and Prescale Snap-shot on next timeout after writing Interval Load Register or Prescale Register, respectively.

Returns

None

Referenced by TimerCcpCombineDisable().

{
    // Check the arguments
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) || (ui32Timer == TIMER_BOTH));
    ASSERT((ui32Mode == TIMER_INTERVALLOAD_NEXTCYCLE) || (ui32Mode == TIMER_INTERVALLOAD_TIMEOUT));

    // Set mode for timer A
    if(ui32Timer & TIMER_A)
    {
        if(ui32Mode == TIMER_INTERVALLOAD_NEXTCYCLE)
        {
            HWREG(ui32Base + GPT_O_TAMR) &= ~(GPT_TAMR_TAILD);
        }
        else
        {
            HWREG(ui32Base + GPT_O_TAMR) |= GPT_TAMR_TAILD;
        }
    }

    // Set mode for timer B
    if(ui32Timer & TIMER_B)
    {
        if(ui32Mode == TIMER_INTERVALLOAD_NEXTCYCLE)
        {
            HWREG(ui32Base + GPT_O_TBMR) &= ~(GPT_TBMR_TBILD);
        }
        else
        {
            HWREG(ui32Base + GPT_O_TBMR) |= GPT_TBMR_TBILD;
        }
    }
}

TimerIntRegister()

void TimerIntRegister	(	uint32_t	ui32Base,
		uint32_t	ui32Timer,
		void(*)(void)	pfnHandler
	)

Registers an interrupt handler for the timer interrupt in the dynamic interrupt table.

Note

Only use this function if you want to use the dynamic vector table (in SRAM)!

This function registers a function as the interrupt handler for a specific interrupt and enables the corresponding interrupt in the interrupt controller.

Specific timer interrupts must be enabled via TimerIntEnable(). It is the interrupt handler's responsibility to clear the interrupt source via TimerIntClear().

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s); must be one of: TIMER_A TIMER_B TIMER_BOTH
pfnHandler	is a pointer to the function to be called when the timer interrupt occurs.

Returns

None

See also

IntRegister() for important information about registering interrupt handlers.

Referenced by TimerMatchGet().

{
    uint32_t ui32Int;

    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    // Get the interrupt number for this timer module.
    ui32Int = TimerIntNumberGet(ui32Base);

    // Register an interrupt handler for timer A if requested.
    if(ui32Timer & TIMER_A)
    {
        // Register the interrupt handler.
        IntRegister(ui32Int, pfnHandler);

        // Enable the interrupt.
        IntEnable(ui32Int);
    }

    // Register an interrupt handler for timer B if requested.
    if(ui32Timer & TIMER_B)
    {
        // Register the interrupt handler.
        IntRegister(ui32Int + 1, pfnHandler);

        // Enable the interrupt.
        IntEnable(ui32Int + 1);
    }
}

Here is the call graph for this function:

TimerIntStatus()

static uint32_t TimerIntStatus ( uint32_t  ui32Base, bool  bMasked  )

inlinestatic

Gets the current interrupt status.

This function returns the interrupt status for the timer module. Either the raw interrupt status or the status of interrupts that are allowed to reflect to the processor can be returned.

Parameters

ui32Base	is the base address of the timer module.
bMasked	selects either raw or masked interrupt status: true : Masked interrupt. false : Raw interrupt.

Returns

The current interrupt status, enumerated as a bit field of values:

• TIMER_CAPB_EVENT : Capture B event interrupt.
• TIMER_CAPB_MATCH : Capture B match interrupt.
• TIMER_TIMB_TIMEOUT : Timer B timeout interrupt.
• TIMER_CAPA_EVENT : Capture A event interrupt.
• TIMER_CAPA_MATCH : Capture A match interrupt.
• TIMER_TIMA_TIMEOUT : Timer A timeout interrupt.

{
    // 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));
}

TimerIntUnregister()

void TimerIntUnregister	(	uint32_t	ui32Base,
		uint32_t	ui32Timer
	)

Unregisters an interrupt handler for the timer interrupt in the dynamic interrupt table.

This function unregisters the handler to be called when a timer interrupt occurs. This function also masks off the interrupt in the interrupt controller so that the interrupt handler is no longer called.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s); must be one of: TIMER_A TIMER_B TIMER_BOTH

Returns

None

See also

IntRegister() for important information about registering interrupt handlers.

Referenced by TimerMatchGet().

{
    uint32_t ui32Int;

    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    // Get the interrupt number for this timer module.
    ui32Int = TimerIntNumberGet(ui32Base);

    // Unregister the interrupt handler for timer A if requested.
    if(ui32Timer & TIMER_A)
    {
        // Disable the interrupt.
        IntDisable(ui32Int);

        // Unregister the interrupt handler.
        IntUnregister(ui32Int);
    }

    // Unregister the interrupt handler for timer B if requested.
    if(ui32Timer & TIMER_B)
    {
        // Disable the interrupt.
        IntDisable(ui32Int + 1);

        // Unregister the interrupt handler.
        IntUnregister(ui32Int + 1);
    }
}

Here is the call graph for this function:

TimerLevelControl()

void TimerLevelControl	(	uint32_t	ui32Base,
		uint32_t	ui32Timer,
		bool	bInvert
	)

Controls the output level.

This function configures the PWM output level for the specified timer.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to adjust. Must be one of: TIMER_A TIMER_B TIMER_BOTH
bInvert	specifies the output level. true : Timer's output is active low. false : Timer's output is active high.

Returns

None

Referenced by TimerDisable().

{
    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    // Set the output levels as requested.
    ui32Timer &= GPT_CTL_TAPWML | GPT_CTL_TBPWML;
    HWREG(ui32Base + GPT_O_CTL) = (bInvert ?
                                   (HWREG(ui32Base + GPT_O_CTL) | ui32Timer) :
                                   (HWREG(ui32Base + GPT_O_CTL) &
                                   ~(ui32Timer)));
}

TimerLoadGet()

static uint32_t TimerLoadGet ( uint32_t  ui32Base, uint32_t  ui32Timer  )

inlinestatic

Gets the timer load value.

This function gets the currently programmed interval load value for the specified timer.

Note

This function can be used for both full- and half-width modes of 16/32-bit timers.

Only TIMER_A should be used when the timer is configured for full-width operation.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer; must be one of: TIMER_A TIMER_B

Returns

Returns the load value for the timer

{
    // 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));
}

TimerLoadSet()

static void TimerLoadSet ( uint32_t  ui32Base, uint32_t  ui32Timer, uint32_t  ui32Value  )

inlinestatic

Sets the timer load value.

This function configures the timer load value; if the timer is running then the value is immediately loaded into the timer.

Note

This function can be used for both full- and half-width modes of 16/32-bit timers.

Only TIMER_A should be used when the timer is configured for full-width operation.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to adjust; must be one of: TIMER_A TIMER_B TIMER_BOTH
ui32Value	is the load value.

Returns

None

{
    // 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;
    }
}

TimerMatchGet()

static uint32_t TimerMatchGet ( uint32_t  ui32Base, uint32_t  ui32Timer  )

inlinestatic

Gets the timer match value.

This function gets the match value for the specified timer.

Note

This function can be used for both full- and half-width modes of 16/32-bit timers.

Only TIMER_A should be used when the timer is configured for full-width operation.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer; must be one of: TIMER_A TIMER_B TIMER_BOTH

Returns

Returns the match value for the timer

{
    // 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));
}

Here is the call graph for this function:

TimerMatchSet()

static void TimerMatchSet ( uint32_t  ui32Base, uint32_t  ui32Timer, uint32_t  ui32Value  )

inlinestatic

Sets the timer match value.

This function configures the match value for a timer. This value is used in capture count mode to determine when to interrupt the processor and in PWM mode to determine the duty cycle of the output signal. Match interrupts can also be generated in periodic and one-shot modes when the value of the counter matches this register.

Note

This function can be used for both full- and half-width modes of 16/32-bit timers.

Only TIMER_A should be used when the timer is configured for full-width operation.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to adjust; must be one of: TIMER_A TIMER_B TIMER_BOTH
ui32Value	is the match value.

Returns

None

{
    // 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;
    }
}

TimerMatchUpdateMode()

void TimerMatchUpdateMode	(	uint32_t	ui32Base,
		uint32_t	ui32Timer,
		uint32_t	ui32Mode
	)

Sets the Match Register Update mode.

This function controls when the Match Register value and Prescale Register value are applied after writing these registers while a timer is enabled.

Note

If the timer is disabled when setting the update mode the Match Register and Prescale Register values are applied immediately when enabling the timer.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to configure; must be one of: TIMER_A TIMER_B TIMER_BOTH
ui32Mode	sets the mode: TIMER_MATCHUPDATE_NEXTCYCLE : Apply Match Register and Prescale Register on next clock cycle after writing any of these registers. TIMER_MATCHUPDATE_TIMEOUT : Apply Match Register and Prescale Register on next timeout after writing any of these registers.

Returns

None

Referenced by TimerCcpCombineDisable().

{
    // Check the arguments
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) || (ui32Timer == TIMER_BOTH));
    ASSERT((ui32Mode == TIMER_MATCHUPDATE_NEXTCYCLE) || (ui32Mode == TIMER_MATCHUPDATE_TIMEOUT));

    // Set mode for timer A
    if(ui32Timer & TIMER_A)
    {
        if(ui32Mode == TIMER_MATCHUPDATE_NEXTCYCLE)
        {
            HWREG(ui32Base + GPT_O_TAMR) &= ~(GPT_TAMR_TAMRSU);
        }
        else
        {
            HWREG(ui32Base + GPT_O_TAMR) |= GPT_TAMR_TAMRSU;
        }
    }

    // Set mode for timer B
    if(ui32Timer & TIMER_B)
    {
        if(ui32Mode == TIMER_MATCHUPDATE_NEXTCYCLE)
        {
            HWREG(ui32Base + GPT_O_TBMR) &= ~(GPT_TBMR_TBMRSU);
        }
        else
        {
            HWREG(ui32Base + GPT_O_TBMR) |= GPT_TBMR_TBMRSU;
        }
    }
}

TimerPrescaleGet()

static uint32_t TimerPrescaleGet ( uint32_t  ui32Base, uint32_t  ui32Timer  )

inlinestatic

Get the timer prescale value.

This function gets the value of the timer clock prescaler. The prescaler is only operational when in half-width mode and is used to extend the range of the half-width timer modes.

When in one-shot or periodic down count modes, ui32Value defines the prescaler for the timer counter. When acting as a true prescaler, the prescaler counts down to 0 before the value in timer registers are incremented.

In all other individual/split modes, ui32Value is a linear extension of the upper range of the timer counter, holding bits 23:16 in the 16-bit modes of the 16/32-bit timer.

Note

Because the prescaler counts down to 0 the timer division ratio equals ui32Value + 1. E.g. a prescale value of 15 divides the timer rate by 16.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer; must be one of: TIMER_A TIMER_B

Returns

Returns the value of the timer prescaler.

{
    // 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));
}

TimerPrescaleMatchGet()

static uint32_t TimerPrescaleMatchGet ( uint32_t  ui32Base, uint32_t  ui32Timer  )

inlinestatic

Get the timer prescale match value.

This function gets the value of the input clock prescaler match value. When in a half-width mode that uses the counter match and prescaler, the prescale match effectively extends the range of the match. The prescaler provides the least significant bits when counting down in periodic and one-shot modes; in all other modes, the prescaler provides the most significant bits.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer; must be one of: TIMER_A TIMER_B

Returns

Returns the value of the timer prescale match.

{
    // 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));
}

TimerPrescaleMatchSet()

static void TimerPrescaleMatchSet ( uint32_t  ui32Base, uint32_t  ui32Timer, uint32_t  ui32Value  )

inlinestatic

Set the timer prescale match value.

This function configures the value of the input clock prescaler match value. When in a half-width mode that uses the counter match and the prescaler, the prescale match effectively extends the range of the match. The prescaler provides the least significant bits when counting down in periodic and one-shot modes; in all other modes, the prescaler provides the most significant bits.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to adjust; must be one of: TIMER_A TIMER_B TIMER_BOTH
ui32Value	is the timer prescale match value which must be between 0 and 255 (both included).

Returns

None

{
    // 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;
    }
}

TimerPrescaleSet()

static void TimerPrescaleSet ( uint32_t  ui32Base, uint32_t  ui32Timer, uint32_t  ui32Value  )

inlinestatic

Set the timer prescale value.

This function configures the value of the timer clock prescaler. The prescaler is only operational when in half-width mode and is used to extend the range of the half-width timer modes.

When in one-shot or periodic down count modes, ui32Value defines the prescaler for the timer counter. When acting as a true prescaler, the prescaler counts down to 0 before the value in timer registers are incremented.

In all other individual/split modes, ui32Value is a linear extension of the upper range of the timer counter, holding bits 23:16 in the 16-bit modes of the 16/32-bit timer.

Note

Because the prescaler counts down to 0 the timer division ratio equals ui32Value + 1. E.g. a prescale value of 15 divides the timer rate by 16.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to adjust; must be one of: TIMER_A TIMER_B TIMER_BOTH
ui32Value	is the timer prescale value which must be between 0 and 255 (both included). 0 : Timer division ratio = 1 (disable prescaling). 1 : Timer division ratio = 2. ... 255 : Timer division ratio = 256.

Returns

None

{
    // 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;
    }
}

TimerStallControl()

void TimerStallControl	(	uint32_t	ui32Base,
		uint32_t	ui32Timer,
		bool	bStall
	)

Controls the stall handling.

This function controls the stall response for the specified timer. If the bStall parameter is true, then the timer stops counting if the processor enters debug mode; otherwise the timer keeps running while in debug mode.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to be adjusted; must be one of: TIMER_A TIMER_B TIMER_BOTH
bStall	specifies the response to a stall signal. true : Timer stops counting if the processor enters debug mode. false : Timer keeps running if the processor enters debug mode.

Returns

None

Referenced by TimerEventControl().

{
    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    // Set the stall mode.
    ui32Timer &= GPT_CTL_TASTALL | GPT_CTL_TBSTALL;
    HWREG(ui32Base + GPT_O_CTL) = (bStall ?
                                   (HWREG(ui32Base + GPT_O_CTL) | ui32Timer) :
                                   (HWREG(ui32Base + GPT_O_CTL) & ~(ui32Timer)));
}

TimerSynchronize()

static void TimerSynchronize ( uint32_t  ui32Base, uint32_t  ui32Timers  )

inlinestatic

Synchronizes the counters in a set of timers.

This function synchronizes the counters in a specified set of timers. When a timer is running in half-width mode, each half can be included or excluded in the synchronization event. When a timer is running in full-width mode, only the A timer can be synchronized (specifying the B timer has no effect).

Parameters

ui32Base	is the base address of the timer module. This parameter must be the base address of Timer0 (in other words, GPT0_BASE).
ui32Timers	is the set of timers to synchronize. The parameter is the bitwise OR of any of the following: TIMER_0A_SYNC TIMER_0B_SYNC TIMER_1A_SYNC TIMER_1B_SYNC TIMER_2A_SYNC TIMER_2B_SYNC TIMER_3A_SYNC TIMER_3B_SYNC

Returns

None

{
    // Check the arguments.
    ASSERT(ui32Base == GPT0_BASE);

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

TimerValueGet()

static uint32_t TimerValueGet ( uint32_t  ui32Base, uint32_t  ui32Timer  )

inlinestatic

Gets the current timer value.

This function reads the current value of the specified timer.

Note

This function can be used for both full- and half-width modes of 16/32-bit timers.

Only TIMER_A should be used when the timer is configured for full-width operation.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer; must be one of: TIMER_A TIMER_B

Returns

Returns the current value of the timer.

{
    // 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));
}

TimerWaitOnTriggerControl()

void TimerWaitOnTriggerControl	(	uint32_t	ui32Base,
		uint32_t	ui32Timer,
		bool	bWait
	)

Controls the wait on trigger handling.

This function controls whether or not a timer waits for a trigger input to start counting. When enabled, the previous timer in the trigger chain must count to its timeout in order for this timer to start counting. Refer to the part's data sheet for a description of the trigger chain.

Note

This function should not be used for Timer 0A or Wide Timer 0A.

Parameters

ui32Base	is the base address of the timer module.
ui32Timer	specifies the timer(s) to be adjusted; must be one of: TIMER_A TIMER_B TIMER_BOTH
bWait	specifies if the timer should wait for a trigger input. true : Wait for trigger. false : Do not wait for trigger.

Returns

None

Referenced by TimerEventControl().

{
    // Check the arguments.
    ASSERT(TimerBaseValid(ui32Base));
    ASSERT((ui32Timer == TIMER_A) || (ui32Timer == TIMER_B) ||
           (ui32Timer == TIMER_BOTH));

    // Set the wait on trigger mode for timer A.
    if(ui32Timer & TIMER_A)
    {
        if(bWait)
        {
            HWREG(ui32Base + GPT_O_TAMR) |= GPT_TAMR_TAWOT;
        }
        else
        {
            HWREG(ui32Base + GPT_O_TAMR) &= ~(GPT_TAMR_TAWOT);
        }
    }

    // Set the wait on trigger mode for timer B.
    if(ui32Timer & TIMER_B)
    {
        if(bWait)
        {
            HWREG(ui32Base + GPT_O_TBMR) |= GPT_TBMR_TBWOT;
        }
        else
        {
            HWREG(ui32Base + GPT_O_TBMR) &= ~(GPT_TBMR_TBWOT);
        }
    }
}

Macro Definition Documentation

TIMER_0A_SYNC

#define TIMER_0A_SYNC   0x00000001

TIMER_0B_SYNC

#define TIMER_0B_SYNC   0x00000002

TIMER_1A_SYNC

#define TIMER_1A_SYNC   0x00000004

TIMER_1B_SYNC

#define TIMER_1B_SYNC   0x00000008

TIMER_2A_SYNC

#define TIMER_2A_SYNC   0x00000010

TIMER_2B_SYNC

#define TIMER_2B_SYNC   0x00000020

TIMER_3A_SYNC

#define TIMER_3A_SYNC   0x00000040

TIMER_3B_SYNC

#define TIMER_3B_SYNC   0x00000080

TIMER_A

#define TIMER_A   0x000000FF

Referenced by TimerDisable(), TimerEnable(), TimerEventControl(), TimerIntervalLoadMode(), TimerIntRegister(), TimerIntUnregister(), TimerLevelControl(), TimerLoadGet(), TimerLoadSet(), TimerMatchGet(), TimerMatchSet(), TimerMatchUpdateMode(), TimerPrescaleGet(), TimerPrescaleMatchGet(), TimerPrescaleMatchSet(), TimerPrescaleSet(), TimerStallControl(), TimerValueGet(), and TimerWaitOnTriggerControl().

TIMER_B

#define TIMER_B   0x0000FF00

Referenced by TimerDisable(), TimerEnable(), TimerEventControl(), TimerIntervalLoadMode(), TimerIntRegister(), TimerIntUnregister(), TimerLevelControl(), TimerLoadGet(), TimerLoadSet(), TimerMatchGet(), TimerMatchSet(), TimerMatchUpdateMode(), TimerPrescaleGet(), TimerPrescaleMatchGet(), TimerPrescaleMatchSet(), TimerPrescaleSet(), TimerStallControl(), TimerValueGet(), and TimerWaitOnTriggerControl().

TIMER_BOTH

#define TIMER_BOTH   0x0000FFFF

Referenced by TimerDisable(), TimerEnable(), TimerEventControl(), TimerIntervalLoadMode(), TimerIntRegister(), TimerIntUnregister(), TimerLevelControl(), TimerLoadSet(), TimerMatchSet(), TimerMatchUpdateMode(), TimerPrescaleGet(), TimerPrescaleMatchSet(), TimerPrescaleSet(), TimerStallControl(), and TimerWaitOnTriggerControl().

TIMER_CAPA_EVENT

#define TIMER_CAPA_EVENT   0x00000004

TIMER_CAPA_MATCH

#define TIMER_CAPA_MATCH   0x00000002

TIMER_CAPB_EVENT

#define TIMER_CAPB_EVENT   0x00000400

TIMER_CAPB_MATCH

#define TIMER_CAPB_MATCH   0x00000200

TIMER_CFG_A_CAP_COUNT

#define TIMER_CFG_A_CAP_COUNT   0x00000003

Referenced by TimerConfigure().

TIMER_CFG_A_CAP_COUNT_UP

#define TIMER_CFG_A_CAP_COUNT_UP   0x00000013

Referenced by TimerConfigure().

TIMER_CFG_A_CAP_TIME

#define TIMER_CFG_A_CAP_TIME   0x00000007

Referenced by TimerConfigure().

TIMER_CFG_A_CAP_TIME_UP

#define TIMER_CFG_A_CAP_TIME_UP   0x00000017

Referenced by TimerConfigure().

TIMER_CFG_A_ONE_SHOT

#define TIMER_CFG_A_ONE_SHOT   0x00000021

Referenced by TimerConfigure().

TIMER_CFG_A_ONE_SHOT_UP

#define TIMER_CFG_A_ONE_SHOT_UP   0x00000031

Referenced by TimerConfigure().

TIMER_CFG_A_PERIODIC

#define TIMER_CFG_A_PERIODIC   0x00000022

Referenced by TimerConfigure().

TIMER_CFG_A_PERIODIC_UP

#define TIMER_CFG_A_PERIODIC_UP   0x00000032

Referenced by TimerConfigure().

TIMER_CFG_A_PWM

#define TIMER_CFG_A_PWM   0x0000000A

Referenced by TimerConfigure().

TIMER_CFG_B_CAP_COUNT

#define TIMER_CFG_B_CAP_COUNT   0x00000300

Referenced by TimerConfigure().

TIMER_CFG_B_CAP_COUNT_UP

#define TIMER_CFG_B_CAP_COUNT_UP   0x00001300

Referenced by TimerConfigure().

TIMER_CFG_B_CAP_TIME

#define TIMER_CFG_B_CAP_TIME   0x00000700

Referenced by TimerConfigure().

TIMER_CFG_B_CAP_TIME_UP

#define TIMER_CFG_B_CAP_TIME_UP   0x00001700

Referenced by TimerConfigure().

TIMER_CFG_B_ONE_SHOT

#define TIMER_CFG_B_ONE_SHOT   0x00002100

Referenced by TimerConfigure().

TIMER_CFG_B_ONE_SHOT_UP

#define TIMER_CFG_B_ONE_SHOT_UP   0x00003100

Referenced by TimerConfigure().

TIMER_CFG_B_PERIODIC

#define TIMER_CFG_B_PERIODIC   0x00002200

Referenced by TimerConfigure().

TIMER_CFG_B_PERIODIC_UP

#define TIMER_CFG_B_PERIODIC_UP   0x00003200

Referenced by TimerConfigure().

TIMER_CFG_B_PWM

#define TIMER_CFG_B_PWM   0x00000A00

Referenced by TimerConfigure().

TIMER_CFG_ONE_SHOT

#define TIMER_CFG_ONE_SHOT   0x00000021

Referenced by TimerConfigure().

TIMER_CFG_ONE_SHOT_UP

#define TIMER_CFG_ONE_SHOT_UP   0x00000031

Referenced by TimerConfigure().

TIMER_CFG_PERIODIC

#define TIMER_CFG_PERIODIC   0x00000022

Referenced by TimerConfigure().

TIMER_CFG_PERIODIC_UP

#define TIMER_CFG_PERIODIC_UP   0x00000032

Referenced by TimerConfigure().

TIMER_CFG_SPLIT_PAIR

#define TIMER_CFG_SPLIT_PAIR   0x04000000

Referenced by TimerConfigure().

TIMER_EVENT_BOTH_EDGES

#define TIMER_EVENT_BOTH_EDGES   0x00000C0C

TIMER_EVENT_NEG_EDGE

#define TIMER_EVENT_NEG_EDGE   0x00000404

TIMER_EVENT_POS_EDGE

#define TIMER_EVENT_POS_EDGE   0x00000000

TIMER_INTERVALLOAD_NEXTCYCLE

#define TIMER_INTERVALLOAD_NEXTCYCLE   0x00000000

Referenced by TimerIntervalLoadMode().

TIMER_INTERVALLOAD_TIMEOUT

#define TIMER_INTERVALLOAD_TIMEOUT   0x00000001

Referenced by TimerIntervalLoadMode().

TIMER_MATCHUPDATE_NEXTCYCLE

#define TIMER_MATCHUPDATE_NEXTCYCLE   0x00000000

Referenced by TimerMatchUpdateMode().

TIMER_MATCHUPDATE_TIMEOUT

#define TIMER_MATCHUPDATE_TIMEOUT   0x00000001

Referenced by TimerMatchUpdateMode().

TIMER_TIMA_DMA

#define TIMER_TIMA_DMA   0x00000020

TIMER_TIMA_MATCH

#define TIMER_TIMA_MATCH   0x00000010

TIMER_TIMA_TIMEOUT

#define TIMER_TIMA_TIMEOUT   0x00000001

TIMER_TIMB_DMA

#define TIMER_TIMB_DMA   0x00002000

TIMER_TIMB_MATCH

#define TIMER_TIMB_MATCH   0x00000800

TIMER_TIMB_TIMEOUT

#define TIMER_TIMB_TIMEOUT   0x00000100