vfdcore.c

MTK1389D dvd原程序

/**********************************************************************/
/***************           MTK CONFIDENTIAL            ****************/
/***************                                       ****************/
/***************   Description : Vfd Update State      ****************/
/***************                 Machine               ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Sung-Ching Lin        ****************/
/**********************************************************************/
#define _VFD_C_

#pragma NOAREGS

#ifndef PC_EMULATION
  #include "8032api.h"
#else
  #include "emu_api.h"
#endif

#include ".\vfd\vfd.h"
#include VFD_DATA_H

#ifndef PLAYER_NO_VFD

/* both vfd_data.c and vfd_data.h are auto generated. */
#include ".\vfd\vfd_comm.h"

#include VFD_DATA_C
#include VFD_KEY_C
#ifdef LCD_HT1621
static void vVfdSendCom(BYTE bVal, BYTE bCnt) large;
static void VfdSendAddr(BYTE Addr) large;
static void VfdSendData(BYTE bData,BYTE bCnt) large;
#endif
// *********************************************************************
// NEC 16311/2 command set
// *********************************************************************
#define VFD_ADDRESS_INC         0x40
#define VFD_ADDRESS_FIX         0x44
#define VFD_ADDRESS_MASK        0xc0
#define VFD_READ_KEY            0x42
#define VFD_SW_KEY              0x43
#define VFD_READ_SW             0x43

#ifdef PANEL_VFD_LED
#define VFD_WRITE_LED           0x41
#endif

#define VFD_DISP_MODE_OFF          0
#define VFD_DISP_MODE_DEFAULT      2
#define VFD_DISP_MODE_MAX          3

static code BYTE pbVfdDispCmd[VFD_DISP_MODE_MAX] = {
#ifdef zzf_modify
   0x8e, 0x8a, 0x8f
#else
   0x87, 0x8a, 0x8f
#endif
};

// *********************************************************************
// VFD Basic Routine
// *********************************************************************
#if !defined(PC_EMULATION)

#define VfdClrStb() { VFD_STB = VFD_LOW; VFD_STB = VFD_LOW; }
#define VfdSetStb() { VFD_STB = VFD_HIGH; VFD_STB = VFD_HIGH; }

#define VfdClrClk() { VFD_CLK = VFD_LOW; VFD_CLK = VFD_LOW; }
#define VfdSetClk() { VFD_CLK = VFD_HIGH; VFD_CLK = VFD_HIGH; }

#define VfdClrDat() { VFD_DATA = VFD_LOW; VFD_DATA = VFD_LOW; }
#define VfdSetDat() { VFD_DATA = VFD_HIGH; VFD_DATA = VFD_HIGH; }
#ifdef LCD_HT1621
static void vVfdSendCom(BYTE bVal, BYTE bCnt) large
{
  BYTE i;
  bVal <<=(8-bCnt);
  for (i = 0; i < bCnt; i++)
  {
  VfdClrClk();
      
    VFD_DATA = (bVal & 0x80);
    _nop_(); _nop_();
    bVal <<= 1;
    
  VfdSetClk();
    _nop_(); _nop_(); _nop_(); _nop_();
  }
}

static void VfdSendAddr(BYTE Addr) large
{
  BYTE i; 

  Addr <<= 2;
  for (i = 0; i < 6; i++)
  {
    VfdClrClk();
    if(Addr & 0x80)
    {
      VFD_DATA = 1;
    }
    else
    {
      VFD_DATA = 0;
    }
    _nop_(); _nop_(); _nop_(); _nop_();
    Addr <<= 1;
    
   VfdSetClk();
    _nop_(); _nop_(); _nop_(); _nop_();
  }
}

static void VfdSendData(BYTE bData,BYTE bCnt) large
{
  BYTE i;
  
  for (i = 0; i < bCnt; i++)
  {
     VfdClrClk();
     VFD_DATA = (bData & 0x01);
     bData >>= 1;
    _nop_(); _nop_(); _nop_(); _nop_();
     VfdSetClk();
    _nop_(); _nop_(); _nop_(); _nop_();
  }
  _nop_(); _nop_(); _nop_(); _nop_();
  VfdSetDat();
}
#endif
static void VfdSend(BYTE bTmp) large
{
  BYTE i;

  for (i = 0; i < 8; i++)
  {
    VfdClrClk();

    VFD_DATA = (bTmp & 0x1);
    bTmp >>= 1;

    VfdSetClk();
  }

  VfdSetDat();
}
#ifndef LCD_HT1621
static BYTE VfdRecv(void) large
{
  BYTE i, bKeyData;

  bKeyData = 0;

  for(i = 0; i < 8; i++)
  {
    VfdSetClk();
    bKeyData <<= 1;
    VfdClrClk();

    /* delay for data output ready */
    _nop_(); _nop_(); _nop_();

    if (VFD_DATA)
    {
      bKeyData |= 1;
    }
  }

  return (bKeyData);
}
 #endif
#else /* for PC_EMULATION */

extern __declspec(dllexport) void VfdClrStb(void);
extern __declspec(dllexport) void VfdSetStb(void);
extern __declspec(dllexport) void VfdSend(BYTE bTmp);
extern __declspec(dllexport) BYTE VfdRecv(void);

#endif /* PC_EMULATION */

// *********************************************************************
// Local Variables
// *********************************************************************
static xdata BYTE _bVfdIdx;
static xdata BYTE _bUpdateIdx;
static xdata BYTE _bVfdBuf;
static xdata BYTE _bVfdKeyBuf;
static xdata BYTE _bVfdDispMode;

#ifdef PANEL_VFD_LED
static xdata BYTE _bVfdLed;
#endif

#ifdef VFD_INIT_STATE_FLASHING
static xdata BYTE _bVfdFlashCnt;
#endif

#ifdef VFD_VOLATILE_MSG
static xdata BYTE _bVfdRestoreCnt;
#endif

#ifdef VFD_USE_TBL_SHADOW

static code WORD wWorkShadowShare[VFD_SHADOW_LEN_MAX] = {
  SI_VFD_WORK_SHADOW,      SI_VFD_WORK_SHADOW +  1, SI_VFD_WORK_SHADOW +  2, SI_VFD_WORK_SHADOW +  3,
  SI_VFD_WORK_SHADOW +  4, SI_VFD_WORK_SHADOW +  5, SI_VFD_WORK_SHADOW +  6, SI_VFD_WORK_SHADOW +  7,
  SI_VFD_WORK_SHADOW +  8, SI_VFD_WORK_SHADOW +  9, SI_VFD_WORK_SHADOW + 10, SI_VFD_WORK_SHADOW + 11,
  SI_VFD_WORK_SHADOW + 12, SI_VFD_WORK_SHADOW + 13, SI_VFD_WORK_SHADOW + 14, SI_VFD_WORK_SHADOW + 15,
  SI_VFD_WORK_SHADOW + 16, SI_VFD_WORK_SHADOW + 17, SI_VFD_WORK_SHADOW + 18, SI_VFD_WORK_SHADOW + 19,
  SI_VFD_WORK_SHADOW + 20, SI_VFD_WORK_SHADOW + 21, SI_VFD_WORK_SHADOW + 22, SI_VFD_WORK_SHADOW + 23,
  SI_VFD_WORK_SHADOW + 24, SI_VFD_WORK_SHADOW + 25, SI_VFD_WORK_SHADOW + 26, SI_VFD_WORK_SHADOW + 27,
  SI_VFD_WORK_SHADOW + 28, SI_VFD_WORK_SHADOW + 29, SI_VFD_WORK_SHADOW + 30, SI_VFD_WORK_SHADOW + 31,
  SI_VFD_WORK_SHADOW + 32, SI_VFD_WORK_SHADOW + 33, SI_VFD_WORK_SHADOW + 34, SI_VFD_WORK_SHADOW + 35,
  SI_VFD_WORK_SHADOW + 36, SI_VFD_WORK_SHADOW + 37, SI_VFD_WORK_SHADOW + 38, SI_VFD_WORK_SHADOW + 39,
  SI_VFD_WORK_SHADOW + 40, SI_VFD_WORK_SHADOW + 41, SI_VFD_WORK_SHADOW + 42, SI_VFD_WORK_SHADOW + 43,
  SI_VFD_WORK_SHADOW + 44, SI_VFD_WORK_SHADOW + 45, SI_VFD_WORK_SHADOW + 46, SI_VFD_WORK_SHADOW + 47
};

static code WORD wUpdateShadowShare[VFD_SHADOW_LEN_MAX] = {
  SI_VFD_UPDATE_SHADOW,      SI_VFD_UPDATE_SHADOW +  1, SI_VFD_UPDATE_SHADOW +  2, SI_VFD_UPDATE_SHADOW +  3,
  SI_VFD_UPDATE_SHADOW +  4, SI_VFD_UPDATE_SHADOW +  5, SI_VFD_UPDATE_SHADOW +  6, SI_VFD_UPDATE_SHADOW +  7,
  SI_VFD_UPDATE_SHADOW +  8, SI_VFD_UPDATE_SHADOW +  9, SI_VFD_UPDATE_SHADOW + 10, SI_VFD_UPDATE_SHADOW + 11,
  SI_VFD_UPDATE_SHADOW + 12, SI_VFD_UPDATE_SHADOW + 13, SI_VFD_UPDATE_SHADOW + 14, SI_VFD_UPDATE_SHADOW + 15,
  SI_VFD_UPDATE_SHADOW + 16, SI_VFD_UPDATE_SHADOW + 17, SI_VFD_UPDATE_SHADOW + 18, SI_VFD_UPDATE_SHADOW + 19,
  SI_VFD_UPDATE_SHADOW + 20, SI_VFD_UPDATE_SHADOW + 21, SI_VFD_UPDATE_SHADOW + 22, SI_VFD_UPDATE_SHADOW + 23,
  SI_VFD_UPDATE_SHADOW + 24, SI_VFD_UPDATE_SHADOW + 25, SI_VFD_UPDATE_SHADOW + 26, SI_VFD_UPDATE_SHADOW + 27,
  SI_VFD_UPDATE_SHADOW + 28, SI_VFD_UPDATE_SHADOW + 29, SI_VFD_UPDATE_SHADOW + 30, SI_VFD_UPDATE_SHADOW + 31,
  SI_VFD_UPDATE_SHADOW + 32, SI_VFD_UPDATE_SHADOW + 33, SI_VFD_UPDATE_SHADOW + 34, SI_VFD_UPDATE_SHADOW + 35,
  SI_VFD_UPDATE_SHADOW + 36, SI_VFD_UPDATE_SHADOW + 37, SI_VFD_UPDATE_SHADOW + 38, SI_VFD_UPDATE_SHADOW + 39,
  SI_VFD_UPDATE_SHADOW + 40, SI_VFD_UPDATE_SHADOW + 41, SI_VFD_UPDATE_SHADOW + 42, SI_VFD_UPDATE_SHADOW + 43,
  SI_VFD_UPDATE_SHADOW + 44, SI_VFD_UPDATE_SHADOW + 45, SI_VFD_UPDATE_SHADOW + 46, SI_VFD_UPDATE_SHADOW + 47
};

#define VfdWorkShadowRead(i)        bSharedInfo(wWorkShadowShare[i])
#define VfdWorkShadowWrite(i,d)     vSetSharedInfo(wWorkShadowShare[i],d)
#define VfdUpdateShadowRead(i)      bSharedInfo(wUpdateShadowShare[i])
#define VfdUpdateShadowWrite(i,d)   vSetSharedInfo(wUpdateShadowShare[i],d)

  #ifdef VFD_VOLATILE_MSG
static code WORD wBackupShadowShare[VFD_SHADOW_LEN_MAX] = {
  SI_VFD_BACKUP_SHADOW,      SI_VFD_BACKUP_SHADOW +  1, SI_VFD_BACKUP_SHADOW +  2, SI_VFD_BACKUP_SHADOW +  3,
  SI_VFD_BACKUP_SHADOW +  4, SI_VFD_BACKUP_SHADOW +  5, SI_VFD_BACKUP_SHADOW +  6, SI_VFD_BACKUP_SHADOW +  7,
  SI_VFD_BACKUP_SHADOW +  8, SI_VFD_BACKUP_SHADOW +  9, SI_VFD_BACKUP_SHADOW + 10, SI_VFD_BACKUP_SHADOW + 11,
  SI_VFD_BACKUP_SHADOW + 12, SI_VFD_BACKUP_SHADOW + 13, SI_VFD_BACKUP_SHADOW + 14, SI_VFD_BACKUP_SHADOW + 15,
  SI_VFD_BACKUP_SHADOW + 16, SI_VFD_BACKUP_SHADOW + 17, SI_VFD_BACKUP_SHADOW + 18, SI_VFD_BACKUP_SHADOW + 19,
  SI_VFD_BACKUP_SHADOW + 20, SI_VFD_BACKUP_SHADOW + 21, SI_VFD_BACKUP_SHADOW + 22, SI_VFD_BACKUP_SHADOW + 23,
  SI_VFD_BACKUP_SHADOW + 24, SI_VFD_BACKUP_SHADOW + 25, SI_VFD_BACKUP_SHADOW + 26, SI_VFD_BACKUP_SHADOW + 27,
  SI_VFD_BACKUP_SHADOW + 28, SI_VFD_BACKUP_SHADOW + 29, SI_VFD_BACKUP_SHADOW + 30, SI_VFD_BACKUP_SHADOW + 31,
  SI_VFD_BACKUP_SHADOW + 32, SI_VFD_BACKUP_SHADOW + 33, SI_VFD_BACKUP_SHADOW + 34, SI_VFD_BACKUP_SHADOW + 35,
  SI_VFD_BACKUP_SHADOW + 36, SI_VFD_BACKUP_SHADOW + 37, SI_VFD_BACKUP_SHADOW + 38, SI_VFD_BACKUP_SHADOW + 39,
  SI_VFD_BACKUP_SHADOW + 40, SI_VFD_BACKUP_SHADOW + 41, SI_VFD_BACKUP_SHADOW + 42, SI_VFD_BACKUP_SHADOW + 43,
  SI_VFD_BACKUP_SHADOW + 44, SI_VFD_BACKUP_SHADOW + 45, SI_VFD_BACKUP_SHADOW + 46, SI_VFD_BACKUP_SHADOW + 47
};

#define VfdBackupShadowRead(i)      bSharedInfo(wBackupShadowShare[i])
#define VfdBackupShadowWrite(i,d)   vSetSharedInfo(wBackupShadowShare[i],d)

  #endif /* VFD_VOLATILE_MSG */

#else /* not define VFD_USE_TBL_SHADOW */

#define VfdWorkShadowRead(i)        bSharedInfo(SI_VFD_WORK_SHADOW + i)
#define VfdWorkShadowWrite(i,d)     vSetSharedInfo(SI_VFD_WORK_SHADOW + i,d)
#define VfdUpdateShadowRead(i)      bSharedInfo(SI_VFD_UPDATE_SHADOW + i)
#define VfdUpdateShadowWrite(i,d)   vSetSharedInfo(SI_VFD_UPDATE_SHADOW + i,d)

  #ifdef VFD_VOLATILE_MSG
#define VfdBackupShadowRead(i)      bSharedInfo(SI_VFD_BACKUP_SHADOW + i)
#define VfdBackupShadowWrite(i,d)   vSetSharedInfo(SI_VFD_BACKUP_SHADOW + i,d)
  #endif

#endif /* not define VFD_USE_TBL_SHADOW */

#ifdef VFD_VOLATILE_MSG

static code WORD wBackupIcon[] = {
  VFDICON_title,
  VFDICON_track,
  VFDICON_colonon
};

#define VFD_BACKUP_ICON_SZ   TBL_SIZE(wBackupIcon)

#endif /* VFD_VOLATILE_MSG */

// *********************************************************************
// Local Function Prototype
// *********************************************************************
void VfdSetChar(BYTE bSeg, BYTE bCode) large;
void VfdClearAllDirect(void) large;

#ifdef PANEL_VFD_LED
void VfdSetLed(BYTE bLed) large;
#endif

#ifdef VFD_STANDBY_LED
  #define VfdStandbyLedOff()    VfdSetLed(0xff)
  #define VfdStandbyLedOn()     VfdSetLed(0x00)
#endif

// *********************************************************************
// Local Defines
// *********************************************************************
#define VFD_LIST_END    0xff

#define VfdStbSend(bData) { VfdClrStb(); VfdSend(bData); VfdSetStb(); }

#define VfdUpdateStart()
#define VfdUpdateStop()   (_rVfdFlag.fgVfdChange = TRUE)
#define VfdUpdateByte(a)

/* note the p can not be constant variable */
#define VfdScanList(p) while (*p != VFD_LIST_END) {               \
  _bVfdBuf = VfdWorkShadowRead(*p);                               \
  _bVfdBuf |= *(p+1); _bVfdBuf &= *(p+2); /* byte no, on, off */  \
  VfdWorkShadowWrite(*p, _bVfdBuf);                               \
  VfdUpdateByte(*p); /* Send to VFD's RAM imdediately */          \
  p += 3;                                                         \
}

#ifdef VFD_VOLATILE_MSG

/* note the p can not be constant variable */
#define VfdScanListBackup(p) while (*p != VFD_LIST_END) {         \
  _bVfdBuf = VfdBackupShadowRead(*p);                             \
  _bVfdBuf |= *(p+1); _bVfdBuf &= *(p+2); /* byte no, on, off */  \
  VfdBackupShadowWrite(*p, _bVfdBuf);                             \
  p += 3;                                                         \
}

/* note the p can not be constant variable */
#define VfdBackupSeg(p) while (*p != VFD_LIST_END) {              \
  _bVfdBuf = VfdWorkShadowRead(*p);                               \
  _bVfdBuf &= ~(*(p+2)); /* byte off inverse only */              \
  _bVfdBuf |= VfdBackupShadowRead(*p);                            \
  VfdBackupShadowWrite(*p, _bVfdBuf);                             \
  p += 3;                                                         \
}

/* note the p can not be constant variable */
#define VfdBackupIcon(p) while (*p != VFD_LIST_END) {             \
  _bVfdBuf = VfdWorkShadowRead(*p);                               \
  _bVfdBuf &= *(p+1); /* byte on only */                          \
  _bVfdBuf |= VfdBackupShadowRead(*p);                            \
  VfdBackupShadowWrite(*p, _bVfdBuf);                             \
  p += 3;                                                         \
}

/* note the p can not be constant variable */
#define VfdClearIcon(p) while (*p != VFD_LIST_END) {              \
  _bVfdBuf = VfdWorkShadowRead(*p);                               \
  _bVfdBuf &= ~(*(p+1)); _bVfdBuf &= *(p+2); /* all off */        \
  VfdWorkShadowWrite(*p, _bVfdBuf);                               \
  p += 3;                                                         \
}

#endif /* VFD_VOLATILE_MSG */

// *********************************************************************
// VFD State Machine
// *********************************************************************
enum
{
  VFD_INIT_STATE,
  VFD_SCAN_STATE_0,
  VFD_SCAN_STATE_1,
  VFD_PARSE_STATE,
  VFD_UPDATE_STATE_0,
  VFD_UPDATE_STATE_1
};

void VfdInitState(BOOL fgShadow) large;
void VfdScanState0(void) large;
void VfdScanState1(void) large;
void VfdParseState(BOOL fgStandby) large;
void VfdUpdateState0(void) large;
void VfdUpdateState1(void) large;

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdInit(BOOL fgClear, BOOL fgOff)
{
  BYTE i;

  _bVfdIdx = 0;
  _bVfdKey = IR_NONE;
  _bVfdKeyBuf = IR_NONE;
  _fgVfdKeyValid = FALSE;

#ifdef VFD_VOLATILE_MSG
  _rVfdFlag.fgSegBackupOn = FALSE;
  _bVfdRestoreCnt = 0;
#endif

  _bVfdDispMode = VFD_DISP_MODE_DEFAULT;
#ifdef VFD_INIT_STATE_FLASHING
  _bVfdFlashCnt = 0;
#endif

  if (fgClear == TRUE) /* if DRAM buffer is available */
  {
    for (i = 0; i < VFD_SHADOW_LEN; i++)
    {
      VfdWorkShadowWrite(i, 0);
      VfdUpdateShadowWrite(i, 0);
#ifdef VFD_VOLATILE_MSG
      VfdBackupShadowWrite(i, 0);
#endif
    }
  }

#ifdef VFD_STANDBY_LED
  if (fgClear == TRUE) /* DRAM available means power on */
  {
    VfdStandbyLedOff();
  }
  else
  {
    VfdStandbyLedOn();
  }
#endif /* VFD_STANDBY_LED */
#ifdef LCD_HT1621
 //for SYS_EN
  VfdClrStb();
  vVfdSendCom(LCD_CMD, 3);
  vVfdSendCom(LCD_SYS_EN, 8);
  vVfdSendCom(0, 1);
  VfdSetStb();

  //for LCD_ON
  VfdClrStb(); 
  vVfdSendCom(LCD_CMD, 3);
  vVfdSendCom(LCD_ON, 8);
  vVfdSendCom(0, 1);
  VfdSetStb();
  
  //for TIMER_EN
  VfdClrStb(); 
  vVfdSendCom(LCD_CMD, 3);
  vVfdSendCom(LCD_TIMER_EN, 8);
  vVfdSendCom(0, 1);
  VfdSetStb();
   //for  rc 256k
 VfdClrStb(); 
  vVfdSendCom(LCD_CMD, 3);
  vVfdSendCom(LCD_RC_256K, 8);
  vVfdSendCom(0, 1);
 VfdSetStb();
  
  //for bias 1/3, 4com
  VfdClrStb(); 
  vVfdSendCom(LCD_CMD, 3);
  vVfdSendCom(LCD_BIAS13_COM4, 8);
  vVfdSendCom(0, 1);
 VfdSetStb();
  //for TNORMAL 
  VfdClrStb(); 
  vVfdSendCom(LCD_CMD, 3);
  vVfdSendCom(LCD_TNORMAL, 8);
  vVfdSendCom(0, 1);
  VfdSetStb();
  VfdClearAllDirect();
    if (fgOff == TRUE)
  {
    /* for AC power-on, show HELLO ASAP */
    if (fgClear == TRUE)
      VfdMsgDirect(VFDMSG_hello);
    	}
  #else
  if (fgOff == TRUE)
  {
    /* for AC power-on, show HELLO ASAP */
    if (fgClear == TRUE)
    {
      VfdClearAllDirect();
#ifdef VFDMSG_hello
      VfdMsgDirect(VFDMSG_hello);
#endif
    }
    else
    {
      VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_OFF]);
    }
  }
  #endif
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdStop(void) large
{
  VfdSetClk();
  VfdSetDat();
  VfdSetStb();

  _bVfdIdx = 0;
  _bUpdateIdx = VFD_SHADOW_LEN;

#ifdef VFD_VOLATILE_MSG
  _bVfdRestoreCnt = 0;
  _rVfdFlag.fgSegBackupOn = FALSE;
#endif

  _rVfdFlag.fgVfdKeyLock = FALSE;
  _rVfdFlag.fgVfdChange = FALSE;
  _rVfdFlag.fgVfdUpdate = FALSE;

  _bVfdKey = IR_NONE;
  _bVfdKeyBuf = IR_NONE;
  _fgVfdKeyValid = FALSE;

}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdBright(BYTE bMode) large
{
#ifndef LCD_HT1621
  if (bMode == VFD_DISP_BRIGHT)
  {
    _bVfdDispMode++;

    if (_bVfdDispMode >= VFD_DISP_MODE_MAX)
    {
      _bVfdDispMode = VFD_DISP_MODE_OFF;
    }
  }
  else if (bMode == VFD_DISP_DARK)
  {
    if (_bVfdDispMode <= VFD_DISP_MODE_OFF)
    {
      _bVfdDispMode = VFD_DISP_MODE_MAX - 1;
    }
    else
    {
      _bVfdDispMode--;
    }
  }
  else if (bMode == VFD_DISP_RESET)
  {
    _bVfdDispMode = VFD_DISP_MODE_DEFAULT;
#ifdef VFD_INIT_STATE_FLASHING
    _bVfdFlashCnt = 0;
#endif
  }

  VfdStbSend(pbVfdDispCmd[_bVfdDispMode]);
  #endif
}

#ifdef PANEL_VFD_LED
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdSetLed(BYTE bLed) large
{
  VfdClrStb();
  VfdSend(VFD_WRITE_LED);
  VfdSend(bLed);
  VfdSetStb();
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdLed(BOOL fgLite, BYTE bMask) large
{
  if (fgLite)
  {
    _bVfdLed |= bMask;
  }
  else
  {
    _bVfdLed &= (~bMask);
  }
}
#endif /* PANEL_VFD_LED */

/************************************************************************
     Function : void VfdSetIcon(WORD anode, BYTE lite)
  Description : lite on/off anode
    Parameter : wNode -> , bLite -> 0/1/2 for off/on/complement
    Return    : None
************************************************************************/