MSP430FR2676: Multiple Timers on Timer_B

To add to this, is there a better way to do what I am trying to do besides put each timer on a separate TB0CCTLn register?

I suspect that this isn't what you want. The timer is configured in continuous mode which means it counts to its maximum value and then goes back to zero. (UP mode would count to the value in CCR0 before reset.) You can of course get an interrupt on each CCRx but the rate at which they happen will be identical. With phase dependent on the CCRx values.

The CCR0 interrupt has its own interrupt vector while the others are shared and the IV register can be read to tell you which one fired. Described in detail in the user guide.

Oh, the data sheet shows that this device has five timers, Four TimerA and one TimerB.

Not quite sure on architecture of what you trying to do.

Each Timer device (e.g Timer A0, Timer A1, Timer B0) has its own counter that sets the period of the PWM cycle, now as that counter cycles (either up to 0xffff, or to some value specified by CCR0, depending on MC bits in TAxCTL - you have continuous, so it cycles up to 0xffff). Now there are many compare registers looking at the PWM counter CCR1-n; each of those can trigger when the PWM counter passes that point.

So the compare registers, are often used as the Duty Cycle in any PWM output, so they toggle for what percentage of the pwm cycle duration, that each of those outputs are active for. So setting CCR1 to 0xff - and it would typically be active from 0 to 0xff, and off from 0x100 to 0xffff; so the led attached would only be one for 1/256 of the total time - and so fairly dim.

Different compare register can have different CCRn values, and so be one for different percentages of the time.

So question is what are you trying to achieve, do all your LED flash at the same period, but with different durations? If so then may be able to do that with a single Timer. If the LEDs are totally asynchronous (e.g. one flashing every 5s and another every 7s) - then you probably need multiple Timers for that.

Does that help? Not sure I've really understood what you are trying to do.

And just a though looking at the code. Have you though of doing port mapping; so have the Timer explicitly toggling a IO port, and then if you can't attach you LEDs to those pins, then port mapping to where the LED is connected? Means you don't need the code to toggle the LED light, instead the timer device does this.

Hi David,

I have attached my latest code that I have so far to hopefully give more clarity to what I am trying to do. In essence, you did describe it well in your comment of what I am trying to do. I am trying to have four timers that are controlled separately for four separate LEDs. I am fine if they are controlled on the same clock, but I want them to be able to be set at different times. For example, I want the software to be able to start the LED1 timer to turn LED1 on when a certain button is pressed and leave it on for a certain amount of seconds before turning it off (could be set anywhere from a few ms to 20 seconds). While the timer for LED1 is running, another button could be pressed to turn on LED2 for a different amount of time before it turns off. The same would be happening with LEDs 3 and 4. It sounds like this may not be the best approach to do. If that is the case, I could create a custom timer code myself that counts independently. However, I wanted to try and utilize the timer modules the MSP430 already had.

//*****************************************************************************
// Definitions
//*****************************************************************************

//*****************************************************************************
//
//! Timer B is used for the LEDs.
//! Register 0 is LED 1.
//! Register 1 is LED 2.
//! Register 2 is LEDs 3.
//! Register 3 is LEDs 4
//! \def TIMER_B_RESET defines a shortcut to set the timer B reset bit.
//! \def TIMER_B_CTL_SET defines a shortcut to set the timer B clock to the
//!      SMCLK divided by 2 (1MHz), the timer B mode to up count, and set the
//!      max count to 16-bit (65535).
//! \def TIMER_B_CTL_STOP defines a shortcut to stop the timer B clocks.
//! \def TIMER_B_LED_1_IQR_ENABLE defines a shortcut to set the timer B
//!      register 0 interrupt enable bit.
//! \def TIMER_B_LED_1_IQR_CLEAR defines a shortcut to clear the timer B
//!      register 0 interrupt bit.
//! \def TIMER_B_LED_1_COUNT defines a shortcut to the timer B count
//!      register 0.
//! \def TIMER_B_LED_2_IQR_ENABLE defines a shortcut to set the timer B
//!      register 1 interrupt enable bit.
//! \def TIMER_B_LED_2_IQR_CLEAR defines a shortcut to clear the timer B
//!      register 1 interrupt bit.
//! \def TIMER_B_LED_2_COUNT defines a shortcut to the timer B count
//!      register 1.
//! \def TIMER_B_LED_3_IQR_ENABLE defines a shortcut to set the timer B
//!      register 2 interrupt enable bit.
//! \def TIMER_B_LED_3_IQR_CLEAR defines a shortcut to clear the timer B
//!      register 2 interrupt bit.
//! \def TIMER_B_LED_3_COUNT defines a shortcut to the timer B count
//!      register 2.
//! \def TIMER_B_LED_4_IQR_ENABLE defines a shortcut to set the timer B
//!      register 3 interrupt enable bit.
//! \def TIMER_B_LED_4_IQR_CLEAR defines a shortcut to clear the timer B
//!      register 3 interrupt bit.
//! \def TIMER_B_LED_4_COUNT defines a shortcut to the timer B count
//!      register 3.
//
//*****************************************************************************
#define TIMER_B_RESET                                         (TB0CTL |= TBCLR)
#define TIMER_B_CTL_SET   (TB0CTL |= TBSSEL__SMCLK | ID__2 | MC__UP | CNTL__16)
#define TIMER_B_CTL_STOP                                        (TB0CTL &= ~MC)
#define TIMER_B_LED_1_IQR_ENABLE                             (TB0CCTL0 |= CCIE)
#define TIMER_B_LED_1_IQR_CLEAR                            (TB0CCTL0 &= ~CCIFG)
#define TIMER_B_LED_1_COUNT                                           (TB0CCR0)
#define TIMER_B_LED_2_IQR_ENABLE                             (TB0CCTL1 |= CCIE)
#define TIMER_B_LED_2_IQR_CLEAR                            (TB0CCTL1 &= ~CCIFG)
#define TIMER_B_LED_2_COUNT                                           (TB0CCR1)
#define TIMER_B_LED_3_IQR_ENABLE                             (TB0CCTL2 |= CCIE)
#define TIMER_B_LED_3_IQR_CLEAR                            (TB0CCTL2 &= ~CCIFG)
#define TIMER_B_LED_3_COUNT                                           (TB0CCR2)
#define TIMER_B_LED_4_IQR_ENABLE                             (TB0CCTL3 |= CCIE)
#define TIMER_B_LED_4_IQR_CLEAR                            (TB0CCTL3 &= ~CCIFG)
#define TIMER_B_LED_4_COUNT                                           (TB0CCR3)

//*****************************************************************************
// Function Implementations
//*****************************************************************************

void Timer_startLED1Timer(uint16_t usDuration)
{
    // Initialize timer B, if applicable
    Timer_startTimerB();

    // Enable the LED timer 1 interrupt, set the count, and clear the interrupt bit
    TIMER_B_LED_1_IQR_ENABLE;
    TIMER_B_LED_1_COUNT = usDuration;
    TIMER_B_LED_1_IQR_CLEAR;
}

void Timer_startLED2Timer(uint16_t usDuration)
{
    // Initialize timer B, if applicable
    Timer_startTimerB();

    // Enable the LED 2 timer interrupt, set the count, and clear the interrupt bit
    TIMER_B_LED_2_IQR_ENABLE;
    TIMER_B_LED_2_COUNT = usDuration;
    TIMER_B_LED_2_IQR_CLEAR;
}

void Timer_startLED3Timer(uint16_t usDuration)
{
    // Initialize timer B, if applicable
    Timer_startTimerB();

    // Enable the LED 3 timer interrupt, set the count, and clear the interrupt bit
    TIMER_B_LED_3_IQR_ENABLE;
    TIMER_B_LED_3_COUNT = usDuration;
    TIMER_B_LED_3_IQR_CLEAR;
}

void Timer_startLED4Timer(uint16_t usDuration)
{
    // Initialize timer B, if applicable
    Timer_startTimerB();

    // Enable the LED 4 timer interrupt, set the count, and clear the interrupt bit
    TIMER_B_LED_4_IQR_ENABLE;
    TIMER_B_LED_4_COUNT = usDuration;
    TIMER_B_LED_4_IQR_CLEAR;
}

void Timer_stopLEDTimers(void)
{
    TIMER_B_CTL_STOP;
    TIMER_B_RESET;
}

void Timer_startTimerB(void)
{
    // Initialize the timer B peripheral, if the timer is not already running
    // TODO: Add way to check the status of the timer
	if (1)
	{
        Timer_stopLEDTimers();
        TIMER_B_CTL_SET;
    }
}

// Interrupt for the LED 1 timer
#pragma vector = TIMER0_B0_VECTOR
__interrupt void Timer_led1ISR()
{
	// TODO: Toggle LED 1 and stop timer, if applicable
}

// Interrupt for other LED timers
#pragma vector = TIMER0_B1_VECTOR
__interrupt void Timer_led2To4ISR()
{
	// TODO: Check which interrupt occurred, toggle appropriate LED, and stop timer, if applicable
}