Tinkering TI MSP430F5529

Free-Running Timer – TA0

A free-running timer is a timer that is left to run on its own. It has limited uses in regular life as it is based on polling. Such timers are useful for generating random numbers, timer-based delay functions, etc. Any timer of a MSP430 microcontroller can be used for making such a timer.

Code Example

#include "driverlib.h"
#include "delay.h"

void clock_init(void);
void GPIO_init(void);
void timer_T0A5_init(void);

void main(void)
{
    WDT_A_hold(WDT_A_BASE);

    clock_init();
    GPIO_init();
    timer_T0A5_init();

    while(1)
    {
        if(Timer_A_getCounterValue(__MSP430_BASEADDRESS_T0A5__) >= 32768)
        {
            GPIO_setOutputLowOnPin(GPIO_PORT_P1,
                                   GPIO_PIN0);

            GPIO_setOutputHighOnPin(GPIO_PORT_P4,
                                    GPIO_PIN7);
        }
        else
        {
            GPIO_setOutputHighOnPin(GPIO_PORT_P1,
                                    GPIO_PIN0);

            GPIO_setOutputLowOnPin(GPIO_PORT_P4,
                                   GPIO_PIN7);
        }
    };
}

void clock_init(void)
{
    PMM_setVCore(PMM_CORE_LEVEL_2);

    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5,
                                               (GPIO_PIN4 | GPIO_PIN2));

    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P5,
                                                (GPIO_PIN5 | GPIO_PIN3));

    UCS_setExternalClockSource(XT1_FREQ,
                               XT2_FREQ);

    UCS_turnOnXT2(UCS_XT2_DRIVE_4MHZ_8MHZ);

    UCS_turnOnLFXT1(UCS_XT1_DRIVE_0,
                    UCS_XCAP_3);

    UCS_initClockSignal(UCS_MCLK,
                        UCS_XT2CLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);

    UCS_initClockSignal(UCS_SMCLK,
                        UCS_REFOCLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);

    UCS_initClockSignal(UCS_ACLK,
                        UCS_XT1CLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);
}

void GPIO_init(void)
{
    GPIO_setAsOutputPin(GPIO_PORT_P1,
                        GPIO_PIN0);

    GPIO_setDriveStrength(GPIO_PORT_P1,
                          GPIO_PIN0,
                          GPIO_FULL_OUTPUT_DRIVE_STRENGTH);

    GPIO_setAsOutputPin(GPIO_PORT_P4,
                        GPIO_PIN7);

    GPIO_setDriveStrength(GPIO_PORT_P4,
                          GPIO_PIN7,
                          GPIO_FULL_OUTPUT_DRIVE_STRENGTH);
}

void timer_T0A5_init(void)
{
    Timer_A_initContinuousModeParam ContinuousModeParam =
    {
         TIMER_A_CLOCKSOURCE_SMCLK,
         TIMER_A_CLOCKSOURCE_DIVIDER_1,
         TIMER_A_TAIE_INTERRUPT_DISABLE,
         TIMER_A_DO_CLEAR,
         false
    };

    Timer_A_stop(__MSP430_BASEADDRESS_T0A5__);

    Timer_A_clearTimerInterrupt(__MSP430_BASEADDRESS_T0A5__);

    Timer_A_initContinuousMode(__MSP430_BASEADDRESS_T0A5__,
                               &ContinuousModeParam);

    Timer_A_startCounter(__MSP430_BASEADDRESS_T0A5__,
                         TIMER_A_CONTINUOUS_MODE);
}

Hardware Setup

Explanation

On-board LED GPIOs are setup as outputs. It is same as with other examples. The interesting part for us here is the timer setup.

void timer_T0A5_init(void)
{
    Timer_A_initContinuousModeParam ContinuousModeParam =
    {
         TIMER_A_CLOCKSOURCE_SMCLK,
         TIMER_A_CLOCKSOURCE_DIVIDER_1,
         TIMER_A_TAIE_INTERRUPT_DISABLE,
         TIMER_A_DO_CLEAR,
         false
    };
    Timer_A_stop(__MSP430_BASEADDRESS_T0A5__);
    Timer_A_clearTimerInterrupt(__MSP430_BASEADDRESS_T0A5__);
    Timer_A_initContinuousMode(__MSP430_BASEADDRESS_T0A5__, &ContinuousModeParam);
    Timer_A_startCounter(__MSP430_BASEADDRESS_T0A5__, TIMER_A_CONTINUOUS_MODE);
}

For demoing free-running timer, i.e. timer without interrupt or CC channels, TA0 is used. Note it is driven by SMCLK. SMCLK’s clock source is the internal 32 kHz REFOCLK oscillator.

UCS_initClockSignal(UCS_SMCLK, UCS_REFOCLK_SELECT, UCS_CLOCK_DIVIDER_1);

No divider is used and so we can roughly expect 32000 ticks per second. We would also want to clear past settings and disable timer interrupt since it is a no-interrupt timer example. Initially the timer is halted because we want to start it right after setting the timer up. Note that here the timer is set in continuous mode of operation. In continuous mode, the timer counts up from 0 to top value of 0xFFFF or 65535 and then rolls over to zero. Shown below are modes of operation of Timer A.

We want to have the on-board LEDs flash equally and alternatively. Since the timer is running at approximately 32 kHz, it will overflow in about 2 second time. To get the LEDs alter state every second, we have to divide 65535 timer count into two equal fractions and check the timer count on every main loop passes. It is checked if the timer count is 32678 or more, i.e. half of 65535. For one count fraction, i.e. from 0 to 32767, the red LED will be lit while the green LED will be off. The same goes for the other fraction, i.e. from 32768 to 65535 count, but the LEDs will be in different logic states.

if(Timer_A_getCounterValue(__MSP430_BASEADDRESS_T0A5__) >= 32768)
{
   GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
   GPIO_setOutputHighOnPin(GPIO_PORT_P4, GPIO_PIN7);
}

else
{
    GPIO_setOutputHighOnPin(GPIO_PORT_P1, GPIO_PIN0); 
    GPIO_setOutputLowOnPin(GPIO_PORT_P4, GPIO_PIN7);
} 

Demo

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

Related Posts

10 comments

Leave a Reply

Your email address will not be published. Required fields are marked *