449stk2.c

Go to the documentation of this file.

/*
 * File:        449stk2.c
 * Purpose:     Main program
 * Author:      Peter Ivanov and others
 * Modified by:
 * Created:     2007-05-19 11:29:32
 * Last modify: 2007-12-09 17:12:51 ivanovp {Time-stamp}
 * Copyright:   (C) Peter Ivanov, 2007
 * Licence:     GPL
 */
/**
 * \file 449stk2.c
 * \brief Main program
 * \author Peter Ivanov and others
 */

#include <msp430x44x.h>
#include <msp430/basic_clock.h>
#include <msp430/system_clock.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <signal.h>
#include <math.h>
#include "lcd.h"
#include "uart.h"
#include "rtc.h"
//#include "rtc_calendar.h"
#include "menu.h"
#include "common.h"
#include "nrf24l01.h"

#define SIZE_OPTIMIZED

#ifdef SIZE_OPTIMIZED
#define TEST_DELAY  250
#else
#define TEST_DELAY  5000
#endif

uint8_t menuOn = 0;

uint8_t tickOn = 0;
uint8_t mode24hOn = 1;
uint8_t alarmHour = 0x12;
uint8_t alarmPm = 0;
uint8_t alarmMinute = 0;
uint8_t alarmOn = 0;
//uint8_t alarmMinute = 1; // DEBUG
//uint8_t alarmOn = 1;     // DEBUG
volatile uint8_t alarmStarted = 0;
//volatile uint32_t time = 0;

/**
 * Software delay.
 *
 * @author Peter Ivanov
 *
 * Input:
 *    @param a Loop count.
 */
void delay (unsigned int a)                           //9+a*12 cycles
{
    unsigned int i;
    for (i = 0; i < a; i++);
}

/**
 * Software longer delay.
 *
 * @author Peter Ivanov
 *
 * Input:
 *    @param b Loop count.
 */
void delayX (unsigned int b)
{
    unsigned int i;
    for (i = 0; i < b; i++) 
    {
        delay (255);
    }
}

/**
 * Switches red LED on/off.
 *
 * @author Peter Ivanov
 *
 * Input:
 *    @param on TRUE: switch on, FALSE: switch off.
 */
void setStatusLed (bool_t on)
{
    if (on)
    {
        P1OUT &= ~STATUS_LED; // switch on status LED
    }
    else  
    {
        P1OUT |= STATUS_LED;  // switch off status LED
    }
}

/**
 * Switches buzzer on or off. You should frequently switch on and off to 
 * generate a sound.
 *
 * @author Peter Ivanov
 *
 * Input:
 *    @param on TRUE: switch on, FALSE: switch off.
 */
void setBuzzer (bool_t on)
{
    if (on)
    {
        P1OUT &= ~BIT0;    //P1.2
        P1OUT |= BIT2;     //P1.3
    }
    else
    {
        P1OUT |= BIT0;     //P1.2
        P1OUT &= ~BIT2;    //P1.3
    }
}

/**
 * Generates tick sound.
 *
 * @author Peter Ivanov
 */
void tick (void)
{
    setBuzzer (TRUE);
#ifndef SIZE_OPTIMIZED
    delay (50);
#endif
    setBuzzer (FALSE);
}

/**
 * Generates sound.
 *
 * @author Peter Ivanov
 *
 * Input:
 *   @param Delay It is in inverse ratio to pitch.
 *   @param length Length of sound.
 */
void sound (uint16_t Delay, uint length)
{
    while (--length)
    {
        setBuzzer (TRUE);
        delay (Delay);
        setBuzzer (FALSE);
        delay (Delay);
    }
}

/**
 * Samples and returns AD-converter value of channel 10
 * (MSP430's internal temperature reference diode)
 * NOTE: to get a more exact value, 8-times oversampling is used
 *
 * @author Andreas Dannenberg, Peter Ivanov
 *
 * Output:
 *   @return Temperature.
 */
unsigned int getTemp ()
{
    unsigned long rv;

    ADC12CTL0 = ADC12ON | SHT0_15 | MSH | REFON;    // ADC on, int. ref. on (1,5 V),
    // multiple sample & conversion
    ADC12CTL1 = ADC12SSEL_2 | ADC12DIV_7 | CSTARTADD_0 | CONSEQ_1 | SHP;   // MCLK / 8 = 1 MHz

    ADC12MCTL0 = SREF_1 | INCH_10;                  // int. ref., channel 10
    ADC12MCTL1 = SREF_1 | INCH_10;                  // int. ref., channel 10
    ADC12MCTL2 = SREF_1 | INCH_10;                  // int. ref., channel 10
    ADC12MCTL3 = SREF_1 | INCH_10;                  // int. ref., channel 10
    ADC12MCTL4 = SREF_1 | INCH_10;                  // int. ref., channel 10
    ADC12MCTL5 = SREF_1 | INCH_10;                  // int. ref., channel 10
    ADC12MCTL6 = SREF_1 | INCH_10;                  // int. ref., channel 10
    ADC12MCTL7 = EOS | SREF_1 | INCH_10;            // int. ref., channel 10, last seg.
                                                    
    ADC12CTL0 |= ENC;                               // enable conversion
    ADC12CTL0 |= ADC12SC;                           // sample & convert
                                                    
    while (ADC12CTL0 & ADC12SC);                    // wait until conversion is complete
                                                    
    ADC12CTL0 &= ~ENC;                              // disable conversion

    rv = ADC12MEM0;                                 // sum up values...
    rv += ADC12MEM1;
    rv += ADC12MEM2;
    rv += ADC12MEM3;
    rv += ADC12MEM4;
    rv += ADC12MEM5;
    rv += ADC12MEM6;
    rv += ADC12MEM7;

    // Peter Ivanov: switch off AD module to save power
    ADC12CTL0 &= ~(ADC12ON | REFON);

    rv >>= 3;                                       // ... and divide by 8
    return rv;
}

/** 
 * Temperature offset in Celsius. This value is for my MSP430-449STK2 board!
 *
 * My calibration:
 * A/D: 2799 -> 7.1 Celsius
 * A/D: 2965 -> 25.0 Celsius
 */
#define TEMP_OFFSET     -3.3

/**
 * Calculates internal temperature of MSP430.
 * You should calibrate the value! Change the TEMP_OFFSET define!
 *
 * @author Peter Ivanov
 *
 * Output:
 *   @return Temperature in Celsius-degrees.
 */
float getTempCelsius ()
{
    unsigned int temp =  getTemp ();
    float tempCelsius = (1.5 * temp / 4096 - 0.986) / 0.00355 + TEMP_OFFSET;
#if 0
    UART_printf ("%s(): temp: %i tempCelsius: %i.%02i\r\n", __FUNCTION__, 
            temp, (int) (tempCelsius), ((int) ((tempCelsius - floor (tempCelsius)) * 100.0))
            );
#endif
    return tempCelsius;
}

/**
 * Increase BCD variable by one.
 *
 * @author Peter Ivanov
 *
 * Input/Output:
 *   @param variable Pointer to variable to increase.
 */
void bcdInc (uint8_t* variable)
{
    uint8_t in, out;
    in = *variable;
    asm (
            "clrc\n"
            "dadd.b #0x01, %1\n"
            "mov.b %1, %0\n"
            : "=r" (out) // %0  // output operands
            : "r" (in)   // %1  // input operands
//          :                   // clobbered registers
        );
    *variable = out;
}

/**
 * Decrease BCD variable by one.
 *
 * @author Peter Ivanov
 *
 * Input/Output:
 *   @param variable Pointer to variable to decrease.
 */
void bcdDec (uint8_t* variable)
{
    uint8_t in, out;
    in = *variable;
    asm (
            "setc\n"
            "dadd.b #0x98, %1\n"
            "mov.b %1, %0\n"
            : "=r" (out) // %0  // output operands
            : "r" (in)   // %1  // input operands
//          : ""                // clobbered registers
        );
    *variable = out;
}

/**
 * Initializes Real-Time-Clock system: enables watchdog interrupt. We will get 
 * an interrupt in every second.
 *
 * @author Peter Ivanov
 */
void RTC_init ()
{
    FLL_CTL0 |= XCAP18PF;       // Set load cap for 32k xtal
    WDTCTL = WDT_ADLY_1000;     // WDT interrupt in every second
    IE1 |= WDTIE;
    _EINT ();
}

/// Variable changed by watchdog ISR.
volatile uint8_t colonOn = 0;

/// Temperature in Celsius multiplied by 10.
int16_t tempCelsius;

/**
 * Updates LCD display to show clock and temperature values.
 *
 * @author Peter Ivanov
 */
void updateDisplay ()
{
    int8_t hour;
    if (menuOn || alarmStarted)
    {
        LCD_writeClockDigit (0, TI_minute & 0x0F);
        LCD_writeClockDigit (1, TI_minute >> 4);
        if (mode24hOn)
        {
            hour = get24Hour (TI_hour, TI_PM);
            LCD_writeClockDigit (2, hour & 0x0F);
            LCD_writeClockDigit (3, hour >> 4);
            LCD_setClockDot (0, 0);
        }
        else
        {
            LCD_writeClockDigit (2, TI_hour & 0x0F);
            LCD_writeClockDigit (3, TI_hour >> 4);
            LCD_setClockDot (0, TI_PM);
        }
        LCD_setClockColon (colonOn);
    }
    else
    {
        if (mode24hOn)
        {
            hour = get24Hour (TI_hour, TI_PM);
            LCD_printf ("%02X%02X%02X ", hour, TI_minute, TI_second);
            LCD_setClockDot (0, 0);
        }
        else
        {
            LCD_printf ("%02X%02X%02X ", TI_hour, TI_minute, TI_second);
            LCD_setClockDot (0, TI_PM);
        }
        LCD_writeLetter (2, '.');
        //if (TI_second & 1)
        if (colonOn)
        {
            LCD_writeLetter (4, ':');
        }
        if ((TI_second & 0x0F) == 0x00)
        {
            // update temperature in every 10 seconds
            tempCelsius = getTempCelsius () * 10.0;
        }
        LCD_writeClockInt (tempCelsius, FALSE);
        LCD_setClockDot (0, TRUE);
    }
    if (alarmOn)
    {
        if (TI_hour == alarmHour && TI_minute == alarmMinute && 
                TI_second == 0x00)
        {
            alarmStarted = 1;
        }
        if (alarmStarted)
        {
            if (!(TI_second & 1))
            {
                setStatusLed (TRUE);
                LCD_printf (" ALARM ");
#ifdef SIZE_OPTIMIZED
                sound (100, 500);
#else
                sound (2000, 500);
#endif
            }
            else
            {
                setStatusLed (FALSE);
                LCD_printf ("       ");
            }
        }
        if (alarmStarted && TI_second == 0x29)
        {
            // Stop alarm after 30 seconds
            alarmStarted = 0;
        }
    }
}

volatile uint8_t clockOn = 1;
/**
 * Interrupt service routine of watchdog. It is called in every second.
 *
 * @author Peter Ivanov
 */
interrupt (WDT_VECTOR) wakeup watchdog_isr (void)
{
    //time++;
    if (clockOn)
    {
        incrementSeconds ();
        colonOn = !colonOn;
        updateDisplay ();
        if (tickOn && !alarmStarted)
        {
            tick ();
        }
    }
    //LPM3_EXIT;
}

/// Previous status of buttons
uint8_t buttonStatusPrev;
/// Current status of buttons
uint8_t buttonStatus;
/// Pressed buttons
uint8_t buttonPressed;
/// Released buttons
uint8_t buttonReleased;

/**
 * Keyboard handler function. You should call this function frequently, because
 * it uses polling method.
 *
 * @author Peter Ivanov
 */
void buttonHandler ()
{
    if (buttonPressed)
    {
        // szoftveres pergesmentesites
#ifdef SIZE_OPTIMIZED
        delayX (300);
#else
        delayX (2000);
#endif
    }
    buttonStatusPrev = buttonStatus;
    buttonStatus = ~(P3IN & BTN_MASK);
    buttonPressed = (buttonStatusPrev ^ buttonStatus) & buttonStatus;
    buttonReleased = (buttonStatusPrev ^ buttonStatus) & buttonStatusPrev;
    if (buttonPressed && alarmStarted)
    {
        setStatusLed (FALSE);
        setBuzzer (FALSE);
        LCD_printf ("       ");
        alarmStarted = 0;

        buttonPressed = 0;
        MENU_showCurrentMenuItem ();
    }
}

/*
 * ### MENU FUNCTIONS ###
 */

/**
 * Decrease hour variable by one (BCD).
 *
 * @author Peter Ivanov
 */
void hourDec (uint8_t* hour, uint8_t* pm)
{
    if (*hour == 0x12)
    {
        if (*pm)
        {
            *pm = 0;
        }
        else
        {
            *pm = 1;
        }
    }
    bcdDec (hour);
    if (*hour == 0x00)
    {
        *hour = 0x12;
    }
}

/**
 * Increase hour variable by one (BCD).
 *
 * @author Peter Ivanov
 */
void hourInc (uint8_t* hour, uint8_t* pm)
{
    bcdInc (hour);
    if (*hour >= 0x13)
    {
        *hour = 1;
    }
    if (*hour == 0x12)
    {
        if (*pm)
        {
            *pm = 0;
        }
        else
        {
            *pm = 1;
        }
    }
}

/**
 * Menu callback function to set hour.
 *
 * @author Peter Ivanov
 */
void setClockHour ()
{
    uint8_t hour = TI_hour;
    uint8_t pm = TI_PM;
    uint8_t write = 1;
    buttonPressed = 0;
    LCD_showArrows (LCD_ARROW_ALL);
    while (!((buttonPressed & BTN_QUIT) || (buttonPressed & BTN_OK)))
    {
        buttonHandler ();
        if (buttonPressed & BTN_UP)
        {
            hourInc (&hour, &pm);
            write = 1;
        }
        if (buttonPressed & BTN_DOWN)
        {
            hourDec (&hour, &pm);
            write = 1;
        }
        if (write)
        {
            if (mode24hOn)
            {
                LCD_printf ("HOUR %02X", get24Hour (hour, pm));
            }
            else
            {
                LCD_printf ("H %s %02X", pm ? "PM" : "AM", hour);
            }
            write = 0;
        }
    }
    if (buttonPressed & BTN_OK)
    {
        clockOn = 0;
        TI_hour = hour;
        TI_PM = pm;
        updateDisplay ();
        clockOn = 1;
    }
}

/**
 * Decrease minute variable by one (BCD).
 *
 * @author Peter Ivanov
 */
void minDec (uint8_t* min)
{
    bcdDec (min);
    if (*min == 0x99)
    {
        *min = 0x59;
    }
}

/**
 * Increase minute variable by one (BCD).
 *
 * @author Peter Ivanov
 */
void minInc (uint8_t* min)
{
    bcdInc (min);
    if (*min >= 0x60)
    {
        *min = 0x00;
    }
}

/**
 * Menu callback function to set minute.
 *
 * @author Peter Ivanov
 */
void setClockMin ()
{
    uint8_t min = TI_minute;
    uint8_t write = 1;
    buttonPressed = 0;
    LCD_showArrows (LCD_ARROW_ALL);
    while (!((buttonPressed & BTN_QUIT) || (buttonPressed & BTN_OK)))
    {
        buttonHandler ();
        if (buttonPressed & BTN_UP)
        {
            minInc (&min);
            write = 1;
        }
        if (buttonPressed & BTN_DOWN)
        {
            minDec (&min);
            write = 1;
        }
        if (write)
        {
            LCD_printf ("MIN  %02X", min);
            write = 0;
        }
    }
    if (buttonPressed & BTN_OK)
    {
        clockOn = 0;
        TI_minute = min;
        TI_second = 0;
        updateDisplay ();
        clockOn = 1;
    }
}

/**
 * Menu callback function to 24 hour mode on/off.
 *
 * @author Peter Ivanov
 */
void setMode24h ()
{
    uint8_t write = 1;
    uint8_t on = mode24hOn;
    buttonPressed = 0;
    LCD_showArrows (LCD_ARROW_ALL);
    while (!((buttonPressed & BTN_QUIT) || (buttonPressed & BTN_OK)))
    {
        buttonHandler ();
        if ((buttonPressed & BTN_UP) || (buttonPressed & BTN_DOWN))
        {
            on = !on;
            write = 1;
        }
        if (write)
        {
            LCD_printf ("24H %s", on ? "ON " : "OFF");
            write = 0;
        }
    }
    if (buttonPressed & BTN_OK)
    {
        clockOn = 0;
        mode24hOn = on;
        updateDisplay ();
        clockOn = 1;
    }
}

/**
 * Menu callback function to set tick sound on/off.
 *
 * @author Peter Ivanov
 */
void setTick ()
{
    uint8_t write = 1;
    uint8_t on = tickOn;
    buttonPressed = 0;
    LCD_showArrows (LCD_ARROW_ALL);
    while (!((buttonPressed & BTN_QUIT) || (buttonPressed & BTN_OK)))
    {
        buttonHandler ();
        if ((buttonPressed & BTN_UP) || (buttonPressed & BTN_DOWN))
        {
            on = !on;
            write = 1;
        }
        if (write)
        {
            LCD_printf ("TCK %s", on ? "ON " : "OFF");
            write = 0;
        }
    }
    if (buttonPressed & BTN_OK)
    {
        tickOn = on;
    }
}

/**
 * Menu callback function to set hour of alarm.
 *
 * @author Peter Ivanov
 */
void setAlarmHour ()
{
    uint8_t hour = alarmHour;
    uint8_t pm = alarmPm;
    uint8_t write = 1;
    buttonPressed = 0;
    LCD_showArrows (LCD_ARROW_ALL);
    while (!((buttonPressed & BTN_QUIT) || (buttonPressed & BTN_OK)))
    {
        buttonHandler ();
        if (buttonPressed & BTN_UP)
        {
            hourInc (&hour, &pm);
            write = 1;
        }
        if (buttonPressed & BTN_DOWN)
        {
            hourDec (&hour, &pm);
            write = 1;
        }
        if (write)
        {
            if (mode24hOn)
            {
                LCD_printf ("HOUR %02X", get24Hour (hour, pm));
            }
            else
            {
                LCD_printf ("H %s %02X", pm ? "PM" : "AM", hour);
            }
            write = 0;
        }
    }
    if (buttonPressed & BTN_OK)
    {
        clockOn = 0;
        alarmHour = hour;
        alarmPm = pm;
        updateDisplay ();
        clockOn = 1;
    }
}

/**
 * Menu callback function to set minute of alarm.
 *
 * @author Peter Ivanov
 */
void setAlarmMin ()
{
    uint8_t min = alarmMinute;
    uint8_t write = 1;
    buttonPressed = 0;
    LCD_showArrows (LCD_ARROW_ALL);
    while (!((buttonPressed & BTN_QUIT) || (buttonPressed & BTN_OK)))
    {
        buttonHandler ();
        if (buttonPressed & BTN_UP)
        {
            minInc (&min);
            write = 1;
        }
        if (buttonPressed & BTN_DOWN)
        {
            minDec (&min);
            write = 1;
        }
        if (write)
        {
            LCD_printf ("MIN  %02X", min);
            write = 0;
        }
    }
    if (buttonPressed & BTN_OK)
    {
        clockOn = 0;
        alarmMinute = min;
        updateDisplay ();
        clockOn = 1;
    }
}

/**
 * Menu callback function to switch on/off alarm.
 *
 * @author Peter Ivanov
 */
void setAlarmOnOff ()
{
    uint8_t write = 1;
    uint8_t on = alarmOn;
    buttonPressed = 0;
    LCD_showArrows (LCD_ARROW_ALL);
    while (!((buttonPressed & BTN_QUIT) || (buttonPressed & BTN_OK)))
    {
        buttonHandler ();
        if ((buttonPressed & BTN_UP) || (buttonPressed & BTN_DOWN))
        {
            on = !on;
            write = 1;
        }
        if (write)
        {
            LCD_printf ("ALM %s", on ? "ON " : "OFF");
            write = 0;
        }
    }
    if (buttonPressed & BTN_OK)
    {
        clockOn = 0;
        alarmOn = on;
        updateDisplay ();
        clockOn = 1;
    }
}

#ifdef NRF24L01
/**
 * Menu point to test extension module MOD-RF24Lx (2.4 GHz transceiver module) in master mode.
 */
void rf24lMasterTest ()
{
    uint8_t inByte;
    uint8_t outByte = 0x7F;

    LCD_printf ("NRF INIT");
    NRF_init ();
    LCD_printf ("NRF OK  ");

    buttonPressed = 0;
    LCD_clearArrows (LCD_ARROW_RIGHT | LCD_ARROW_UP | LCD_ARROW_DOWN);
    LCD_showArrows (LCD_ARROW_LEFT);
    while (!(buttonPressed & BTN_QUIT))
    {
        buttonHandler ();

        if (buttonPressed & BTN_OK)
        {
            NRF_send (outByte);
            NRF_prepareForReceive ();
            LCD_printf (">%02X    ", outByte);
            outByte++;
        }
        if (NRF_receive (&inByte))
        {
            LCD_printf ("%02X%02X %s", outByte - 1, inByte, inByte == (256 - outByte) ? "OK" : "ER");
        }

        delayX (10);
    };
}

/**
 * Menu point to test extension module MOD-RF24Lx (2.4 GHz transceiver module) in slave mode.
 */
void rf24lSlaveTest ()
{
    uint8_t inByte;
    uint8_t outByte;

    LCD_printf ("NRF INIT");
    NRF_init ();
    LCD_printf ("NRF OK  ");

    buttonPressed = 0;
    LCD_clearArrows (LCD_ARROW_RIGHT | LCD_ARROW_UP | LCD_ARROW_DOWN);
    LCD_showArrows (LCD_ARROW_LEFT);
    while (!(buttonPressed & BTN_QUIT))
    {
        buttonHandler ();

        if (NRF_receive (&inByte))
        {
            outByte = 255 - inByte;
            delayX (100); // wait for the other side to switch to RX mode!
            NRF_send (outByte);
            NRF_prepareForReceive ();
            LCD_printf ("<%02X >%02X", inByte, outByte);
        }

        delayX (10);
    };
}
#endif

/**
 * Clock sub-menu.
 * The length of menu title must be seven characters long (add spaces to the end)!
 *
 * @author Peter Ivanov
 */
menuPoint_t setClockMenu[] =
{
    //1234567   sub-menu        callback function
    {"HOUR   ", NULL,           &setClockHour},
    {"MINUTE ", NULL,           &setClockMin},
    {"24H    ", NULL,           &setMode24h},
    {"TICK   ", NULL,           &setTick},
    {NULL,      NULL,           NULL}   // end of menu
};

/**
 * Alarm sub-menu.
 * The length of menu title must be seven characters long (add spaces to the end)!
 *
 * @author Peter Ivanov
 */
menuPoint_t setAlarmMenu[] =
{
    //1234567   sub-menu        callback function
    {"HOUR   ", NULL,           &setAlarmHour},
    {"MINUTE ", NULL,           &setAlarmMin},
    {"ON/OFF ", NULL,           &setAlarmOnOff},
    {NULL,      NULL,           NULL}   // end of menu
};

/**
 * RF test sub-menu. This menu is for test MOD-NRF24Lx.
 * The length of menu title must be seven characters long (add spaces to the end)
 *
 * @author Peter Ivanov
 */
menuPoint_t rfTestMenu[] =
{
    //1234567   sub-menu        callback function
    {"MASTER ", NULL,           &rf24lMasterTest},
    {"SLAVE  ", NULL,           &rf24lSlaveTest},
    {NULL,      NULL,           NULL}   // end of menu
};

/**
 * Root menu. 
 * The length of menu title must be seven characters long (add spaces to the end)!
 *
 * @author Peter Ivanov
 */
menuPoint_t rootMenu[] = 
{
    //1234567   sub-menu        callback function
#ifdef NRF24L01
    {"RF TEST", rfTestMenu,     NULL},
#endif
    {"SET CLK", setClockMenu,   NULL},
    {"SET ALM", setAlarmMenu,   NULL},
    {NULL,      NULL,           NULL}   // end of menu
};

/**
 * Initialize system.
 *
 * @author Peter Ivanov and others
 */
void init ()
{
    WDTCTL = WDTPW | WDTHOLD;                       // stop watchdog timer

    FLL_CTL0 &= ~XTS_FLL;                           // XT1 as low-frequency
    // !!!!!!!!!!!
    FLL_CTL0 = XCAP18PF;                            // set load capacitance for 32k xtal
    // !!!!!!!!!!!

    _BIC_SR (OSCOFF);                               // turn on XT1 oscillator

    do                                              // wait in loop until crystal is stable
    {
        IFG1 &= ~OFIFG;
    }
    while (IFG1 & OFIFG);

    FLL_CTL1 &= ~FLL_DIV0;                          // ACLK = XT1
    FLL_CTL1 &= ~FLL_DIV1;

    IFG1 &= ~OFIFG;                                 // clear osc. fault int. flag

    FLL_CTL1 &= ~SELM0;                             // set DCO as MCLK
    FLL_CTL1 &= ~SELM1;

//  SVSCTL = 0x68;                                  //brown out

//  WDTCTL = WDTPW + WDTHOLD;                       // Stop watchdog timer

//  SCFI0 = BIT2 | BIT3 | BIT4 | BIT5 | BIT6 | BIT7;    
//  SCFI0 |= FN_4;                                  // x2 DCO frequency, 8MHz nominal DCO
//  SCFQCTL = SCFQ_1M;            

//  FLL_CTL0 = /*DCOPLUS + */XCAP10PF;                  //Set load Cap. for Cristal = 10pF
// x2 DCO frequency, 8MHz nominal DCO    

//  FLL_CTL1 |= SELM_XT2;                             //Select XT2 for CPU MCLK
//  SCFI1 = 0;
//  SCFQCTL = SCFQ_M | SCFQ_1M;                       //M=1, 1Mhz
//  _BIS_SR(SCG0+SCG1);                               //disable DCO in status_reg
//  delayX(200);

    UART_init ();
    UART_printf (
            "\r\n"
            "\r\n"
            "MSP430-449STK2 board started\r\n"
            "Compiled on " __DATE__ " " __TIME__ "\r\n"
            "\r\n"
            );
    LCD_init ();

    // Initialize IO port
    P1SEL = BIT5;                                             //p1.5 is 32768Hz
    P1DIR = BIT5 | BIT3 | BIT0 | BIT2;                        //BUZ,LED are outputs

    LCD_all ();                                               // turn on all LCD segments
#ifdef SIZE_OPTIMIZED
    sound (100, 100);        // if the code is optimized with -Os switch
#else
    sound (2000, 100);    // if the code is optimized with -O3 switch
#endif
    setStatusLed (TRUE);
    delayX (TEST_DELAY);
    setStatusLed (FALSE);
    delayX (TEST_DELAY);
    setStatusLed (TRUE);
    delayX (TEST_DELAY);
    setStatusLed (FALSE);
    LCD_clear ();
    
#if 0
    LCD_writeLetter (0, ':'); // olimex
    LCD_printf (" rulez");
    delayX (TEST_DELAY * 2);
    LCD_clear ();
#endif

    LCD_clearArrows (LCD_ARROW_LEFT | LCD_ARROW_UP | LCD_ARROW_DOWN);
    LCD_showArrows (LCD_ARROW_RIGHT);

    setTime (0x12, 0, 0, 0); // initialize time to 12:00:00 AM
    //setDate (2007, JANUARY, 1);
    RTC_init ();
    updateDisplay ();

    MENU_init (rootMenu);

    buttonStatusPrev = ~(P3IN & BTN_MASK);
}

/**
 * Main (end-less) loop.
 *
 * @author Peter Ivanov
 */
void run ()
{
    while (1)
    {
        buttonHandler ();
        if (buttonPressed)
        {
            if (menuOn)
            {
                MENU_handler (buttonPressed);
                if (currentMenuLevel == -1)
                {
                    menuOn = FALSE;
                    LCD_clearClock ();
                    updateDisplay ();
                }
            }
            else
            {
                if (buttonPressed == BTN_OK)
                {
                    menuOn = TRUE;
                    updateDisplay ();
                    MENU_handler (buttonPressed);
                }
            }
        }
        if (UART_getCharIsReady ()) 
        {
            uint8_t c = UART_getChar ();
            UART_putChar (c); //echo
            if (c == '\r')           // CR
            {
                UART_putChar ('\n'); // LF
                // TODO: parser!
            }
        }
        //while ((DALLAS) == 0) testBuzzer ();                            //test DALLAS button
    }
}

/**
 * Entry point of the program.
 *
 * @author Peter Ivanov
 */
int main (void)
{
    init ();
    run ();
    return 0;
}
/**
 * @mainpage
 * This is an example project for the MSP430-449STK2 development board,
 * which is produced by Olimex Ltd. I've used Linux, but maybe you can use any
 * operating system which has GNU make and mspgcc (http://mspgcc.sourceforge.net/).
 * The code is from Olimex, Muneem Shahriar and me.
 *
 * Features:
 * - Clock and alarm functions
 * - Simple menu system:
 *   MENU_handler()
 * - LCD handling. Writing text to display with printf:
 *   LCD_printf()
 * - UART (RS232) handling. Writing text to the serial line with printf:
 *   UART_printf()
 * - MOD-NRF24Lx extension board handling: NRF_send() NRF_receive() <br>
 *   You should connect P3.0 to CSN, P3.1 to MOSI, P3.2 to MISO, P3.3 to CLK and P1.6 to CE using 
 *   the EXT connector of MSP430-449STK2.
 * 
 * Quick how-to for make:
 *  - Type <code>make</code> to compile the code.
 *  - Type <code>make flash</code> to flash program to the MSP430's ROM.
 *  - Type <code>make doc</code> to generate documentation.
 *
 * You can download this sample here:
 * http://dev.ivanov.eu/projects/msp430-449stk2_sample/msp430-449stk2_sample.tar.gz
 * http://dev.ivanov.eu/projects/msp430-449stk2_sample/msp430-449stk2_sample.zip
 *
 * Contact: Peter Ivanov 
 * E-mail: ivanovp__AT__gmail__DOT__com__NOSPAM
 */

---