keyboard.h

Go to the documentation of this file.

// keyboard.h

#define KEYBOARD_WITH_PRESSED   
#define KEYBOARD_WITH_REPEAT    
#define KEYBOARD_WITH_LONG      
#define KEYBOARD_WITH_RELEASE   
#define KEYBUFSIZE      16      

static const uint8_t    KEY_REPEAT_DELAY=60;    
static const uint8_t    KEY_REPEAT_RATE=5;      
static const uint8_t    KEY_ACTION_MASK=0xc0;   
static const uint8_t    KEY_PRESSED=0;          
static const uint8_t    KEY_REPEAT=0x40;        
static const uint8_t    KEY_PRESSED_LONG=0x80;  
static const uint8_t    KEY_RELEASED=0xc0;      

typedef uint8_t KEY_CHAR_t;

extern KEY_CHAR_t   GetKey(void);

extern volatile unsigned char keyPressed;
extern volatile uint8_t keyboardLocked;

#define KEYSCANPORT     PORTB
#define KEYSCANDDR      DDRB
#define KEYRETPORT      PORTA
#define KEYRETPIN       PINA
#define KEYRETDDR       DDRA
#define KEY_SCANLINES       3   
#define KEY_RETLINES        4   
#define ROTPORT         PORTD
#define ROTPIN          PIND
#define ROTBUTTON       (PIND & (1<<PIND5))

/*  Definition of Key-Names.

    Caution: We use the two upper bits of a Key to
    indicate KEY_PRESS, KEY_PRESSED_LONG and KEY_RELEASE,
    so all key codes must be below 0x40!
*/
#define KEY_INVALID 1   
#define KEY_ENTER   2   
#define KEY_CANCEL  3   
#define KEY_ROTUP   4   
#define KEY_ROTDOWN 5   
#define KEY_NONE    6   

/*  Definition of Putkey-Return-Values */
typedef enum {
    PUTKEY_DONE,                    
    PUTKEY_ERROR_BUFFER_FULL,       
    PUTKEY_ERROR_KEYBOARD_LOCKED    
    } PutCharReturn_t;

extern uint8_t  bufReadPtr,bufWritePtr;

static inline bool  keyStat(void)
{
    return bufReadPtr!=bufWritePtr;
}

extern uint8_t  keynum;

static inline void InitKeyboard()
{
KEYSCANDDR|=0b00000111; // scan lines are output, other input
KEYSCANPORT|=0b00000110;    // and set only first scanline low
KEYRETPORT|=0b00001111; // enable pullups at return lines
ROTPIN &= 0b11100111;   // set rotary pins as input...
ROTPORT|=0b00011000;    // ...with pullup
keynum=9;   // no key
}

extern uint8_t  rot,lastRot,rotButton,lastRotButton;
extern const char   rotMatrix[16];
extern PutCharReturn_t  PutKey(KEY_CHAR_t c);

static inline void  scanRotaryEncoder(void)
{
    uint8_t rotIndex;
    
    rot=(ROTPIN & 0b00011000) >> 3;
    rotIndex=rot | (lastRot<<2);
    char    rotChar=pgm_read_byte(&(rotMatrix[rotIndex]));
    if (rotChar!=0)
    {
        PutKey(rotChar);
    }
    lastRot=rot;
    rotButton=ROTBUTTON;
    if (rotButton!=lastRotButton)
    {
        if (rotButton==0)
        {
            PutKey(KEY_ENTER);
        }
    lastRotButton=rotButton;
    }
}

extern uint8_t  scancnt;
extern uint8_t  keyTimer[KEY_RETLINES*KEY_SCANLINES];
extern const char       decodeMatrix[];
extern uint8_t  repeatRateCnt;

static inline void scanKeyboard()
{
unsigned char i;
char    c;

/* The following switch() is hardware dependant and converts
the active return line into a number bewteen 0 and KEY_RETLINES
or 255 if no or more than one key is pressed */
switch(KEYRETPIN&0x0f) {
    case 0x0f:  keynum=255; // All lines high, no key is pressed
            break;
    case 0x0e:  keynum=0;
            break;
    case 0x0d:  keynum=1;
            break;
    case 0x0b:  keynum=2;
            break;
    case 0x07:  keynum=3;
            break;
    default:    keynum=255; // more than one key pressed. We treat this as if no key is pressed.
    }
if (keynum<KEY_RETLINES) {  // a key is pressed
    keynum+=scancnt<<2; // add the value of the current scan line
    c=pgm_read_byte(&(decodeMatrix[keynum]));
    if (keyTimer[keynum]==0) {  // key has just been pressed
        PutKey(c|KEY_PRESSED);
    }
    if (keyTimer[keynum]<KEY_REPEAT_DELAY)
        {
            keyTimer[keynum]++;
        }  else
        if (keyTimer[keynum]<=KEY_REPEAT_DELAY)
        {
            keyTimer[keynum]++;
#ifdef KEYBOARD_WITH_LONG
            PutKey(c|KEY_PRESSED_LONG);
#endif
        } else
        {
            {
#ifdef KEYBOARD_WITH_REPEAT
                repeatRateCnt++;
                if (repeatRateCnt>=KEY_REPEAT_RATE)
                {
                    repeatRateCnt=0;
                    PutKey(c|KEY_REPEAT);
                }
#endif
            }
        }
    }
else if (keynum==255) {
    for (i=scancnt<<2;i<(scancnt<<2)+KEY_RETLINES;i++)
        {
#ifdef KEYBOARD_WITH_RELEASE
            if (keyTimer[i])
            {
                c=pgm_read_byte(&(decodeMatrix[i]));
                PutKey(c|KEY_RELEASED);
            }
#endif
            keyTimer[i]=0;
        }
    }
scancnt++;
if (scancnt>=KEY_SCANLINES)
    scancnt=0;
/* The following lines are hardware dependant and set all
scan lines high and the active one low. */
KEYSCANPORT|=0b00000111;    // all scanlines high
KEYSCANPORT&=~(0b00000001<<scancnt);    // active scanline low
}