Embedded Lab

RTC_A as Counter

As with other timers, counter mode is a secondary feature of RTC_A module. In this mode, the calendar feature of RTC_A is not used. Instead of being an RTC, RTC_A in this mode behaves like a regular timer. However, unlike other regular timers, we cannot get timer count. This does not limit us much from using it for time bases as there are two counters that can be cascaded and, individually and independently prescaled. RTC_A is rarely used in this role because it is only used as such when we have run out of regular timers and have no need for RTC. 

Code Example

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

void clock_init(void);
void GPIO_init(void);
void RTC_init(void);

#pragma vector=RTC_VECTOR
__interrupt void RTC_A_ISR(void)
{
    switch (__even_in_range(RTCIV, 16))
    {
        case 0: break;  //No interrupts
        case 2: break;  //RTCRDYIFG
        case 4:         //RTCEVIFG
        {
            GPIO_toggleOutputOnPin(GPIO_PORT_P1,
                                   GPIO_PIN0);

            GPIO_toggleOutputOnPin(GPIO_PORT_P4,
                                   GPIO_PIN7);

            break;
        }
        case 6: break;  //RTCAIFG
        case 8: break;  //RT0PSIFG
        case 10: break; //RT1PSIFG
        default: break;
    }
}

void main(void)
{
    WDT_A_hold(WDT_A_BASE);

    clock_init();
    GPIO_init();
    RTC_init();

    while(1)
    {
    };
}

void clock_init(void)
{
    PMM_setVCore(PMM_CORE_LEVEL_3);

    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_3,
                    UCS_XCAP_3);

    UCS_initClockSignal(UCS_FLLREF,
                        UCS_XT2CLK_SELECT,
                        UCS_CLOCK_DIVIDER_4);

    UCS_initFLLSettle(MCLK_KHZ,
                      MCLK_FLLREF_RATIO);

    UCS_initClockSignal(UCS_SMCLK,
                        UCS_XT2CLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);

    UCS_initClockSignal(UCS_ACLK,
                        UCS_XT2CLK_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);

    GPIO_setOutputLowOnPin(GPIO_PORT_P1,
                           GPIO_PIN0);

    GPIO_setOutputHighOnPin(GPIO_PORT_P4,
                            GPIO_PIN7);
}

void RTC_init(void)
{
    RTC_A_initCounter(RTC_A_BASE,
                      RTC_A_CLOCKSELECT_RT1PS,
                      RTC_A_COUNTERSIZE_16BIT);

    RTC_A_initCounterPrescale(RTC_A_BASE,
                              RTC_A_PRESCALE_0,
                              RTC_A_PSCLOCKSELECT_SMCLK,
                              RTC_A_PSDIVIDER_4);

    RTC_A_initCounterPrescale(RTC_A_BASE,
                              RTC_A_PRESCALE_1,
                              RTC_A_PSCLOCKSELECT_RT0PS,
                              RTC_A_PSDIVIDER_16);

    RTC_A_setCounterValue(RTC_A_BASE,
                          0);

    RTC_A_clearInterrupt(RTC_A_BASE,
                         RTC_A_TIME_EVENT_INTERRUPT);

    RTC_A_clearInterrupt(RTC_A_BASE,
                         RTC_A_PRESCALE_TIMER1_INTERRUPT);

    RTC_A_enableInterrupt(RTC_A_BASE,
                          RTC_A_TIME_EVENT_INTERRUPT);

    RTC_A_enableInterrupt(RTC_A_BASE,
                          RTC_A_PRESCALE_TIMER1_INTERRUPT);

    RTC_A_startClock(RTC_A_BASE);

    __enable_interrupt();
}

Hardware Setup

Explanation

For simplest-possible demo, we will again make a LED toggler.                      

Obviously, counter mode is different from regular calendar mode and so we can use different clock settings. Here, we will be using SMCLK and it will be running at 4 MHz.

UCS_initClockSignal(UCS_SMCLK, UCS_XT2CLK_SELECT, UCS_CLOCK_DIVIDER_1);

Both on-board LEDs are used but they are initialized at different logic states.

GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);

GPIO_setAsOutputPin(GPIO_PORT_P4, GPIO_PIN7);

GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);

GPIO_setOutputHighOnPin(GPIO_PORT_P4, GPIO_PIN7);

RTC_A module’s setup this time is obviously different from the last RTC_A example.

void RTC_init(void)
{
    RTC_A_initCounter(RTC_A_BASE,
                      RTC_A_CLOCKSELECT_RT1PS,
                      RTC_A_COUNTERSIZE_16BIT);

    RTC_A_initCounterPrescale(RTC_A_BASE,
                              RTC_A_PRESCALE_0,
                              RTC_A_PSCLOCKSELECT_SMCLK,
                              RTC_A_PSDIVIDER_4);

    RTC_A_initCounterPrescale(RTC_A_BASE,
                              RTC_A_PRESCALE_1,
                              RTC_A_PSCLOCKSELECT_RT0PS,
                              RTC_A_PSDIVIDER_16);

    RTC_A_setCounterValue(RTC_A_BASE, 0);

    RTC_A_clearInterrupt(RTC_A_BASE, RTC_A_TIME_EVENT_INTERRUPT);

    RTC_A_clearInterrupt(RTC_A_BASE, RTC_A_PRESCALE_TIMER1_INTERRUPT);

    RTC_A_enableInterrupt(RTC_A_BASE, RTC_A_TIME_EVENT_INTERRUPT);

    RTC_A_enableInterrupt(RTC_A_BASE, RTC_A_PRESCALE_TIMER1_INTERRUPT);

    RTC_A_startClock(RTC_A_BASE);

    __enable_interrupt();
}

Firstly, the size of the main RTC counter and its clock source are set. Here the clock source is RT1PS. RT0PS and RT1PS are sub-counters. RT0PS is clocked with either SMCLK or ACLK while RT1PS is clocked with SMCLK, ACLK or prescaled RT0PS. Finally, the RTC module’s main counter can be fed with SMCLK, ACLK or prescaled RT1PS. Thus, here the latter codes involve setting these parameters. RT0PS is fed with 4 MHz SMCLK and then a prescalar of 4 is applied. The resultant frequency is a 1 MHz which is used to feed RT1PS. Now RT1PS is further prescaled by 16, resulting in 62.5 kHz clock. This is what that feeds the main counter. Only 16 bits of the 32-bit main counter is used. Thus, the main counter overflows roughly about every second.

Every overflow event triggers an interrupt. Inside the interrupt on-board LEDs are toggled.

#pragma vector=RTC_VECTOR
__interrupt void RTC_A_ISR(void)
{
    switch (__even_in_range(RTCIV, 16))
    {
        case 0: break;  //No interrupts
        case 2: break;  //RTCRDYIFG
        case 4:         //RTCEVIFG
        {
            GPIO_toggleOutputOnPin(GPIO_PORT_P1, GPIO_PIN0);

            GPIO_toggleOutputOnPin(GPIO_PORT_P4, GPIO_PIN7);

            break;
        }
        case 6: break;  //RTCAIFG
        case 8: break;  //RT0PSIFG
        case 10: break; //RT1PSIFG
        default: break;
    }
}

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