lg.c

M3355的源代码

    for (bGrid = 1; bGrid <= VFD_GRID_NUM; bGrid ++)
    {
        for (b = 0; b < VFD_SEG_NUM; b++)
        {
            LightTable[bGrid] &= ~(0x00000001 << b);/* turn off one element */
            VfdSetGrid(bGrid, LightTable[bGrid]);
            dly_tsk(100);
            LightTable[bGrid] = 0xffffffff;
        }
        VfdSetGrid(bGrid, LightTable[bGrid]);
    }

    /* Light ALL */
    VfdUpdate(LightTable);
    dly_tsk(300);
#endif

#if 1
    /******************************/
    /* Light LED                  */
    /******************************/
    PRINTF("\nLight LED\n");

    /* Light ALL LED */
    VfdSetLed(0xff);
    /* Light one LED */
    dly_tsk(300);
    for(b=0;b<5;b++)
    {
        VfdSetLed(0x01 << b);
        dly_tsk(200);
    }
    /* Light ALL LED */
    VfdSetLed(0xff);
#endif

#if 1
    /******************************/
    /* Check Key and SW input     */
    /******************************/
    PRINTF("\nCheck Key and SW input\n");

    while(1)
    {
        //		b = VfdGetSw();
        //		if(b)
        //		{
        //			PRINTF("\nFind SW input! %x\n", b);
        //		}

        dw = VfdGetKeys();
        if(dw)
        {
            PRINTF("\nFind Key input! %x\n", dw);
        }
    }
#endif
}
#endif


/*----------------------------------------------------------------------
 * Function_Name: VfdInit
 *
 * Description:	Initialize the Vfd Chip
 *
 * Arguments:
 *
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdInit()
{
    /* Disable STB, this chip is high active!! */
#if 0

    SET_GPIO_W(SCI_VFD);
    SET_GPIO_LOW(SCI_VFD);


    VfdSetLed(0x00);
    VfdCls();
#endif
}

/*----------------------------------------------------------------------
 * Function_Name: VfdUpdate
 *
 * Description:	Update whole VFD screen
 *
 * Arguments:
 *     DWORD* dwBuff - DisplayBuffer to set
 * Return Value: void
 *----------------------------------------------------------------------*/
void VfdUpdate(DWORD *dwBuff)
{
    int i;

#if 0

    static fld_transmit_seq=0;
    for(i=0;i<3 && !GET_GPIO_DATA(S_REQ);i++)
    {
        switch(fld_transmit_seq)
        {
        case 0:
            if (PnlLastTable[1]!=dwBuff[1] || PnlLastTable[2]!=dwBuff[2])
                break;
            else if (PnlLastTable[3]!=dwBuff[3] || PnlLastTable[4]!=dwBuff[4])
            {
                fld_transmit_seq = 1;
                break;
            }
            else if (PnlLastTable[5]!=dwBuff[5] || PnlLastTable[6]!=dwBuff[6])
            {
                fld_transmit_seq = 2;
                break;
            }
            return;
        case 1:
            if (PnlLastTable[3]!=dwBuff[3] || PnlLastTable[4]!=dwBuff[4])
                break;
            else if (PnlLastTable[5]!=dwBuff[5] || PnlLastTable[6]!=dwBuff[6])
            {
                fld_transmit_seq = 2;
                break;
            }
            else if (PnlLastTable[1]!=dwBuff[1] || PnlLastTable[2]!=dwBuff[2])
            {
                fld_transmit_seq = 0;
                break;
            }
            return;
        case 2:
            if (PnlLastTable[5]!=dwBuff[5] || PnlLastTable[6]!=dwBuff[6])
                break;
            else if (PnlLastTable[1]!=dwBuff[1] || PnlLastTable[2]!=dwBuff[2])
            {
                fld_transmit_seq = 0;
                break;
            }
            else if (PnlLastTable[3]!=dwBuff[3] || PnlLastTable[4]!=dwBuff[4])
            {
                fld_transmit_seq = 1;
                break;
            }
            return;
        default:
            fld_transmit_seq = 0;
        }
        frontTransmitData[0] = 0xa0+fld_transmit_seq*2;
        frontTransmitData[1] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+fld_transmit_seq*8)];
        frontTransmitData[2] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+fld_transmit_seq*8+1)];
        frontTransmitData[3] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+fld_transmit_seq*8+2)];
        frontTransmitData[4] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+fld_transmit_seq*8+4)];
        frontTransmitData[5] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+fld_transmit_seq*8+5)];
        frontTransmitData[6] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+fld_transmit_seq*8+6)];

        if(!front_interface_trans(8))
            continue;

        PnlLastTable[2*fld_transmit_seq+1]=dwBuff[2*fld_transmit_seq+1];
        PnlLastTable[2*fld_transmit_seq+2]=dwBuff[2*fld_transmit_seq+2];
    }
    //*/
#else
    Enter_GPIOSection();
    I2CBusBusy();
    for(i=VFD_GRID_NUM/2-1;i>-1;i--)
    {
        if(PnlLastTable[2*i+1]!=dwBuff[2*i+1] || PnlLastTable[2*i+2]!=dwBuff[2*i+2])
        {
            frontTransmitData[0] = 0xa0+i*2;
            frontTransmitData[1] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+i*8)];
            frontTransmitData[2] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+i*8+1)];
            frontTransmitData[3] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+i*8+2)];
            frontTransmitData[4] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+i*8+4)];
            frontTransmitData[5] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+i*8+5)];
            frontTransmitData[6] = tbl_bit_swap[*((unsigned char *)(dwBuff+1)+i*8+6)];
            XSET_GPIO_R(S_REQ);
            while(XGET_GPIO_DATA(S_REQ))
                dly_tsk(1);
            if(!front_interface_trans(8))
            {
                i++;
                continue;
            }

            PnlLastTable[2*i+1]=dwBuff[2*i+1];
            PnlLastTable[2*i+2]=dwBuff[2*i+2];
        }
    }
    I2CBusRelease();
    Leave_GPIOSection();
    //*/
#endif
}

DWORD GetKeyDownTime()
{
    return PKKeyClock;
}

DWORD GetIRDownTime()
{
    return IRKeyClock;
}
BOOL IsKeyUp()
{
    if(PKState==0)
        return TRUE;
    return FALSE;
}

BOOL IsIRUp()
{
    if(IRState==0)
        return TRUE;
    return FALSE;
}

#if (_TRANSFER_ALI_BOARD_ == _TRANSFER_ALI_BOARD_DISABLE_)
BOOL
VfdOpenLongKey (BYTE KeyGrpID)
{
    if (KeyGrpID>=(sizeof(LongKeyGroup)/sizeof(LONGKEYGROUP)))
        return FALSE;
    LongKeyGroup[KeyGrpID].KeyMapFlag=TRUE;
    return TRUE;
}
#endif


BOOL VfdGroupIsOpen(BYTE KeyGrpId)//bond add for lg bug 2774 .031117
{

  if(LongKeyGroup[KeyGrpId].KeyMapFlag==TRUE)
  	return TRUE;
  else
  	return FALSE;
}
#if (_TRANSFER_ALI_BOARD_ == _TRANSFER_ALI_BOARD_DISABLE_)
BOOL
VfdCloseLongKey(BYTE KeyGrpID)
{
    if (KeyGrpID>=(sizeof(LongKeyGroup)/sizeof(LONGKEYGROUP)))
        return FALSE;
    LongKeyGroup[KeyGrpID].KeyMapFlag=FALSE;
    return TRUE;
}
#endif


void
VfdChkSkip(DWORD ChkKey)
{
    if ((ChkKey==C_KEY_SKIP_L)||(ChkKey==C_KEY_SKIP_R))
    {
        if (SYSOption.bSkipScanIR==0)
            LongKeyGroup[0].KeyMapFlag=FALSE;
        else
            LongKeyGroup[0].KeyMapFlag=TRUE;
    }
}
/*----------------------------------------------------------------------
 * Function_Name: VfdGetKeys
 *
 * Description:	
 *
 * Arguments:
 *
 * Return Value: 
 *     DWORD - key-map of 32 keys. (This chip should have 48 keys at most!)
 *----------------------------------------------------------------------*/
DWORD VfdGetKeys()
{
    DWORD RetKey;
    DWORD KeyDownTime;
    BOOL KeyMapFlag;
    int i,j;
    RetKey=GET_PK_CODE;

    KeyMapFlag=FALSE;

    for(i=0;i<(sizeof(LongKeyGroup)/sizeof(LONGKEYGROUP));i++)
    {
        for (j=0;j<LongKeyGroup[i].KeyNum;j++)
            if (RetKey==LongKeyGroup[i].LongKeyMap[j].ShortKey)
            {
                if ((RetKey==C_KEY_SKIP_L)||(RetKey==C_KEY_SKIP_R))
                {
                    if (SYSOption.bSkipScanFP==0)
                        LongKeyGroup[i].KeyMapFlag=FALSE;
                    else
                        LongKeyGroup[i].KeyMapFlag=TRUE;
                }

                if (LongKeyGroup[i].KeyMapFlag)
                {
                    KeyMapFlag=TRUE;
                    KeyDownTime=GetKeyDownTime();
                    if (KeyDownTime>=LongKeyGroup[i].LongKeyMap[j].KeyTimer)
                        RetKey=LongKeyGroup[i].LongKeyMap[j].LongKey;
                    else
                        if (IsKeyUp())
                            ;
                        else
                            return VFD_KEY_NONE;
                }
                break;
            }

        if (KeyMapFlag==TRUE)
            break;

    }

    GET_PK_CODE=0xff;
    return RetKey;
#if 0

    DWORD dwRet;
    VfdHold();
    /* Command : set Keys input mode */
    SciSetByteMF(0xa0);
    SciDelay(80);/* Delay >40us */
    BYTE3(dwRet)=SciGetByteMF();
    SciDelay(80);/* Delay >40us */
    BYTE2(dwRet)=SciGetByteMF();
    SciDelay(80);/* Delay >40us */
    BYTE1(dwRet)=SciGetByteMF();
    BYTE0(dwRet)=0;
    VfdRelease();
    return dwRet;
#endif
}
/*----------------------------------------------------------------------
 * Function_Name: VfdTransformKey
 *
 * Description:	
 *
 * Arguments:
 *
 * Return Value: 
 *     DWORD - key-map of 32 keys. (This chip should have 48 keys at most!)
 *----------------------------------------------------------------------*/
unsigned long VfdTransformKey(register DWORD key)
{

    return key;
#if 0

    register int    i;

    for (i = 0; i < (sizeof(PnlKeyTrans)/sizeof(unsigned long)-1); i++)
    {
        if (key & 0x00000001)
            return PnlKeyTrans[i];
        key >>= 1;
    }

    return PNL_KEY_NONE;
#endif
}
void  VfdSetKey(DWORD KeyVal)
{
    GET_PK_CODE=KeyVal;
}


DWORD VfdGetIR()
{
    //vfd driver
    DWORD RetIR;
    DWORD IRDownTime;
    BOOL KeyMapFlag;
    int i,j;

    RetIR=GET_IR_CODE;

    KeyMapFlag=FALSE;
    for(i=0;i<(sizeof(LongKeyGroup)/sizeof(LONGKEYGROUP));i++)
    {
        for(j=0;j<LongKeyGroup[i].KeyNum;j++)
            if (RetIR==LongKeyGroup[i].LongKeyMap[j].ShortKey)
            {
                if ((RetIR==C_KEY_SKIP_L)||(RetIR==C_KEY_SKIP_R))
                {
                    if (SYSOption.bSkipScanIR==0)
                        LongKeyGroup[i].KeyMapFlag=FALSE;
                    else
                        LongKeyGroup[i].KeyMapFlag=TRUE;
                }

                if (LongKeyGroup[i].KeyMapFlag)
                {
                    KeyMapFlag=TRUE;
                    IRDownTime=GetIRDownTime();
                    if (IRDownTime>=(LongKeyGroup[i].LongKeyMap[j].KeyTimer))
                    {
                        RetIR=LongKeyGroup[i].LongKeyMap[j].LongKey;
                    }
                    else
                        if (IsIRUp())
                            ;
                        else
                            return VFD_IR_NONE;

                }
                break;
            }
        if (KeyMapFlag==TRUE)
            break;
    }

    return RetIR;
}

void  VfdSetIR(DWORD IRVal)
{
    GET_IR_CODE=IRVal;
}