The Launchpad comes with a 32.768 kHz crystal that can be used when timing more precise than the DCO is needed. The crystal frequency is useful for simple timing tasks, such as a RTC, because it is a power of 2. That allows a simple cascade of 15 flip-flops to create a 1 pulse per second time base. It is common for microcontroller timers to have prescalers, postscalers and/or preset divisors that are simply a tap on the flip-flip chain. The watchdog timer in the MSP430 is an example of a timer with power of 2 presets (64, 512, 8192, 32768). TimerA units have a prescaler with power of 2 presets (1, 2, 4, 8).
The sample code in this post uses the watchdog timer to create an interrupt that occurs once per second. TimerA can also be used to do this. One of the advantages of using TimerA is the ability to change the preset +/- 1 every N cycles to allow for calibration and temperature compensation of the crystal. I chose to use the watchdog timer so that TimerA was free to be used for alarm tones or PWM backlight control.
Using the C standard library time functions for a RTC
The C standard library provides several functions for working with real time. The function prototypes are in time.h. The type time_t is typically an integer type that is in units of 1 second. It doesn't have to be that, but usually is. The epoch is usually January 1, 1970 for "unix time." Be aware that CCS uses an epoch of January 1, 1900 and time_t is unsigned rather than signed. I assume GCC uses the more common unix time epoch and time_t is signed.
Since time_t is in units of 1 second, the ISR for timekeeping is trivial...
#pragma vector = WDT_VECTOR // - Watchdog timer interrupt vector
__interrupt void wdt_isr(void) // This interrupt will occur once per second
{ //
++tt; // Increment time_t
} //
To display the time it can be converted to a tm structure that has elements for hours, minutes, day, month, ect. There are two functions to do this: gmtime() and localtime(). gmtime() converts to UTC, and localtime converts to the time zone for the set locale. Both functions take a time_t and return a pointer to a static tm struct.
To set the time the mktime() function will convert a tm struct to a time_t value. It will also determine day of week and day or year for you.
Benefits
Tivial ISR. Simple and efficient.
Portable code - the C standard library time functions work on almost any device with a C compiler.
Easy to calulate time deltas - use ordinary integer math on time_t values.
Easy to compare times using <, >, ==, etc.
Compact representation of time (32 bit time_t typically) is good for timestamps of data logs.
Some file systems (not FAT unfortunately) use time_t as for timestamps.
Concerns
Converting from time_t to tm struct takes quite a few clock cycles, so not good for low power (battery powered) systems.
Time functions take up quite a bit of flash - will not fit in G2211 for example.
Software model of a hardware RTC
Hardware real time clocks typically have counters for seconds, minutes, hours, ect. Each counter will reset at the appropriate
limit - 60 seconds, 24 hours, ect. This approch can be use for a software RTC. The ISR has more code than the previous version...
#pragma vector = WDT_VECTOR // - Watchdog timer interrupt vector
__interrupt void wdt_isr(void) // This interrupt will occur once per second
{ //
if(++t.tm_sec > 59) { // Increment seconds, check for overflow
t.tm_sec = 0; // Reset seconds
if(++t.tm_min > 59) { // Increment minutes, check for overflow
t.tm_min = 0; // Reset minutes
if(++t.tm_hour > 23) { // Increment hours, check for overflow
t.tm_hour = 0; // Reset hours
++t.tm_yday; // Increment day of year
if(++t.tm_wday > 6) // Increment day of week, check for overflow
t.tm_wday = 0; // Reset day of week
// Increment day of month, check for overflow
if(++t.tm_mday > dim[t.tm_mon][is_leap_year(t.tm_year + 1900)]) {
t.tm_mday = 1; // Reset day of month
if(++t.tm_mon > 11) { // Increment month, check for overflow
t.tm_mon = 0; // Reset month
t.tm_yday = 0; // Reset day of year
++t.tm_year; // Increment year
} // - year
} // - month
} // - day
} // - hour
} // - minute
} //
Most of the time the ISR will just increment the seconds member and return. The worst case is at the end of the year when the year is incremented and all other counters are reset to inital values.
There is no need for any conversion for display of the time or setting the time. Be aware that day of week and day of year must be explicity set and can be out-of-sync if not properly set.
Benefits
No conversion function needed for display of time or setting of time.
Small code size. Fits in G2211.
High efficiency is good for battery powered applications.
Use of tm struct provides some familiarity to those who have used the C standard library functions.
Concerns
No easy to way calulate time delta.
No support for time zones / localization.
Time comparison (for alarms) requires more MCU cycles because several structure members require comparason rather than just a long integer.
This sample code can be configured to use either of the two methods descibed by (un)commenting the "#define USE_STDLIB_TIME" in main.c
main.c
#include
#include
#include
#include "rtc.h"
#include "lcd.h"
//#define USE_STDLIB_TIME // Use functions in time.h
void show_time(const struct tm *t) // Show time on LCD
{
static const char *dow[7] = {
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
};
int x, w;
const char *d;
if(t->tm_hour < 10) {
x = -1;
lcd_fill(0, 1, 10, 2, 0);
} else {
x = 4;
lcd_fill(0, 1, 4, 2, 0);
lcd_pd12(t->tm_hour / 10, x, 1);
}
lcd_pd12(t->tm_hour % 10, x + 11, 1);
lcd_pd12(11, x + 22, 1);
lcd_pd12(t->tm_min / 10, x + 27, 1);
lcd_pd12(t->tm_min % 10, x + 38, 1);
lcd_pd12(11, x + 49, 1);
lcd_pd12(t->tm_sec / 10, x + 54, 1);
lcd_pd12(t->tm_sec % 10, x + 65, 1);
lcd_fill(x + 76, 1, 8 - x, 2, 0);
if(t->tm_mon < 9) {
x = -4;
lcd_fill(0, 3, 7, 2, 0);
} else {
x = 1;
lcd_fill(0, 3, 1, 2, 0);
lcd_pd12((t->tm_mon + 1) / 10, x, 3);
}
lcd_pd12((t->tm_mon + 1) % 10, x + 11, 3);
lcd_pd12(13, x + 22, 3);
lcd_pd12(t->tm_mday / 10, x + 30, 3);
lcd_pd12(t->tm_mday % 10, x + 41, 3);
lcd_pd12(13, x + 52, 3);
lcd_pd12(t->tm_year %100 / 10, x + 60, 3);
lcd_pd12(t->tm_year % 10, x + 71, 3);
lcd_fill(x + 82, 3, 2 - x, 2, 0);
d = dow[t->tm_wday];
w = strlen(d) * 6;
x = (84 - w) >> 1;
lcd_fill(0, 5, x, 1, 0);
lcd_print(d, x, 5);
x += w;
lcd_fill(x, 5, 84 - x, 1, 0);
}
//
struct tm ts; // Time structure
time_t tt; // Time in seconds since epoch
//
//
#pragma vector = WDT_VECTOR // - Watchdog timer interrupt vector
__interrupt void wdt_isr(void) // This interrupt will occur once per second
{ //
#ifdef USE_STDLIB_TIME //
++tt; // Increment time_t
#else //
rtc_tick(&ts); // Increment tm struct
#endif //
__bic_SR_register_on_exit(LPM0_bits); // Wakeup main code
} //
//
void main(void) //
{ //
WDTCTL = WDTPW | WDTHOLD; // Disable watchdog reset
//
lcd_init(); // Init LCD
lcd_clear(0); //
lcd_print("MSP430 RTC", 12, 0); //
//
// 32 kHz xtal loading
//BCSCTL3 = XCAP_1; // 6 pF (default)
BCSCTL3 = XCAP_2; // 10 pF
//BCSCTL3 = XCAP_3; // 12.5 pF
//
WDTCTL = WDTPW | WDTTMSEL | WDTCNTCL | WDTSSEL; // Use WDT as interval timer
IE1 |= WDTIE; // Enable WDT interrupt
_EINT(); // Enable interrupts
//
// Set initial time - there is no UI for this
ts.tm_hour = 13; // Hour
ts.tm_min = 37; // Minute
ts.tm_sec = 42; // Second
ts.tm_mon = 3; // Month (0 based!)
ts.tm_mday = 20; // Day of Month
ts.tm_year = 2012 - 1900; // Year
ts.tm_wday = 5; // Day of Week - Not used by mktime()
ts.tm_yday = 0; // Not used by mktime()
ts.tm_isdst = 0; // DST flag - Not used by rtc_tick()
//
#ifdef USE_STDLIB_TIME // Convert tm struct to time_t
tt = mktime(&ts); //
#endif //
//
for(; { // for-ever
#ifdef USE_STDLIB_TIME //
show_time(localtime(&tt)); // Convert time_t to tm struct and show on LCD
#else //
show_time(&ts); // Show time on LCD
#endif //
__bis_SR_register(LPM0_bits + GIE); // Sleep until WDT interrupt
} //
} //
rtc.h
void rtc_tick(struct tm *t);
rtc.c - Software model of hardware RTC
#include
static int is_leap_year(const int y)
{
if(y & 3) return 0; // Not divisible by 4
switch(y % 400) { // Divisible by 100, but not by 400 (1900, 2100, 2200, 2300, 2500, 2600)
case 100: case 200: case 300: return 0;
}
return 1; // Divisible by 4 and !(100 and !400)
}
void rtc_tick(struct tm *t)
{
static const signed char dim[12][2] = { // Number of days in month for non-leap year and leap year
31, 31, // January
28, 29, // February
31, 31, // March
30, 30, // April
31, 31, // May
30, 30, // June
31, 31, // July
31, 31, // August
30, 30, // September
31, 31, // October
30, 30, // November
31, 31 // December
}; //
//
if(++t->tm_sec > 59) { // Increment seconds, check for overflow
t->tm_sec = 0; // Reset seconds
if(++t->tm_min > 59) { // Increment minutes, check for overflow
t->tm_min = 0; // Reset minutes
if(++t->tm_hour > 23) { // Increment hours, check for overflow
t->tm_hour = 0; // Reset hours
++t->tm_yday; // Increment day of year
if(++t->tm_wday > 6) // Increment day of week, check for overflow
t->tm_wday = 0; // Reset day of week
// Increment day of month, check for overflow
if(++t->tm_mday > dim[t->tm_mon][is_leap_year(t->tm_year + 1900)]) {
t->tm_mday = 1; // Reset day of month
if(++t->tm_mon > 11) { // Increment month, check for overflow
t->tm_mon = 0; // Reset month
t->tm_yday = 0; // Reset day of year
++t->tm_year; // Increment year
} // - year
} // - month
} // - day
} // - hour
} // - minute
} //
lcd.h
typedef enum {
lcd_command = 0, // Array of one or more commands
lcd_data = 1, // Array of one or more bytes of data
lcd_data_repeat = 2 // One byte of data repeated
} lcd_cmd_type;
void lcd_send(const unsigned char *cmd, unsigned len, const lcd_cmd_type type);
void lcd_home(void);
void lcd_pos(unsigned char x, unsigned char y);
void lcd_clear(unsigned char x);
void lcd_init(void);
void lcd_fill(unsigned x, unsigned y, unsigned w, unsigned h, unsigned char z);
void lcd_print(const char *s, unsigned x, unsigned y);
void lcd_pd12(unsigned n, unsigned x, unsigned y);
