lcd_msg.c

Realtek 公司的RTD2523A芯片原厂source code,没有被修改过的。

#define __MESSAGE__

#include "Header\INCLUDE.H"


unsigned char GetKeyState(void)
{
    unsigned char ucKeyState    = 0;

#if (MCU_TYPE == MCU_STD8051)

#if (BOARD_TYPE == QA_PCB || BOARD_TYPE == DEMO_LVDS_A || KINGMICE)
    ucKeyState  = bPOWER_KEY ? P3 | (IR_KEY_MASK | POWER_KEY_MASK) : (P3 | IR_KEY_MASK) & (0xff ^ POWER_KEY_MASK);
#elif (BOARD_TYPE == DEMO1_PCB)
    ucKeyState  = bPOWER_KEY ? P1 | (IR_KEY_MASK | POWER_KEY_MASK) : (P1 | IR_KEY_MASK) & (0xff ^ POWER_KEY_MASK);
#else
//  ucKeyState  = (P3 & 0x78) | (P2 & 0x02) | IR_KEY_MASK;
    ucKeyState  = (P3 & 0x40) | (P1 & 0x1b) | IR_KEY_MASK;
#endif

#if (IRPOLLING)
    {
    //    unsigned char   ucIR_Curr;
        
        // You cannot respond to ucIR_Cmd[0] when IR command decoding (1 < ucIR_State).
        // Because ucIR_Cmd[0] is not a constant during command decoding.
        Data[0]   = (1 < ucIR_State) ? 0 : ucIR_Cmd[0];

        if (Data[0])
        {
            switch (Data[0])
            {
#if (POWER_KEY_TYPE == TYPE_ONE_TOUCH)
            // Only when power-key is one-touch style, you can use IR remote controller to switch power on/off
            case IR_POWER_KEY :     ucKeyState  &= (0xff ^ POWER_KEY_MASK);     break;
#endif
            // Use IR to implement standard key
            case IR_LEFT_KEY :      ucKeyState  &= (0xff ^ LEFT_KEY_MASK);      break;
            case IR_RIGHT_KEY :     ucKeyState  &= (0xff ^ RIGHT_KEY_MASK);     break;
            case IR_ENTER_KEY :     ucKeyState  &= (0xff ^ ENTER_KEY_MASK);     break;
            // Other IR function key
            default :        
                ucKeyState  &= (0xff ^ IR_KEY_MASK);

#if (TV_CHIP != TV_NONE)
                switch (Data[0])
                {
                case IR_FUNC_SOURCE :   Data[0] = NOTIFY_IR_SOURCE;     break;
                case IR_FUNC_DISP :     Data[0] = NOTIFY_IR_DISP;       break;
                case IR_FUNC_JUMP :     Data[0] = NOTIFY_IR_JUMP;       break;
                case IR_FUNC_CHDEC :    Data[0] = NOTIFY_IR_CHDEC;      break;
                case IR_FUNC_CHINC :    Data[0] = NOTIFY_IR_CHINC;      break;
                case IR_FUNC_VOLINC :   Data[0] = NOTIFY_IR_VOLINC;     break;
                case IR_FUNC_VOLDEC :   Data[0] = NOTIFY_IR_VOLDEC;     break;
                case IR_FUNC_MENU :     Data[0] = NOTIFY_IR_MENU;       break;
                case IR_FUNC_ENTER :    Data[0] = NOTIFY_IR_ENTER;      break;
                case IR_FUNC_MUTE :     Data[0] = NOTIFY_IR_MUTE;       break;
                case IR_FUNC_NUM0 :     Data[0] = NOTIFY_IR_NUM0;       break;
                case IR_FUNC_NUM1 :     Data[0] = NOTIFY_IR_NUM1;       break;
                case IR_FUNC_NUM2 :     Data[0] = NOTIFY_IR_NUM2;       break;
                case IR_FUNC_NUM3 :     Data[0] = NOTIFY_IR_NUM3;       break;
                case IR_FUNC_NUM4 :     Data[0] = NOTIFY_IR_NUM4;       break;
                case IR_FUNC_NUM5 :     Data[0] = NOTIFY_IR_NUM5;       break;
                case IR_FUNC_NUM6 :     Data[0] = NOTIFY_IR_NUM6;       break;
                case IR_FUNC_NUM7 :     Data[0] = NOTIFY_IR_NUM7;       break;
                case IR_FUNC_NUM8 :     Data[0] = NOTIFY_IR_NUM8;       break;
                case IR_FUNC_NUM9 :     Data[0] = NOTIFY_IR_NUM9;       break;
                default :               ucKeyState  |= IR_KEY_MASK;     break;
                }
#endif
                break;
            }
        }
    }
#endif
    
    return ((ucKeyState & ALL_KEY_MASK) | KEY_DISABLED) ^ ALL_KEY_MASK;

#else

    if (!bRIGHT_KEY)
        ucKeyState  = ucKeyState | RIGHT_KEY_MASK;
    if (!bLEFT_KEY)
        ucKeyState  = ucKeyState | LEFT_KEY_MASK;
    if (!bENTER_KEY)
        ucKeyState  = ucKeyState | ENTER_KEY_MASK;
    if (!bMENU_KEY)
        ucKeyState  = ucKeyState | MENU_KEY_MASK;
    if (!bPOWER_KEY)
        ucKeyState  = ucKeyState | POWER_KEY_MASK;

    return ucKeyState;

#endif
}

// Key_Trans() is used for generating key related messages, including OSD timout message.
// You can just issue the message or execute system default function, like changing input source.

// BE CAREFUL !! YOU CANNOT CHANGE ANY OSD STATUS REGISTERS OR CALL ANY OSD PROCESS HERE !!
// You should not expect OSD_Proc() can always receive your message.
// Because main program will shield OSD process from been triggered when input signal isn't stable,
// and terminate OSD process when input source is changed.
unsigned char Key_Trans()
{
    static unsigned char idata ucP3_Prev    = 0;
    static unsigned char idata ucP3_Curr    = 0;
    static unsigned char idata ucKey_Repeat = 0;
    static unsigned char idata ucKey_Issued = 0;

    unsigned char   ucNotify    = NOTIFY_NONE;

    // Save the previous key status
    ucP3_Prev   = ucP3_Curr;
    // Sample the current key status
    ucP3_Curr   = GetKeyState();

#if (POWER_KEY_TYPE == TYPE_TWO_STATE)

    // We MUST handle power-key first.
    if (bPower_Status)
    {
        if (ucP3_Curr & POWER_KEY_MASK)
            ucP3_Curr   ^= POWER_KEY_MASK;  // Go further to handle other keys (and mask power-key)
        else
        {
            Delay_Xms(20);

            ucP3_Prev   = ucP3_Curr;
            ucP3_Curr   = GetKeyState();

            if (ucP3_Curr & POWER_KEY_MASK)
                ucP3_Curr   ^= POWER_KEY_MASK;  // Go further to handle other keys (and mask power-key)
            else
                return  NOTIFY_POWERDOWN;
        }
    }
    else
    {
        if (ucP3_Curr & POWER_KEY_MASK)
        {
            ucKey_Issued    = 0;
            bKeyTurbo       = 0;

            Delay_Xms(20);

            ucP3_Prev   = ucP3_Curr;
            ucP3_Curr   = GetKeyState();

            if (ucP3_Curr & POWER_KEY_MASK)
                return NOTIFY_POWERUP;
            else
                return NOTIFY_NONE;
        }
        else
            return NOTIFY_NONE;
    }

#else   // POWER_KEY_TYPE is TYPE_ONE_TOUCH

    if (bPower_Status)
    {
        if (POWER_KEY_MASK & ucP3_Curr)
        {
            if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
            {
                Delay_Xms(20);

                ucP3_Curr   = GetKeyState();

                if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)   
                    return NOTIFY_POWERDOWN;
                else
                    return NOTIFY_NONE;
            }
        }

        // When an user presses power-key during auto-config
        if (bPowerDownWhenAuto)
        {
            bPowerDownWhenAuto  = 0;
            return NOTIFY_POWERDOWN;
        }
    }
    else
    {
        // Clear flag if already in power-down
        bPowerDownWhenAuto  = 0;

        if (POWER_KEY_MASK & ucP3_Curr)
        {
            if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
            {
                ucKey_Issued    = 0;
                bKeyTurbo       = 0;

                Delay_Xms(20);

                ucP3_Curr   = GetKeyState();

                if ((ucP3_Prev ^ ucP3_Curr) & POWER_KEY_MASK)
                    return NOTIFY_POWERUP;
                else
                    return NOTIFY_NONE;
            }
            else
                return NOTIFY_NONE;
        }
    }

#endif

    // Generate Key Messages
    switch (ucP3_Curr)
    {
    case MENU_KEY_MASK :
        if ((ucP3_Prev ^ ucP3_Curr) & MENU_KEY_MASK)
        {
            ucKey_Issued    = 0;
            bKeyTurbo       = 0;

            ucNotify        = NOTIFY_MENU_KEY;
        }
        break;
    
    case ENTER_KEY_MASK :

        if ((ucP3_Prev ^ ucP3_Curr) & ENTER_KEY_MASK)
        {
            ucKey_Issued    = 0;
            bKeyTurbo       = 0;

            ucNotify        = NOTIFY_ENTER_KEY;
            ucKey_Repeat    = KEY_REPEAT_COUNT * 8;
        }
        else
        {
            if (ucKey_Repeat)
                ucKey_Repeat    -= 1;
            else
            {
                if (Is_Main_OSD_Exist())
                {
                    ucNotify    = NOTIFY_RESET_OSD;
                }
            }
        }
        break;
    
    case RIGHT_KEY_MASK :
    case LEFT_KEY_MASK:
            
        if ((ucP3_Prev ^ ucP3_Curr) & ucP3_Curr)
        {
            ucKey_Issued    = 0;
            bKeyTurbo       = 0;

            ucNotify        = (ucP3_Curr == RIGHT_KEY_MASK) ? NOTIFY_RIGHT_KEY : NOTIFY_LEFT_KEY;  // Post right-key pressed message
            ucKey_Repeat    = KEY_REPEAT_COUNT;
        }
        else
        {
            if (ucKey_Repeat)
                ucKey_Repeat    -= 1;
            else
            {
                if (KEY_TURBO_ENABLE > ucKey_Issued)
                {
                    ucKey_Issued    += 1;
                    ucKey_Repeat    = KEY_REPEAT_PERIOD;
                }
                else
                {
                    bKeyTurbo       = 1;
                    ucKey_Repeat    = 0;
                }

                ucNotify        = (ucP3_Curr == RIGHT_KEY_MASK) ? NOTIFY_RIGHT_KEY : NOTIFY_LEFT_KEY;  // Post right-key repeat message
            }
        }
        break;

#if (IRPOLLING)

    case IR_KEY_MASK :

        ucKey_Issued    = 0;
        bKeyTurbo       = 0;

        if ((ucP3_Prev ^ ucP3_Curr) & IR_KEY_MASK)
        {
            // Post IR-key pressed message
            ucNotify        = Data[0];
            ucKey_Repeat    = KEY_REPEAT_COUNT;
        }
        else if (NOTIFY_IR_VOLINC == Data[0] || NOTIFY_IR_VOLDEC == Data[0])
        {
            if (ucKey_Repeat)
                ucKey_Repeat    -= 1;
            else
            {
                ucNotify        = Data[0];
                ucKey_Repeat    = KEY_REPEAT_PERIOD;
            }
        }
        break;
#endif
    
    default :

        // No key or more than 1 key pressed. Post no message and reset key-repeat.
        ucKey_Repeat    = KEY_REPEAT_COUNT;
        ucKey_Issued    = 0;
        bKeyTurbo       = 0;

#if (HIDDEN_PAGE)        
        // For triggering the hidden page
        if (!Is_Main_OSD_Exist() && (RIGHT_KEY_MASK | LEFT_KEY_MASK) == ucP3_Curr)     ucNotify    = NOTIFY_LR_KEY;
#endif
        break;
    }

    return ucNotify;
}