2.114 Timer Counter for Control Applications (TCC)

Timer Counter for Control Applications (TCC) peripheral consists of counter, compare/capture channels and control logic. Waveform extensions are featured for motor control, ballast, LED, H-bridge, power converters, and other types of power control applications. They allow for low- and high-side output with optional dead-time insertion.

TCC provides below features:

• Up to four compare/capture channels (CC) with double buffering

• Waveform extensions:

• Configurable distribution of compare channels outputs across port pins

• Low- and high-side output with programmable dead-time insertion

• Waveform swap option with double buffer support

• Pattern generation with double buffer support

• Dithering support

• Fault protection for safe disabling of drivers

• Two non-recoverable fault sources

• Two recoverable fault sources

TIMER MODE

This section provides brief overview of the TC peripheral library in Timer mode

Using The Library

When the timer is enabled, it increments by one on every rising edge of the input clock, and generates an interrupt on a period match (period is controlled by CC0 in MPWM waveform mode). Timer mode is used for periodic interrupt generation. It provides both polling and callback methods to indicate period match has occurred. With polling, the application will need to continuously poll to check if the timer has expired. With callback, the registered callback function will be called when the timer expires. This means the application do not have to poll continuously.

COMPARE MODE

This section provides brief overview of the TC peripheral library in Compare mode.

Using The Library

When using the TC and the Compare/Capture Value registers (CCx) for compare operations, the counter value is continuously compared to the values in the CCx registers. The Channel x Compare Buffer (CCBUFx) registers provide double buffer capability. Output polarity can be reversed by inverting the output waveforms. In compare mode, overflow interrupt and compare match interrupts can be used to change the frequency or duty cycle of the waveform.

CAPTURE MODE

This section provides brief overview of the TC peripheral library in Capture mode.

Using The Library

Capture trigger can be provided by

• Input event line TC_EV

• Two event input line is available

• This provides different capture event actions:

• Pulse width in CC0 and period in CC1

• Pulse width in CC1 and period in CC0

• Pulse width

• Input event line TC_MCEIx

• Each capture channel has associated input capture event line

It provides both polling and callback methods to indicate capture event has occurred.

• With polling, the application will need to continuously poll to check if the capture event has occurred.

• With callback, the registered callback function will be called when the capture event occurs. This means the application do not have to poll continuously.

PWM MODE

This section provides brief overview of the TC peripheral library in PWM mode.

Using The Library

TCC is used to generate single slope or dual slope PWM signals with dead time. This can generate four complimentary PWM signals.

Below example shows to generate 3 phase PWM signals for motor control application. Duty cycle is updated in interrupt handler.

/* Duty cycle increment value */
\#define DUTY_INCREMENT (10U)

/* Save PWM period */
uint32_t period;

/* This function is called after TCC period event */
void TCC_PeriodEventHandler(uint32_t status, uintptr_t context)
{
    /* duty cycle values */
    static uint32_t duty1 = 0U;
    static uint32_t duty2 = 0U;
    static uint32_t duty3 = 0U;

    TCC0_PWM24bitDutySet(TCC0_CHANNEL1, duty1);
    TCC0_PWM24bitDutySet(TCC0_CHANNEL2, duty2);
    TCC0_PWM24bitDutySet(TCC0_CHANNEL3, duty3);

    /* Increment duty cycle values */
    duty1 += DUTY_INCREMENT;
    duty2 += DUTY_INCREMENT;
    duty3 += DUTY_INCREMENT;


    if (duty1 > period)
    {
            duty1 = 0U;
        if (duty2 > period)
            duty2 = 0U;
        if (duty3 > period)
            duty3 = 0U;
    }
}

int main ( void )
{
    /* Initialize all modules */
    SYS_Initialize ( NULL );

        /* Register callback function for period event */
    TCC0_PWMCallbackRegister(TCC_PeriodEventHandler, (uintptr_t)NULL);

    /* Read the period */
    period = TCC0_PWM24bitPeriodGet();

    /* Start PWM*/
    TCC0_PWMStart();

    while(1);
}