Burglar alarm with keypad

#include <msp430g2452.h>

// Port 1 connections to the keypad.
#define KEY_BLACK  BIT0
#define KEY_WHITE  BIT1
#define KEY_GRAY   BIT2
#define KEY_VIOLET BIT3
#define KEY_ORANGE BIT4
#define KEY_BROWN  BIT5

// Port 2 connections to the keypad.
#define KEY_BLUE   BIT1
#define KEY_GREEN  BIT2
#define KEY_YELLOW BIT3
#define KEY_RED    BIT4

// Port 2 has LED status lights and reed switch.
#define REED_SWITCH BIT0
#define LED_GRN    BIT7
#define LED_RED    BIT6

// Port 1 has the piezo speaker.
#define SPEAKER0   BIT6
#define SPEAKER1   BIT7

#define NUM_KEYS   12
char key_symbol[NUM_KEYS] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '#' };
char key_pressed[NUM_KEYS] = { 0,0,0, 0,0,0, 0,0,0, 0,0,0 };
char key_pending[NUM_KEYS] = { 0,0,0, 0,0,0, 0,0,0, 0,0,0 };
char p1_color[NUM_KEYS] = { KEY_VIOLET, KEY_BLACK, KEY_BLACK, KEY_BLACK,
    KEY_WHITE, KEY_WHITE, KEY_WHITE, KEY_VIOLET, KEY_VIOLET, KEY_GRAY,
    KEY_ORANGE, KEY_BROWN };
char p2_color[NUM_KEYS] = { KEY_YELLOW, KEY_BLUE, KEY_GREEN, KEY_YELLOW,
    KEY_BLUE, KEY_GREEN, KEY_YELLOW, KEY_BLUE, KEY_GREEN, KEY_YELLOW,
    KEY_RED, KEY_RED };
volatile int clear_key_light = 0;

void main( void ) {
    // Stop the watchdog timer
    WDTCTL = WDTPW + WDTHOLD;

    // Set chip to calibrated 1mhz clock rate.
    BCSCTL1 = CALBC1_1MHZ;
    DCOCTL = CALDCO_1MHZ;

    // Set the auxiliary clock to use the VLO.  We'll use this to wake up
    // via the watchdog and scan for keypresses.
    BCSCTL3 |= LFXT1S_2;

    // Set all keys initially to low, but as output pins.
    P1OUT &= ~( KEY_BLACK + KEY_WHITE + KEY_GRAY  + KEY_VIOLET + KEY_ORANGE + KEY_BROWN );
    P1DIR |=    KEY_BLACK + KEY_WHITE + KEY_GRAY  + KEY_VIOLET + KEY_ORANGE + KEY_BROWN;

    // Set piezo leads to low, but as output pins.
    P1OUT &= ~( SPEAKER0 + SPEAKER1 );
    P1DIR |=    SPEAKER0 + SPEAKER1;

    // Set LED status lights off, but as output pins.
    P2SEL &= ~( LED_GRN + LED_RED );
    P2OUT &= ~( LED_GRN + LED_RED );
    P2DIR |=    LED_GRN + LED_RED;

    // Set pull down resistors on port 2 pins that monitor keypad.
    P2DIR &= ~( KEY_BLUE + KEY_GREEN + KEY_YELLOW + KEY_RED );
    P2OUT &= ~( KEY_BLUE + KEY_GREEN + KEY_YELLOW + KEY_RED );
    P2REN |=    KEY_BLUE + KEY_GREEN + KEY_YELLOW + KEY_RED;
    // Interrupt on rising edges.
    P2IES &= ~( KEY_BLUE + KEY_GREEN + KEY_YELLOW + KEY_RED );

    // Set pull up resistor on port 2 pin for reed switch.
    P2DIR &= ~( REED_SWITCH );
    P2OUT |=    REED_SWITCH;
    P2REN |=    REED_SWITCH;
    // Interrupt on falling edges.
    P2IES |=    REED_SWITCH;

    // Enable interrupts for all of the port 2 pins we monitor.
    P2IE |=     KEY_BLUE + KEY_GREEN + KEY_YELLOW + KEY_RED +
                REED_SWITCH;

    // Set watchdog timer to trigger every 16*32.768k/12k = 44 ms.
    WDTCTL = WDT_ADLY_16;
    // Clear the watchdog timer interrupt flag.
    IFG1 &= ~WDTIFG;
    // Enable watchdog interrupts.
    IE1 |= WDTIE;

    /* Do nothing...forever */
    for( ; ; ) {
        /* Go into low power mode 3, general interrupts enabled */
        __bis_SR_register( LPM3_bits + GIE );
    }
}

// Handle key pad symbols.
void do_key( char c ) {
    // Visually signify the press by blinking a light (the reset
    // happens in the watchdog handler).
    P2OUT ^= LED_GRN + LED_RED;
    clear_key_light = 1;
}

void WDT_ISR(void) __attribute__((interrupt(WDT_VECTOR)));
void WDT_ISR(void) {
    int i;

    if( clear_key_light ) {
        P2OUT ^= LED_GRN + LED_RED;
        clear_key_light = 0;
    }

    // Set interrupts on so Port 2 handler can trigger.
    __bis_SR_register( GIE );

    // Turn each wire on in turn to trigger an interrupt on port 2.
    P1OUT |= KEY_BLACK;
    asm( "nop \n\t" "nop \n\t" "nop \n\t" );
    P1OUT &= ~KEY_BLACK;

    P1OUT |= KEY_WHITE;
    asm( "nop \n\t" "nop \n\t" "nop \n\t" );
    P1OUT &= ~KEY_WHITE;

    P1OUT |= KEY_GRAY;
    asm( "nop \n\t" "nop \n\t" "nop \n\t" );
    P1OUT &= ~KEY_GRAY;

    P1OUT |= KEY_VIOLET;
    asm( "nop \n\t" "nop \n\t" "nop \n\t" );
    P1OUT &= ~KEY_VIOLET;

    P1OUT |= KEY_ORANGE;
    asm( "nop \n\t" "nop \n\t" "nop \n\t" );
    P1OUT &= ~KEY_ORANGE;

    P1OUT |= KEY_BROWN;
    asm( "nop \n\t" "nop \n\t" "nop \n\t" );
    P1OUT &= ~KEY_BROWN;

    // Decrement the counts in key_pending[] and record any key releases.
    for( i = 0; i < NUM_KEYS; i++ ) {
        if( key_pending[i] ) key_pending[i]--;
        if( !key_pending[i] ) key_pressed[i] = 0;
    }

    // Clear the watchdog timer interrupt flag.
    IFG1 &= ~WDTIFG;
}

/* Port 2 interrupt service routine.  Triggered by presses of
 * the keypad or by opening of the reed switch.
 */
void Port_2 (void) __attribute__((interrupt(PORT2_VECTOR)));
void Port_2(void) {
    int i;
    int mask = 0;

    for( i = 0; i < NUM_KEYS; i++ ) {
        if( P2IFG & p2_color[i] ) {     // Check if this color triggered the interrupt.
            mask |= p2_color[i];

            if( P1OUT & p1_color[i] ) { // Check if the other color for this key is also on.
                if( key_pending[i] && !key_pressed[i] ) {
                    key_pressed[i] = 1;

                    do_key( key_symbol[i] );
                }

                key_pending[i] = 2;     // Remember for next time.
            }
        }
    }
    // Clear interrupt flag.
    P2IFG &= ~mask;

    if( P2IFG & REED_SWITCH ) {
        P2IFG &= ~REED_SWITCH;
    }
}

$ msp430-gcc -O2 -mmcu=msp430g2452 -o keypad.elf keypad.c
$ mspdebug rf2500 "prog keypad.elf"