#include"config.h"
#include"key.h"

/*
*********************************************************************************************************
*                                            LOCAL CONSTANTS
*********************************************************************************************************
*/

#define KEY_STATE_UP                 1      								/* Key scanning states used in KeyScan()*/
#define KEY_STATE_DEBOUNCE           2
#define KEY_STATE_RPT_START_DLY      3
#define KEY_STATE_RPT_DLY            4

static uint8 KeyBuf[KEY_BUF_SIZE];
static uint8 KeyBufInIx;
static uint8 KeyBufOutIx;
static volatile uint8 KeyNRead;

static uint16 KeyDownTmr;
static uint8  KeyRptStartDlyCtr;
static uint8  KeyRptDlyCtr;

static uint8  KeyScanState;

#if USE_RTOS

static  OS_STK    KeyScanTaskStk[KEY_SCAN_TASK_STK_SIZE];  	/* Keyboard scanning task stack		*/
static  OS_EVENT *KeySemPtr;                               	/* Pointer to keyboard semaphore	*/
static  void      KeyScanTask(void *data);				/* Keyboard scanning task			*/

#else
static volatile uint16  KeyWaitTime;
#endif

/*
*********************************************************************************************************
*                                       LOCAL FUNCTION PROTOTYPES
*********************************************************************************************************
*/

static  void      KeyBufIn(uint8 icode);     			/* Insert scan code into keyboard buffer	*/
static  uint8     KeyBufOut(void);
static  uint8     KeyDecode(void);          			/* Get scan code from current key pressed	*/
static  boolean   KeyIsKeyDown(void);       			/* See if key has been pressed			*/


static  void  KeyBufIn(uint8 icode)
{
    ENTRY_CRITICAL();
    if (KeyNRead<KEY_BUF_SIZE)
    {
        KeyNRead++;
        KeyBuf[KeyBufInIx++]=icode;
        if (KeyBufInIx>=KEY_BUF_SIZE)
            KeyBufInIx=0;
        EXIT_CRITICAL();
#if USE_RTOS
        OSSemPost(KeySemPtr);
#endif
    }
    else
    {
        EXIT_CRITICAL();
    }
}

static uint8 KeyDecode(void)
{
    uint8 row;
    uint8 col;
    uint8 col_id;
    uint8 offset;
    uint8 msk;
    boolean done;

    row=0;
    done=false;
    while ((row<KEY_MAX_ROWS)&&(!done))
    {
        KeySelRow(row);
        if (KeyIsKeyDown())
        {
            done=true;
        }
        else
        {
            row++;
        }
    }

    offset=0;
    col=KeyGetCol();
    if (col&KEY_SHIFT1_MSK)
        offset+=KEY_SHIFT1_OFFSET;
    if (col&KEY_SHIFT2_MSK)
        offset+=KEY_SHIFT2_OFFSET;
    if (col&KEY_SHIFT3_MSK)
        offset+=KEY_SHIFT3_OFFSET;

    col_id=0;
    done=false;
    msk=0x01;
    while ((col_id<KEY_MAX_COLS)&&(!done))
    {
        if (col&msk)
        {
            done=true;
        }
        else
        {
            col_id++;
            msk<<=1;
        }
    }

    return (row*KEY_MAX_COLS+offset+col_id);
}

void KeyFlush(void)
{
    while (KeyHit())
    {
        KeyGetKey(0);
    }
}

boolean KeyHit(void)
{
    boolean hit;
    ENTRY_CRITICAL();
    hit=(boolean)((KeyNRead>0)?true:false);
    EXIT_CRITICAL();
    return hit;
}

static uint8 KeyBufOut(void)
{
    uint8 retkey=KEY_NO_KEY;

    ENTRY_CRITICAL();
    if (KeyNRead>0)
    {
        KeyNRead--;
        retkey=KeyBuf[KeyBufOutIx++];
        if (KeyBufOutIx>=KEY_BUF_SIZE)
            KeyBufOutIx=0;
    }
    EXIT_CRITICAL();
    return retkey;
}

uint8 KeyGetKey(uint16 to)
{
#if USE_RTOS
    uint8 err;
    OSSemPend(KeySemPtr,to,&err);
#else
    if (KeyNRead==0)
    {
        KeyWaitTime=to/KEY_SCAN_TASK_DLY+1;
        while ((KeyWaitTime>0)&&(KeyNRead==0));
    }
#endif
    return KeyBufOut();
}


uint32 KeyGetKeyDownTime(void)
{
    uint32 tmr;
    ENTRY_CRITICAL();
    tmr=KeyDownTmr;
    EXIT_CRITICAL();
    return (tmr*KEY_SCAN_TASK_DLY);
}

void KeyInit(void)
{
    KeyScanState=KEY_STATE_UP;
    KeyBufOutIx=0;
    KeyBufInIx=0;
    KeyNRead=0;
    KeyDownTmr=0;

#if USE_RTOS
    KeySemPtr=OSSemCreate(0);
#if OS_STK_GROWTH>0
    OSTaskCreate(KeyScanTask,(void*)0,&KeyScanTaskStk[KEY_SCAN_TASK_STK_SIZE],KEY_SCAN);
#else
    OSTaskCreate(KeyScanTask,(void*)0,&KeyScanTaskStk[0],KEY_SCAN);
#endif
#else
    KeyWaitTime=0;
#endif

    KeyInitPort();
    KeySelRow(KEY_ALL_ROWS);

}

static boolean KeyIsKeyDown(void)
{
    if (KeyGetCol()&((1<<KEY_MAX_COLS)-1))
    {
        ENTRY_CRITICAL();
        KeyDownTmr++;
        EXIT_CRITICAL();
        return true;
    }
    else
        return false;
}



#if USE_RTOS
static void KeyScanTask(void *ddata)
#else
void KeyScanTask(void)
#endif
{
    uint8 icode;
#if USE_RTOS
    ddata=ddata;
    for (;;)
    {
        OSTimeDly(KEY_SCAN_TASK_DLY);
#endif
        switch (KeyScanState)
        {
        case KEY_STATE_UP:
            if (KeyIsKeyDown())
            {
                KeyScanState=KEY_STATE_DEBOUNCE;
                KeyDownTmr=0;
            }
            break;
        case KEY_STATE_DEBOUNCE:
            if (KeyIsKeyDown())
            {
                icode=KeyDecode();
                KeyBufIn(icode);
                KeyScanState=KEY_STATE_RPT_START_DLY;
                KeyRptStartDlyCtr=KEY_RPT_START_DLY;
            }
            else
            {
                KeySelRow(KEY_ALL_ROWS);
                KeyScanState=KEY_STATE_UP;
            }
            break;
        case KEY_STATE_RPT_START_DLY:
            if (KeyIsKeyDown())
            {
                KeyRptStartDlyCtr--;
                if (KeyRptStartDlyCtr==0)
                {
                    icode=KeyDecode();
                    KeyBufIn(icode);
                    KeyScanState=KEY_STATE_RPT_DLY;
                    KeyRptDlyCtr=KEY_RPT_DLY;
                }
            }
            else
            {
                KeyScanState=KEY_STATE_DEBOUNCE;
            }
            break;
        case KEY_STATE_RPT_DLY:
            if (KeyIsKeyDown())
            {
                KeyRptDlyCtr--;
                if (KeyRptDlyCtr==0)
                {
                    KeyRptDlyCtr=KEY_RPT_DLY;
                    icode=KeyDecode();
                    KeyBufIn(icode);
                }
            }
            else
            {
                KeyScanState=KEY_STATE_DEBOUNCE;
            }
            break;
        }

#if USE_RTOS
    }
#endif
}

void KeyInitPort(void) 		/*键盘硬件初始化					*/
{
    KEY_PORT_CW=0xFF;
}

uint8 KeyGetCol(void) 		/*获得键盘按下时的列值，某位为1时表示被按下*/
{
    uint8 col;
    col=KEY_PORT_COL;
    return ~(col>>KEY_MAX_ROWS);
}

void KeySelRow(uint8 row)		/*选择键盘的某一行，作为选择某行输出		*/
{
    if (row==KEY_ALL_ROWS)
        KEY_PORT_ROW=0x00;
    else
        KEY_PORT_ROW=~(1<<row);
}