/* (C) 2005 by Richard West (rw88@cornell.edu)
 * Published: 25 Feb 2005
 * Updated:   30 Jan 2006
 * Published under GNU General Public License - http://www.linux.org/info/gnu.html
 *
 * Keypad Function Definition File
 * (see keypad.h for documentation)
 *
 * Hardware setup notes:
 *      Keypad connected to Portx.0-7 (see note 2 in header)
 */

#ifndef _KEYPAD_C_
#define _KEYPAD_C_

#ifdef KEYPAD_USEDISPLAY
    #ifdef DISPLAY_USEPORTA
    #asm(".equ __lcd_port=0x1B")
    #elif defined DISPLAY_USEPORTB
    #asm(".equ __lcd_port=0x18")
    #elif defined DISPLAY_USEPORTC
    #asm(".equ __lcd_port=0x15")
    #elif defined DISPLAY_USEPORTD
    #asm(".equ __lcd_port=0x12")
    #else
    #error Keypad library - Please specify which port to use for the display.
    #endif
#include <lcd.h> // lcd library
#include <stdio.h> // for sprintf()
#endif

// keypad states
#define KEY_RELEASE 0x00
#define KEY_DEBOUNCE_DOWN 0x01
#define KEY_PRESSED 0x02
#define KEY_DEBOUNCE_UP 0x03
#define KEY_DONE 0x04

// "private" keypad runtime global variables
unsigned char keymode;
unsigned char keycount;
unsigned char keymaybe;
unsigned char keyterminate;
// only compile if using display
#ifdef KEYPAD_USEDISPLAY
unsigned char keydisplay;
unsigned char keyposx;
unsigned char keyposy;
unsigned char keylcd_buffer[2];
#endif
// only compile if using keypad keyboard
#ifdef KEYPAD_KEYBOARD
unsigned char keycapslock;
unsigned char keytableoffset;
#endif

// if using a telephone style keypad
#ifdef KEYPAD_TELPAD
#define KEY_TABLE_LENGTH 16
unsigned char keysymbol_table[16] = {'1', '2', '3', 'A',
                                     '4', '5', '6', 'B',
                                     '7', '8', '9', 'C',
                                     '*', '0', '#', 'D'};
flash unsigned char keycode_table[16] = {0xEE, 0xDE, 0xBE, 0x7E,
                                         0xED, 0xDD, 0xBD, 0x7D,
                                         0xEB, 0xDB, 0xBB, 0x7B,
                                         0xE7, 0xD7, 0xB7, 0x77};

// if using a hexadecimal style keypad
#elif defined KEYPAD_HEXPAD
#define KEY_TABLE_LENGTH 16
unsigned char keysymbol_table[16] = {'1', '2', '3', 'A',
                                     '4', '5', '6', 'B',
                                     '7', '8', '9', 'C',
                                     '0', 'F', 'E', 'D'};
flash unsigned char keycode_table[16] = {0xEE, 0xED, 0xEB, 0xE7,
                                         0xDE, 0xDD, 0xDB, 0xD7,
                                         0xBE, 0xBD, 0xBB, 0xB7,
                                         0x7E, 0x7D, 0x7B, 0x77};

// if wanting to use a telephone style keypad as a keyboard
#elif defined KEYPAD_KEYBOARD
#define KEY_TABLE_LENGTH 80

/*
0xFF symbol represent ignored button or button combination
0xFE symbol represents shift A
0xFD symbol represents shift B
0xFC symbol represents shift C
0xFB symbol represents shift D
0xFA symbol represents the caps-lock toggle
0xF9 symbol represents the delete key
0xF8 symbol represents the clear key
0x27 symbol represents single quote (escape char has problems with CodevisionAVR)
*/
unsigned char keysymbol_table[80] = {'1', '2', '3', 0xFE, // none pushed
                                     '4', '5', '6', 0xFD,
                                     '7', '8', '9', 0xFC,
                                     '*', '0', '\0', 0xFB,
                                     '!', 'a', 'd', 0xFF, // A pushed
                                     'g', 'j', 'm', 0xFA,
                                     'p', 't', 'w', 0xF9,
                                     '.', ' ', ',', 0xF8,
                                     '?', 'b', 'e', 0xFA, // B pushed
                                     'h', 'k', 'n', 0xFF,
                                     'q', 'u', 'x', 0xFF,
                                     '+', '(', ';', 0xFF,
                                     0x27, 'c', 'f', 0xF9, // C pushed
                                     'i', 'l', 'o', 0xFF,
                                     'r', 'v', 'y', 0xFF,
                                     '-', ')', ':', 0xFF,
                                     '"', '@', '#', 0xF8, // D pushed
                                     '$', '%', '^', 0xFF,
                                     's', '&', 'z', 0xFF,
                                     '/', '<', '>', 0xFF};
flash unsigned char keycode_table[80] = {0xEE, 0xDE, 0xBE, 0x7E, // none pushed
                                         0xED, 0xDD, 0xBD, 0x7D,
                                         0xEB, 0xDB, 0xBB, 0x7B,
                                         0xE7, 0xD7, 0xB7, 0x77,
                                         0x6E, 0x5E, 0x3E, 0x7E, // A pushed
                                         0x6C, 0x5C, 0x3C, 0x7C,
                                         0x6A, 0x5A, 0x3A, 0x7A,
                                         0x66, 0x56, 0x36, 0x76,
                                         0x6C, 0x5C, 0x3C, 0x7C, // B pushed
                                         0x6D, 0x5D, 0x3D, 0x7D,
                                         0x69, 0x59, 0x39, 0x79,
                                         0x65, 0x55, 0x35, 0x75,
                                         0x6A, 0x5A, 0x3A, 0x7A, // C pushed
                                         0x69, 0x59, 0x39, 0x79,
                                         0x6B, 0x5B, 0x3B, 0x7B,
                                         0x63, 0x53, 0x33, 0x73,
                                         0x66, 0x56, 0x36, 0x76, // D pushed
                                         0x65, 0x55, 0x35, 0x75,
                                         0x63, 0x53, 0x33, 0x73,
                                         0x67, 0x57, 0x37, 0x77};

// if using a user defined keypad
#elif defined KEYPAD_USERDEF
#define KEY_TABLE_LENGTH 16

#else
#error Keypad library - Please specify the style of keypad you wish to use.
#endif

// "private" function prototypes
unsigned char keypad_scan(void);
unsigned char keypad_lookup(unsigned char keycode);

void keypad_map_keysymbol(unsigned char old_keysymbol, unsigned char new_keysymbol)
{
    unsigned char i;

    // loop through entire table
    for (i=0; i<KEY_TABLE_LENGTH; i++)
    {
        // lookup old keysymbol
        if (keysymbol_table[i] == old_keysymbol)
        {
            // map new keysymbol
            keysymbol_table[i] = new_keysymbol;

            // break loop execution
            break;
        }
    }
}

void keypad_define_terminator(unsigned char keysymbol)
{
    // map keysymbol to '\0'
    keypad_map_keysymbol(keysymbol, '\0');
}

void keypad_ignore_keysymbol(unsigned char keysymbol)
{
    // map keysymbol to 0xFF
    keypad_map_keysymbol(keysymbol, 0xFF);
}

// only compile if using display
#ifdef KEYPAD_USEDISPLAY
void keypad_set_display(unsigned char display)
{
    // set keydisplay
    keydisplay = display;
}

void keypad_gotoxy(unsigned char x, unsigned char y)
{
    // set position of display
    keyposx = x;
    keyposy = y;
}
#endif

unsigned char keypad_scan(void)
{
    unsigned char keycode;

    // only compile if using PORTA
    #ifdef KEYPAD_USEPORTA
    #define KEYPAD_PORT PORTA
    #define KEYPAD_PIN PINA
    #define KEYPAD_DDR DDRA

    // only compile if using PORTB
    #elif defined KEYPAD_USEPORTB
    #define KEYPAD_PORT PORTB
    #define KEYPAD_PIN PINB
    #define KEYPAD_DDR DDRB

    // only compile if using PORTC
    #elif defined KEYPAD_USEPORTC
    #define KEYPAD_PORT PORTC
    #define KEYPAD_PIN PINC
    #define KEYPAD_DDR DDRC

    // only compile if using PORTD
    #elif defined KEYPAD_USEPORTD
    #define KEYPAD_PORT PORTD
    #define KEYPAD_PIN PIND
    #define KEYPAD_DDR DDRD

    #else
    #error Keypad library - Please specify which port to use for the keypad.
    #endif

    // get lower nibble
    KEYPAD_DDR = 0x0F;
    KEYPAD_PORT = 0xF0;
    #asm
    push r16
    ldi r16, 235
    L1: inc r16
    brne L1
    pop r16
    #endasm
    keycode = KEYPAD_PIN;

    // get upper nibble
    KEYPAD_DDR = 0xF0;
    KEYPAD_PORT = 0x0F;
    #asm
    push r16
    ldi r16, 235
    L2: inc r16
    brne L2
    pop r16
    #endasm
    keycode |= KEYPAD_PIN;

    // return keycode
    return keycode;
}

unsigned char keypad_lookup(unsigned char keycode)
{
    unsigned char i;
    unsigned char keysymbol = 0xFF; // default is invalid

    // check for keycode
    if (keycode != 0xFF)
    {
        // compile default code unless using keypad as keyboard
        #ifndef KEYPAD_KEYBOARD
        // loop through entire table
        for (i=0; i<KEY_TABLE_LENGTH; i++)
        {
            // lookup keycode
            if (keycode_table[i] == keycode)
            {
                // lookup keysymbol
                keysymbol = keysymbol_table[i];
                break;
            }
        }
        #else
        // loop through select portion of table
        for (i=keytableoffset; i<(keytableoffset+16); i++)
        {
            // lookup keycode
            if (keycode_table[i] == keycode)
            {
                // lookup keysymbol
                keysymbol = keysymbol_table[i];
                break;
            }
        }
        #endif
    }

    // return keysymbol, 0xFF if invalid
    return keysymbol;
}

void keypad_get_string(void)
{
    unsigned char keycode;
    unsigned char keysymbol;

    // scan keypad for keycode
    keycode = keypad_scan();

    if (keymode == KEY_RELEASE)
    {
        // check for keycode
        if (keycode != 0xFF)
        {
            keymaybe = keycode;
            keymode = KEY_DEBOUNCE_DOWN;
        }
        // only compile if using keypad keyboard
        #ifdef KEYPAD_KEYBOARD
        else
        {
            // reset keytableoffset
            keytableoffset = 0;
        }
        #endif
    }
    else if (keymode == KEY_DEBOUNCE_DOWN)
    {
        // check for keycode match
        if (keycode == keymaybe)
        {
            // lookup keysymbol based on keycode
            keysymbol = keypad_lookup(keycode);

            // check for terminator
            if (keysymbol == '\0')
            {
                // terminate key string and signal terminator
                keystring[keycount] = '\0';
                keyterminate = 0x01;
            }
            else if (keysymbol < 0xF0)
            {
                // only compile if using keypad keyboard
                #ifdef KEYPAD_KEYBOARD
                if ((keycapslock == 0x01) && ('a' <= keysymbol) && (keysymbol <= 'z'))
                {
                    // convert lower to upper
                    keysymbol -= 0x20;
                }
                #endif

                // only compile if using display
                #ifdef KEYPAD_USEDISPLAY
                // check display mode
                if (keydisplay == KEYPAD_ECHODISPLAY)
                {
                    // display keysymbol
                    sprintf(keylcd_buffer, "%c", keysymbol);
                    lcd_gotoxy(keyposx, keyposy);
                    lcd_puts(keylcd_buffer);

                    // increment position
                    keyposx++;
                }
                else if (keydisplay == KEYPAD_MASKDISPLAY)
                {
                    // display masked keysymbol
                    lcd_gotoxy(keyposx, keyposy);
                    lcd_putsf("*");

                    // increment position
                    keyposx++;
                }
                #endif

                // add keysymbol to keystring and increment keycount
                keystring[keycount++] = keysymbol;
            }
            // else invalid/ignored/special keycode/keysymbol

            // only compile if keypad keyboard
            #ifdef KEYPAD_KEYBOARD
            // check for special symbols
            if (keysymbol == 0xFE) // shift A
            {
                keytableoffset = 16;
            }
            else if (keysymbol == 0xFD) // shift B
            {
                keytableoffset = 32;
            }
            else if (keysymbol == 0xFC) // shift C
            {
                keytableoffset = 48;
            }
            else if (keysymbol == 0xFB) // shift D
            {
                keytableoffset = 64;
            }
            else if (keysymbol == 0xFA) // capslock
            {
                // toggle capslock
                keycapslock ^= 0x01;
            }
            else if (keysymbol == 0xF9) // delete
            {
                if (keycount) {
                    // decrement keycount
                    keycount--;

                    // only compile if using the display
                    #ifdef KEYPAD_USEDISPLAY
                    if (keydisplay != KEYPAD_NODISPLAY) {
                        // decrement position and "erases" character
                        keyposx--;
                        lcd_gotoxy(keyposx, keyposy);
                        lcd_putsf(" ");
                    }
                    #endif
                }
            }
            else if (keysymbol == 0xF8) // clear
            {
                // only compile if using the display
                #ifdef KEYPAD_USEDISPLAY
                if (keydisplay != KEYPAD_NODISPLAY) {
                    // decrement position and "erases" character
                    while(keycount) {
                        keyposx--;
                        lcd_gotoxy(keyposx, keyposy);
                        lcd_putsf(" ");
                        keycount--;
                    }
                }
                #else
                // reset keycount
                keycount = 0;
                #endif
            }
            #endif

            keymode = KEY_PRESSED;
        }
        else
        {
            keymode = KEY_RELEASE;
        }
    }
    else if (keymode == KEY_PRESSED)
    {
        // check for keycode mismatch
        if (keycode != keymaybe)
        {
            keymode = KEY_DEBOUNCE_UP;
        }
    }
    else if (keymode == KEY_DEBOUNCE_UP)
    {
        // check for keycode match
        if (keycode == keymaybe)
        {
            keymode = KEY_PRESSED;
        }
        else
        {
            // check if terminator was pushed
            if (keyterminate != 0x01)
            {
                // release for next button
                keymode = KEY_RELEASE;
            }
            else
            {
                // signal ready
                keystring_ready = 0x01;

                // suspend keypad state machine
                keymode = KEY_DONE;
            }
        }
    }
}

void keypad_release(void)
{
    // reset keypad variables
    keycount = 0x00;
    keystring_ready = 0x00;
    keystring[0] = '\0';
    keyterminate = 0x00;

    // compile only if using keypad keyboard
    #ifdef KEYPAD_KEYBOARD
    // reset capslock
    keycapslock = 0x00;
    keytableoffset = 0;
    #endif

    // restart keypad state machine
    keymode = KEY_RELEASE;
}
#endif