Introduction

MSP430G2553 has two Timer_As viz. Timer0_A3 and Timer1_A3 which features 3 capture/compare registers while MSP430G2231 has only 1 timer called Timer0_A2 with only 2 capture/compare registers. In addition to Capture, Timer_A also supports PWM outputs and interrupts. They also include a Watchdog Timer (WDT+) which I will discuss in another tutorial.

Timer_A supports four different clock sources: ACLK, SMCLK and 2 external sources: TACLK or INCLK. The selected clock source can then be divided by 1,2,4 or 8. The register used for counting is called TAR(16-bit R/W) and can increment or decrement for each rising edge of clock signal. Compared to Timer blocks of other microcontrollers, these MCUs don’t support prescaler.

Timer Modes:

Timer_A supports 4 modes of operation:

1. Stop Mode: In this mode the Timer is Halted.
2. Up Mode: Timer repeatedly counts from Zero to value stored in Capture/Compare Register 0 (TACCR0).
3. Continuous: Timer repeatedly counts from Zero to 0xFFFF, which is maximum value for 16-bit TAR.
4. Up/Down Mode: Timer repeatedly counts from Zero up to the value in TACCR0 and back down to zero.

MSP430 Timer Registers

1) TAR – Timer Counter Register: Holds the current count for Timer_A.

2) TACCRx – Timer Capture/Compare Register: In Compare mode, it holds compare value to be compared against TAR. In Capture mode, it holds the current value of TAR when a capture is performed. Maximum value it can store is 0xFFFF since its a 16 bit register.

3) TACTL – Control Register: Used to configure Timer_A. This register is divided as follows:

• Bit[0] – TAIFG – Timer_A Interrupt Flag. 0 = No interrupt pending, 1 = Interrupt pending.
• Bit[1] – TAIE – Timer_A Interrupt Enable. 0 = Interrupt Disabled, 1 = Interrupt Enabled.
• Bit[2] – TACLR – Timer_A clear. Setting this bit resets TAR, clock divider, and the count direction. It is automatically reset and is always read as zero.
• Bits[5:4] – MCx – Mode Control bits. Used to select between 4 different modes as given:
  [00] = MC_0 – Stop mode: Timer is halted.
  [01] = MC_1 – Up mode: Timer counts up to TACCR0.
  [10] = MC_2 – Continuous mode: Timer counts up to 0xFFFF.
  [11] = MC_3 – Up/down mode: Timer counts up to TACCR0 then down to 0x0000.
• Bit[7:6] – IDx – Input divider. Selects input clock divider.
  [00] = ID_0 – /1
  [01] = ID_1 – /2
  [10] = ID_2 – /4
  [11] = ID_3 – /8
• Bits[9:8] TASSELx – Timer_A clock source select.
  [00] = TASSEL_0 – TACLK
  [01] = TASSEL_1 – ACLK
  [10] = TASSEL_2 – SMCLK
  [11] = TASSEL_3 – INCLK (check datasheet)
• Other Bits – Reserved

3) TACCTLx – Capture/Compare Control Register: Used to configure capture/compare options. I will only cover the parts of this register which are applicable to this tutorial. We will see it in detail in other tutorials(for Capture mode & PWM).

• Bit[0] – CCIFG – Capture/compare interrupt flag: 0 = interrupt pending, 1 = Interrupt pending.
• Bit[4] – CCIE – Capture/compare interrupt enable: This bit enables the interrupt request of the corresponding CCIFG flag. 0 = Interrupt disabled = 1 Interrupt enabled.
• Bit[8] – CAP – Capture mode: Used to select between Compare and Capture mode. We will this bit in its default setting i.e. = 0. 0 = Compare mode, 1 = Capture mode.

4) TAIV – Interrupt Vector Register: Used to identify the flag which requested an interrupt. This is a read only register and only uses 3 bits [3:1] called TAIVx. The values for TAIVx which corresponds to various sources is as given below:

• 0x00 = No Interrupt Pending.
• 0x02 = Capture/Compare 1 – TACCR1 CCIFG.
• 0x04 = Capture/Compare 2 – TACCR2 CCIFG.
• 0x0A = Timer(TAR) Overflow – TAIFG.
• Other – Reserved.

Configuring & Setting Up Timer in MSP430

Given, clocks are configured properly, basic setup of Timer_A can be done follows:

• Set the Compare value in TACCR0 if using Up mode or Up/Down mode. Timer may be stopped by using TACCR0 = 0; and can be started/restarted any time by writing a non-zero compare value in TACCR0 whenever Timer is to be used. Total Counts by timer will be TACCR0 + 1.
• Set CCIE(Capture/Counter Interrupt Enable) bit in TACCTL0 to enable interrupt for CCR0. We also keep the CAP bit to default value(=0) to enable Compare mode.
• Select Clock Source, Input Clock divider and Timer mode using TASSELx, IDx, MCx fields respectively.
• Enable global Interrupts and we are done.

In examples given below we will use Up mode with input clock source as SMCLK(MCx = MC_1) without an divider(IDx = ID_0 i.e. divide by 1). We will set MCLK and SMCLK to run at 1MHz, both sourcing clock from DCO. This is the default configuration.

TACCR0 = ..; //Compare Value for TAR
TACCTL0 |= CCIE; //Enable interrupt for CCR0.
TACTL = TASSEL_2 + ID_0 + MC_1; //Select SMCLK, SMCLK/1 , Up Mode
_enable_interrupt();
/* More code */

Handy MSP430 Timer Formulae for delay calculations

Formula for amount of time taken to increment TAR count by 1 is given as:

where DIV = Input Clock divider either 1,2,4 or 8.

E.g.: When using divider of /2 and Input clock of 4MHz we get timer resolution as,

The time required for TAR to count from 0 and reach TACCR0 (i.e. overflow or TAR period) is given as:

We subtract 1 from TACCR0 since TAR counts “TACCR0+1” times to overflow. This is because count starts from 0.

E.g.: When using divider of /2, Input clock of 4MHz and TACCR0 = 1000-1 = 999, we get Timer Period as,

MSP430 Timer Examples

Now, lets cover 2 Timer examples. Both examples are valid for MSP430G2553 , MSP430G2231 and similar MCUs.

Example 1: A simple Delay function using Interrupt

Of-course, we have the option of using inbuilt function __delay_cycles(..), but wheres the fun if we don’t implement a similar function using Timer? Anyways, in this example we will define a function called delayMS(int msec) which generates delay as per given input in mill-seconds. This function is used in conjunction with Timer_A Interrupt for CCR0. The time is counting, ISR continuously increments an Overflow counter when TAR reaches value in TACCR0. We set the value in TACCR0 such that counting from 0 to TACCR0 takes exactly 1ms, and hence we get a resolution of 1ms for our delay function. This function will give more accurate delay as MCLK increases, since it contains a few statements which eat up proportionate amount CPU cycles. Now, since we are using Timer Clock = 1MHz (SMCLK=1MHz), 1000 ticks will equal to 1ms. Hence, we use TACCR0 = 1000 inside delay function. In general for Y MHz timer clock, Y x 1000 ticks are required for 1ms delay. Before exiting the function we use TACCR0 = 0 to stop the Timer.

#include <msp430.h>

void initTimer_A(void);
void delayMS(int msecs);

unsigned int OFCount;

int main(void)
{
	WDTCTL = WDTPW + WDTHOLD; //Stop watchdog timer
	P1DIR |= BIT0; //Configure P1.0 as Output

	//Set MCLK = SMCLK = 1MHz
	BCSCTL1 = CALBC1_1MHZ;
	DCOCTL = CALDCO_1MHZ;

	initTimer_A();
	_enable_interrupt();

	while(1)
	{
		P1OUT |= BIT0; //Drive P1.0 HIGH - LED1 ON
		delayMS(500); //Wait 0.5 Secs

		P1OUT &= ~BIT0; //Drive P1.0 LOW - LED1 OFF
		delayMS(500); //Wait 0.5 Secs
	}
}

void initTimer_A(void)
{
	//Timer0_A3 Configuration
	TACCR0 = 0; //Initially, Stop the Timer
	TACCTL0 |= CCIE; //Enable interrupt for CCR0.
	TACTL = TASSEL_2 + ID_0 + MC_1; //Select SMCLK, SMCLK/1, Up Mode
}

void delayMS(int msecs)
{
	OFCount = 0; //Reset Over-Flow counter
	TACCR0 = 1000-1; //Start Timer, Compare value for Up Mode to get 1ms delay per loop
	//Total count = TACCR0 + 1. Hence we need to subtract 1.

	while(i<=msecs);

	TACCR0 = 0; //Stop Timer
}

//Timer ISR
#pragma vector = TIMER0_A0_VECTOR
__interrupt void Timer_A_CCR0_ISR(void)
{
	OFCount++; //Increment Over-Flow Counter
}

Example 2: Blinky using MSP430 Timer Interrupt

In this example, instead of using a dedicated delay function we place the blinky code inside the Timer_A Interrupt itself. The Timer initialization code is same as before. The Timer is never stopped and it repeatedly restarts counting when TAR reaches TACCR0 to generate 1ms delay. Similar to previous example, an overflow counter is maintained by ISR itself. We just need to define how much delay(in ms) we require. This is done by defining a MACRO BLINKY_DELAY_MS. Also, note that we won't be using Low Power Mode (LMP0). If you want to use LMP0 than make sure TACCR0 has a suitable maximum value along with higher clock divider, so CPU stays disabled most of the time. In our case we can use TACCR0 = 50000; and use overflow count limit of 10 for 500ms delay. In this way the ISR is called every 50ms when clock divider is 1, and every 200ms when clock divider is 4.

#include <msp430.h>
#define BLINKY_DELAY_MS 500 //Change this as per your needs

void initTimer_A(void);
void delayMS(int msecs);

unsigned int OFCount;

int main(void)
{
	WDTCTL = WDTPW + WDTHOLD; //Stop watchdog timer
	P1DIR |= BIT0; //Configure P1.0 as Output

	//Set MCLK = SMCLK = 1MHz
	BCSCTL1 = CALBC1_1MHZ;
	DCOCTL = CALDCO_1MHZ;

	initTimer_A();
	_enable_interrupt();

	OFCount  = 0;
	TACCR0 = 1000-1; //Start Timer, Compare value for Up Mode to get 1ms delay per loop
	/*Total count = TACCR0 + 1. Hence we need to subtract 1.
	1000 ticks @ 1MHz will yield a delay of 1ms.*/

	while(1);
}

void initTimer_A(void)
{
	//Timer Configuration
	TACCR0 = 0; //Initially, Stop the Timer
	TACCTL0 |= CCIE; //Enable interrupt for CCR0.
	TACTL = TASSEL_2 + ID_0 + MC_1; //Select SMCLK, SMCLK/1 , Up Mode
}

//Timer ISR
#pragma vector = TIMER0_A0_VECTOR
__interrupt void Timer_A_CCR0_ISR(void)
{
	OFCount++;
	if(OFCount >= BLINKY_DELAY_MS)
	{
		P1OUT ^= BIT0;
		OFCount = 0;
	}
}

The post MSP430 Timer Programming Tutorial appeared first on OCFreaks!.

Current version of MSP430G2 Launchpad Ships with MSP430G2553 and MSP430G2452. Older version(Rev1.4) used to ship with MSP430G2231 and MSP430G2211. However, programming is same for all supported devices unless mentioned.

GPIO Registers in MSP430

The GPIO block has many registers. We will only go through some of the digital I/O registers that are within the scope of this tutorial. I will cover Interrupt related registers(viz. PxIFG, PxIES, PxIE) in a different tutorial.

Also note that PxSEL/PxSEL2 registers do not change the pin directions as required by the module function. Make sure you set the proper pin direction, as required by the alternate function, using PxDIR register.

MSP430 GPIO Programming & Example Code in C/C++

Prerequisite: Before we start programming gpio you need to have basic understanding of Binary and Hexadecimal system and Bitwise operations in C/C++, here are two tutorials which can go through (or if you are already acquainted with these you can skip these and continue below) :

• Hexadecimal and Binary Number System basics for Embedded Programming
• Tutorial : Embedded programming basics in C – bitwise operations

msp430.h is common header for all MSP430 devices. This header identifies your device and accordingly includes the device specific header. Each of the device specific headers also include bit definitions viz. from BIT0 to BITF. Where BITn is equivalent to (1<<n) i.e the nth bit location is a 1 and rest bits are 0s.

Now lets see how we can assign values to registers. We can use Hexadecimal notation & decimal notation for assigning values. If your compiler supports other notations like binary notation use can use that too. Lets say, we want to set PIN 6 of Port 1 as output. It can be done in following ways:

CASE 1. P1DIR = (1<<6); //(binary using left shift - direct assign: other pins set to 0)

CASE 2. P1DIR |= 0x20; //or 0x20; (hexadecimal - OR and assign: other pins not affected)

CASE 3. P1DIR |= (1<<6); //(binary using left shift - OR and assign: other pins not affected)

CASE 4. P1DIR |= BIT6; //Same as above, use Standard BIT definitions

• In many scenarios, Case 1 must be avoided since we are directly assigning a value to the register. So while we are making P1.6 '1' others are forced to be assigned a '0' which can be avoided by ORing and then assigning Value.
• Case 2 can be used when bits need to be changed in bulk and
• Case 3(and 4) can be used when some or single bit needs to be changed.

First thing to note here is that preceding Zeros in Hexadecimal Notation can be ignored because they have no meaning since we are working with unsigned values here (positive only) which are assigned to Registers. For eg. 0x4 and 0x04 mean the same.

Basic example code in C/C++

Ex. 1)

Consider that we want to configure Pin 0 of Port 1 i.e P1.0 as Output and want to drive it HIGH. This can be done as:

P1DIR |= BIT0; //same as (1<<0) and 0x1, Configure P0.1 as Output
P1OUT |= BIT0; //Drive Output High for P1.0

Ex. 2)

Making output configured Pin P1.4 LOW individually, without affecting other bits can be does as follows:

P1DIR |= BIT4; //Configure P1.4 as Output
P1OUT &= ~BIT4; //Only P1.4 is made LOW

Ex. 3)

Configuring P1.4 and P1.6 as Output and Setting them HIGH together:

P1DIR |= BIT4 | BIT6; //Config P1.4 and P1.6 as Output
P1OUT |= BIT4 | BIT6; //Drive P1.4 and P1.6 HIGHT

Ex. 4)

Configuring all Pins of Port 1 (P1.0 to P1.7) as Output and Setting them High:

P1DIR = 0xFF; //Config all pins of P1 as Output
P1OUT = 0xFF; //Drive all pins HIGH

Ex. 5)

In this example code, we will configure Pin P1.3 as Input with internal Pullup enabled:

P1DIR &= ~BIT3; //Config P1.3 as input (It will be anyways input after reset)
P1REN = BIT3; //Enable Pullup/down for P1.3
P1OUT = BIT3; //Select Pullup resistor for P1.3

Ex. 6)

We can check the current state of Input pin P1.3, configured above, as:

if(P1IN & BIT3)
{
	//P1.3 is HIGH
}
else
{
	//P1.3 is LOW
}

Ex. 7)

Lets, say we have configured P1.4 as input with pullup resistor enabled and we want to continuously scan P1.4 until a LOW appears at the pin. This can be achieved as follows:

P1DIR &= ~BIT4; //Configure P1.4 as Input
P1REN = BIT4; //Enable Pullup/down for P1.4
P1OUT = BIT4; //Select Pullup resistor for P1.4

if(..) //some condition or parent loop
{
	while( !(P1IN & BIT4) ); //wait until P1.4 is LOW (busy wait)
	/*do something after loop terminates*/
}

Real World MSP430 GPIO Examples/Programs

Note: Examples(Demo Programs) given below assume default clock speeds. I have tested below programs using CCS V6.2.0 on MSP430G2231/MSP430G2211 but it will also work on MSP430G2553/MSP430G2452 and other compatible Microcontrollers.

Blinky Example Code

The most common example for GPIO is blinking an LED. Here we drive pin 0 of port 1 (P1.0) HIGH then LOW in a loop (Toggle). P1.0 is connected to LED1 on Launchpad Development board. We will use the intrinsic function __delay_cycles(unsigned long cycles) . As evident, it generates delay by the amount of clock cycles given as argument. However, this is not the recommended method for generating delays and must be avoided. I have used it in example below just for the sake of brevity. To generate delays using Timer please check my MSP430 Timer Tutorial.

#include <msp430.h>

int main(void)
{
	WDTCTL = WDTPW | WDTHOLD; //Stop watchdog timer to Prevent PUC Reset
	P1DIR |= BIT0; //Configure P1.0 as Output
	
	while(1)
	{
		P1OUT ^= BIT0; //Toggle P1.0 - LED Blinks
		__delay_cycles(400000);
	
		/* The above code is same as:
		P1OUT |= BIT0; //Drive P1.0 HIGH - LED1 ON
		__delay_cycles(400000);

		P1OUT &= ~BIT0; //Drive P1.0 LOW - LED1 OFF
		__delay_cycles(400000);	*/
	}
	//return 0; //normally this won't execute
}

Toggle LED with Button Switch

In this example program we will configure P1.3 as Input and monitor it for a LOW on the pin. P.3 is connected to Push Button Switch (S2) on the Launchpad. We will use LED2 i.e. P1.6 as output. Initially LED2 will be ON. Whenever we press the Button S2 it will toggle the LED state.

#include <msp430.h>

int main(void)
{
	WDTCTL = WDTPW | WDTHOLD; //Stop watchdog timer to Prevent PUC Reset
	P1DIR &= ~BIT3 ; //explicitly making P1.3 as Input - even though by default its Input
	P1REN = BIT3; //Enable Pullup/down
	P1OUT = BIT3; //Select Pullup

	P1DIR |= BIT6; //Configuring P1.6(LED2) as Output
	P1OUT |= BIT6; //drive output HIGH initially

	while(1)
	{
		if( !(P1IN & BIT3) ) //Evaluates to True for a 'LOW' on P1.3
		{
			P1OUT ^= BIT6; //Toggle the state of P1.6
			while( !(P1IN & BIT3) ); //wait until button is released
		}
	}
	//return 0; //this won't execute normally
}

Turn LED ON when Button is pressed else OFF

Now lets modify the above example so that when the button is pressed, LED2 will glow and when released or not pressed the LED won't glow. When switch is not pressed internal pull-up resistor will force the input to a HIGH state.

#include <msp430.h>

int main(void)
{
	WDTCTL = WDTPW | WDTHOLD; //Stop watchdog timer to Prevent PUC Reset
	P1DIR &= ~BIT3 ; //explicitly making P1.3 as Input - even though by default its Input
	P1REN = BIT3; //Enable Pullup/down
	P1OUT = BIT3; //Select Pullup

	P1DIR |= BIT6; //Configuring P1.6(LED2) as Output
	P1OUT &= ~BIT6; //Turn off LED2 initially
	
	while(1)
	{
		if( !(P1IN & BIT3) )
		{
			P1OUT |= BIT6; //Input LOW - turn led ON
		}
		else
		{
			P1OUT &= ~BIT6; //Input HIGH - turn led OFF
		}
	}
	
	//return 0; //normally this won't execute
}

The post MSP430 GPIO Programming Tutorial appeared first on OCFreaks!.