vfdcore.c

mtkDVD源代码程序4*16 很好玩的内置5.1环绕音效 大家可以玩一下

  for (i = 0; i < VFD_BACKUP_ICON_SZ;i++)
  {
    pbList = (_pbVfdIconMacro + wBackupIcon[i]);

    VfdClearIcon(pbList);
  }

  /* display messages */
  pbList = pbVfdMsg[bIndex];
  VfdScanList(pbList);

  VfdUpdateStop();
  
  _bVfdRestoreCnt = bTime;
}
#endif /* VFD_VOLATILE_MSG */

  #ifdef VFD_INIT_STATE_FLASHING
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdSetFlashing(BYTE bMode) large
{
  if (bMode == VFD_FLASHING_ON)
  {
    _bVfdFlashCnt = VFD_FLASHING_TIME * 2;
  }
  else
  {
    _bVfdFlashCnt = 0;
  }
}
  #endif /* VFD_INIT_STATE_FLASHING */

// *********************************************************************
// VFD State Machine
// *********************************************************************

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdInitState(BOOL fgShadow) large
{
  BYTE i;

  _bUpdateIdx = VFD_SHADOW_LEN;
  _bVfdKey = IR_NONE;
  _bVfdKeyBuf = IR_NONE;
  _fgVfdKeyValid = FALSE;

  VfdClearAllDirect();

  if (fgShadow)
  {
    /* DRAM buffer is avialable */
    VfdClearAll();
  }

  _rVfdFlag.fgVfdKeyLock = FALSE;

  _rVfdFlag.fgVfdChange = TRUE;
  _rVfdFlag.fgVfdUpdate = TRUE;
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdScanState0(void) large
{
  VfdClrStb();
  VfdSend(VFD_READ_KEY);
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdScanState1(void) large
{
  BYTE i, j, bRecvByte;

  _bVfdKeyBuf = IR_NONE;

  for (j=VFD_KEY_LEN;j>0;j--)
  {
    bRecvByte = VfdRecv();
    if (bRecvByte != 0)
    {
      for(i = 0; i < 8; i++)
      {
        if (bRecvByte & 0x1)
        {
          _bVfdKeyBuf = i + ((VFD_KEY_LEN - j) * 8);
          break;
        }
        bRecvByte >>= 1;
      }
    }
  }

  VfdSetClk(); /* ? */
  VfdSetStb();

  if (_bVfdKeyBuf == IR_NONE)
  {
    _rVfdFlag.fgVfdKeyLock = FALSE;
    _bVfdIdx++; /* skip parse state */
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdParseState(BOOL fgStandby) large
{
  BYTE i, j;

  if ((_bVfdKeyBuf < VFD_KEY_TBL_SIZE) && (_rVfdFlag.fgVfdKeyLock == FALSE))
  {
    _bVfdKey = _pbVFDKeyTbl[_bVfdKeyBuf];

#ifdef VFD_MULTI_FUNC_KEY
    if (fgStandby == FALSE)
    {
      VfdMultiKeyProc();
    }
#endif

    _rVfdFlag.fgVfdKeyLock = TRUE;
  }

  /* check if VFD key is valid */
  if (_bVfdKey == IR_NONE)
  {
    _fgVfdKeyValid = FALSE;
  }
  else
  {
    _fgVfdKeyValid = TRUE;
  }

  _bVfdKeyBuf = IR_NONE;
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdUpdateState0(void) large
{
#ifdef VFD_HDCD_LED
  VfdSetLed(_bVfdLed);
#endif

  VfdStbSend(VFD_MODE);
#ifdef VFD_INIT_STATE_FLASHING
  if (_bVfdFlashCnt > 0)
  {
    if (_bVfdFlashCnt == VFD_FLASHING_TIME * 2)
    {
      VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_OFF]);
    }
    else if (_bVfdFlashCnt == VFD_FLASHING_TIME)
    {
      VfdStbSend(pbVfdDispCmd[_bVfdDispMode]);
    }

    if (_bVfdFlashCnt == 1)
    {
      _bVfdFlashCnt = VFD_FLASHING_TIME * 2;
    }
    else
    {
      _bVfdFlashCnt--;
    }
  }
  else
#endif
  {
    VfdStbSend(pbVfdDispCmd[_bVfdDispMode]);
  }
  VfdStbSend(VFD_ADDRESS_FIX);
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
#define VFD_UPDATE_BYTE_PER_STATE     ((BYTE)((VFD_SHADOW_LEN + 1) / 2))

void VfdUpdateState1(void) large
{
  BYTE i, j;

  for (i=0;i<VFD_UPDATE_BYTE_PER_STATE;i++)
  {
    _bUpdateIdx--;

    if (_rVfdFlag.fgVfdUpdate == TRUE)
    {
      VfdClrStb();
      VfdSend(_pbVfdRefresh[_bUpdateIdx] | VFD_ADDRESS_MASK);
      VfdSend(VfdUpdateShadowRead(_bUpdateIdx));
      VfdSetStb();
    }

    if (_bUpdateIdx == 0)
    {
      _bUpdateIdx = VFD_SHADOW_LEN;

      if (_rVfdFlag.fgVfdChange == TRUE)
      {
        _rVfdFlag.fgVfdChange = FALSE;
        
        for (j=0;j<VFD_SHADOW_LEN;j++)
        {
          VfdUpdateShadowWrite(j, VfdWorkShadowRead(j));
        }
        _rVfdFlag.fgVfdUpdate = TRUE;
      }
      else
      {
        _rVfdFlag.fgVfdUpdate = FALSE;
      }
    } /* _bUpdateIdx == 0 */
  }
}

/* for NEC 16312 only */
code BYTE _bVfdStateList[] =
{
  VFD_INIT_STATE, /* only used when VFD control mode is changed */
  /* scan panel key 4Hz, 20ms timer base */
  VFD_UPDATE_STATE_0,
  VFD_UPDATE_STATE_1,
  VFD_UPDATE_STATE_1,
  VFD_SCAN_STATE_0,
  VFD_SCAN_STATE_1,
  VFD_PARSE_STATE
};

#define VFD_STATE_LIST_MAX      TBL_SIZE(_bVfdStateList)

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdProc(void) large
{
  BYTE bTmp;

  if (_bVfdIdx >= VFD_STATE_LIST_MAX)
  {
    _bVfdIdx = 1;
  }

  bTmp = _bVfdStateList[_bVfdIdx];

#ifdef VFD_VOLATILE_MSG
  if ((_bVfdRestoreCnt != VFD_NO_DISAPPEAR) && (_bVfdRestoreCnt > 0))
  {
    _bVfdRestoreCnt--;
  }
#endif

  switch (bTmp)
  {
    case VFD_INIT_STATE:
      VfdInitState(TRUE); /* update DRAM buffer */
      break;
    case VFD_SCAN_STATE_0:
#ifdef VFD_VOLATILE_MSG
      if (fgIsVfdSegBackupOn() && (_bVfdRestoreCnt == 0))
      {
        VfdRestore();
      }
#endif
      VfdScanState0();
      break;
    case VFD_SCAN_STATE_1:
      VfdScanState1();
      break;
    case VFD_PARSE_STATE:
      VfdParseState(FALSE);
      break;
    case VFD_UPDATE_STATE_0:
      VfdUpdateState0();
      break;
    case VFD_UPDATE_STATE_1:
      VfdUpdateState1();
      break;
    default:
      _bVfdIdx = 0;
      return;
  }

  _bVfdIdx++;
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
/* we must confirm this is called 20ms periodically */
void VfdTimer(void) large
{
  VfdProc();
}

#ifdef PLAYER_POWERDOWN

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdPowerDownState0(void) large
{
  /* VfdStbSend(VFD_MODE); */
  VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_OFF]);
  VfdStbSend(VFD_ADDRESS_FIX);
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdPowerDownProc(void) large
{
  BYTE bTmp;

  if (_bVfdIdx >= VFD_STATE_LIST_MAX)
  {
    _bVfdIdx = 1;
  }

  bTmp = _bVfdStateList[_bVfdIdx];

  switch (bTmp)
  {
    case VFD_INIT_STATE:
      VfdInitState(FALSE); /* DRAM buffer is not available */
      break;
    case VFD_SCAN_STATE_0:
      VfdScanState0();
      break;
    case VFD_SCAN_STATE_1:
      VfdScanState1();
      break;
    case VFD_PARSE_STATE:
      VfdParseState(TRUE);
      break;
    case VFD_UPDATE_STATE_0:
      VfdPowerDownState0();
      break;
    case VFD_UPDATE_STATE_1:
      /* no need */
      break;
    default:
      _bVfdIdx = 0;
      return;
  }

  _bVfdIdx++;
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
/* we must confirm this is called 20ms periodically */
#ifndef PLAYER_NO_VFD
void VfdPowerDownTimer(void) large
{
  VfdPowerDownProc();

  /* TODO: the emergency key should abort ther current key operation */

  if ((_bVfdKey != IR_NONE)  && (_bVfdIdx != (VFD_STATE_LIST_MAX-1)))
  {
    switch (_bVfdKey)
    {
      case IR_POWER:
        _fgVfdKeyValid = TRUE;
        break;

      /* panel play key is power key */
      case IR_PLAY:
      case IR_PLAY_PAUSE:
      case IR_PLAY_ENTER:
        _bVfdKey = IR_POWER;
        _fgVfdKeyValid = TRUE;
        break;

      case IR_EJECT: /* power-on eject key */
        _bVfdKey = IR_EJECT;
        _fgVfdKeyValid = TRUE;
        break;

      default:
        _bVfdKey = IR_NONE;
        _fgVfdKeyValid = FALSE;
        break;      
    } /* switch (_bVfdKey) */
  }
  else
  {
    _fgVfdKeyValid = FALSE;
  }
}
#endif
#endif /* PLAYER_POWERDOWN */

#else /* dummy function */

#ifdef PANEL_IO_KEY

xdata struct
{
  BYTE  fgVfdKeyLock:1;
  BYTE  Reserve:7;
}
_rVfdFlag;

sbit  PANEL_STOP_KEY     =  P1^2;
sbit  PANEL_EJECT_KEY    =  P1^4;
sbit  PANEL_PLAY_KEY     =  P1^3;

#define PANEL_KEY_HIGH   1
#define PANEL_KEY_LOW    0

void GetPanelKey(void) large
{
  BYTE bKeyTemp;

  if (PANEL_EJECT_KEY == PANEL_KEY_LOW)
  {
    bKeyTemp = IR_EJECT;
  }
  else if (PANEL_PLAY_KEY == PANEL_KEY_LOW)
  {
    bKeyTemp = IR_PLAY_ENTER;
  }
  else if (PANEL_STOP_KEY == PANEL_KEY_LOW)
  {
    bKeyTemp = IR_STOP;
  }
  else
  {
    _rVfdFlag.fgVfdKeyLock = FALSE;
    _fgVfdKeyValid = FALSE;
    _bVfdKey = IR_NONE;
    return;
  }

  if (_rVfdFlag.fgVfdKeyLock == FALSE)
  {
    _rVfdFlag.fgVfdKeyLock = TRUE;
    _fgVfdKeyValid = TRUE;
    _bVfdKey = bKeyTemp;
  }
}
#endif /* PANEL_IO_KEY */

code BYTE _bVfdStateList[1] = { FALSE }; /* for code segment */

void VfdInit(BOOL fgClear, BOOL fgOff)
{
#ifdef PANEL_IO_KEY
  _rVfdFlag.fgVfdKeyLock = FALSE;
  _fgVfdKeyValid = FALSE;

  fgClear =  PANEL_STOP_KEY;
  fgClear =  PANEL_EJECT_KEY;
  fgClear =  PANEL_PLAY_KEY;
#endif /* PANEL_IO_KEY */

  fgClear = _bVfdStateList[0];
  return;
}

void VfdStop(void) large
{
  return;
}

void VfdTimer(void) large
{
#ifdef PANEL_IO_KEY
  GetPanelKey();
#else
  _fgVfdKeyValid = FALSE;
#endif
  return;
}

#ifndef SIMPLE_VERSION
#ifdef PLAYER_NO_VFD
void VfdPowerDownTimer(void) large
{
  _fgVfdKeyValid = FALSE;

  return;
}
void VfdErrMsgDirect(BYTE bCode) large
{
  return;
}
#endif
#endif


#ifdef VFD_DEBUG
  #include ".\vfd\vfd_dbg.c"
#endif

#endif /* PLAYER_NO_VFD */