vfd_pub.c

MTK 1389e版 MINI组合音响代码

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************   Description : VFD public functions  ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _VFD_PUB_C_

#pragma NOAREGS

#include "general.h"
#ifdef VFD_SUPPORT
#include ".\vfd\vfd_grp.h"
#if defined(DVD_RECEIVER)
  #include  ".\receiver\dvdrec.h"
#endif

#if defined(DVD_RECEIVER)
extern xdata BYTE _bPWRMode;
extern BYTE xdata _bVfdTimer; //BillDen
extern BYTE xdata bVfdRefreshPos;//DVD_AMP
#endif    

#ifdef  USE_CD4094
extern void SET_4094_PIN(BYTE PIN);
extern void CLR_4094_PIN(BYTE PIN);
#endif

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdGrpClear(BYTE *pbGrpTable, BYTE bIdxNs) large
{
  BYTE i;
  BYTE bMode;
  
  for(i = 0; i < bIdxNs; i++)
  {
    bMode = pbGrpTable[i];
    vVfdSetMode(bMode, VFD_OFF);
  } 
}


/************************************************************************
     Function : void vVfdGrpProc(BYTE *pbGrpTable, BYTE bIdxNs,
                                 BYTE *pbGrpOnTable, BYTE bOnIdx)
  Description : turn on symbols in one group
    Parameter : pbGrpTable: pointer to group table
                bIdxNs: total element numbers in this group
                pbGrpOnTable: pointer to group turn on table
                bOnIdx: index to turn on table
    Return    : None
************************************************************************/
static void vVfdGrpProc(BYTE *pbGrpTable, BYTE bIdxNs,
                        BYTE *pbGrpOnTable, BYTE bOnIdx) large
{
  BYTE i;
  BYTE bNum;
  BYTE bMode;

  if(bOnIdx == VFD_NULL)
  {
    return;
  }
  
  vVfdGrpClear(pbGrpTable, bIdxNs);

  if(bOnIdx == VFD_GRP_OFF)
  {
    return;
  }

  bNum = pbGrpOnTable[bOnIdx];
  for(i = 0; i < bNum; i++)
  {
    bMode = pbGrpOnTable[i + 1 + bOnIdx];
    vVfdSetMode(bMode, VFD_ON);
  } 
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdDiscGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_DISC_IDX_NS)

  vVfdGrpProc(_pbVfdGrpDisc, VFD_GRP_DISC_IDX_NS,
              _pbVfdGrpDiscOnTable, bIdx);

#endif  
}

  
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdTvGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_TV_IDX_NS)

  vVfdGrpProc(_pbVfdGrpTv, VFD_GRP_TV_IDX_NS,
              _pbVfdGrpTvOnTable, bIdx);

#endif  
} 


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdPScanGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_PSCAN_IDX_NS)

  vVfdGrpProc(_pbVfdGrpPScan, VFD_GRP_PSCAN_IDX_NS,
              _pbVfdGrpPScanOnTable, bIdx);

#endif
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdRepeatGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_REPEAT_IDX_NS)

  vVfdGrpProc(_pbVfdGrpRepeat, VFD_GRP_REPEAT_IDX_NS,
              _pbVfdGrpRepeatOnTable, bIdx);

#endif  
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdABGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_AB_IDX_NS)

  vVfdGrpProc(_pbVfdGrpAB, VFD_GRP_AB_IDX_NS,
              _pbVfdGrpABOnTable, bIdx);

#endif  
}
  

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdTrickGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_TRICK_IDX_NS)

  vVfdGrpProc(_pbVfdGrpTrick, VFD_GRP_TRICK_IDX_NS,
              _pbVfdGrpTrickOnTable, bIdx);

#endif  
} 


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdATypeGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_A_TYPE_IDX_NS)

  vVfdGrpProc(_pbVfdGrpAType, VFD_GRP_A_TYPE_IDX_NS,
              _pbVfdGrpATypeOnTable, bIdx);

#endif  
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdAChGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_A_CH_IDX_NS)

  vVfdGrpProc(_pbVfdGrpACh, VFD_GRP_A_CH_IDX_NS,
              _pbVfdGrpAChOnTable, bIdx);
  
#endif  
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdALRGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_A_LR_IDX_NS)

  vVfdGrpProc(_pbVfdGrpALR, VFD_GRP_A_LR_IDX_NS,
              _pbVfdGrpALROnTable, bIdx);

#endif
} 


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdAKeyGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_A_KEY_IDX_NS)

  vVfdGrpProc(_pbVfdGrpAKey, VFD_GRP_A_KEY_IDX_NS,
              _pbVfdGrpAKeyOnTable, bIdx);

#endif
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdPlayInfoGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_PLAYINFO_IDX_NS)

  vVfdGrpProc(_pbVfdGrpPlayInfo, VFD_GRP_PLAYINFO_IDX_NS,
              _pbVfdGrpPlayInfoOnTable, bIdx);

#endif
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdColonGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_COLON_IDX_NS)

  vVfdGrpProc(_pbVfdGrpColon, VFD_GRP_COLON_IDX_NS,
              _pbVfdGrpColonOnTable, bIdx);

#endif
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
static void vVfdMiscGrpProc(BYTE bIdx) large
{
#if (VFD_GRP_MISC_IDX_NS)
  BYTE i;
  BYTE bMode;

  if(bIdx == VFD_NULL)
  {
    return;
  }
  if(bIdx == VFD_GRP_OFF)
  {
    for(i = 0; i < VFD_GRP_MISC_IDX_NS; i++)
    {
      bMode = _pbVfdGrpMisc[i];  
      vVfdSetMode(bMode, VFD_OFF);
    }  
  }
  
  if((bIdx & VFD_MISC_OFF) == VFD_MISC_OFF)
  {
    bIdx = bIdx & (~VFD_MISC_OFF);
    bMode = _pbVfdGrpMisc[bIdx];
    vVfdSetMode(bMode, VFD_OFF);
  }
  else
  {
    bMode = _pbVfdGrpMisc[bIdx];
    vVfdSetMode(bMode, VFD_ON);
  }

#endif
}

#if  defined(DVD_RECEIVER) 
static void vVfdLockGrpProc(BYTE bIdx) large
{
  #if  (VFD_GRP_LOCK_IDX_NS)
  vVfdGrpProc(_pbVfdGrpLOCK, VFD_GRP_LOCK_IDX_NS,
              _pbVfdGrpLockOnTable, bIdx);
  #endif	
}

static void vVfdTunerGrpProc(BYTE bIdx) large
{
  #if  (VFD_GRP_TUNER_IDX_NS)
  vVfdGrpProc(_pbVfdGrpTUNER, VFD_GRP_TUNER_IDX_NS,
              _pbVfdGrpTUNEROnTable, bIdx);
  #endif
}
#endif

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdSymbol(WORD wSymbol) large
{
  BYTE bGrp = bVfdSymbolGrp(wSymbol);
  BYTE bIdx = bVfdSymbolIdx(wSymbol);

  switch(bGrp)
  {
    case VFD_GRP_DISC_TYPE:
      vVfdDiscGrpProc(bIdx);
      break;
    case VFD_GRP_TV:
      vVfdTvGrpProc(bIdx);
      break;
    case VFD_GRP_PSCAN:
      vVfdPScanGrpProc(bIdx);
      break;
    case VFD_GRP_REPEAT:
      vVfdRepeatGrpProc(bIdx);
      break;
    case VFD_GRP_AB:
      vVfdABGrpProc(bIdx);
      break;
    case VFD_GRP_TRICK:
      vVfdTrickGrpProc(bIdx);
      break;    
    case VFD_GRP_AUD_TYPE:
      vVfdATypeGrpProc(bIdx);
      break;
    case VFD_GRP_AUD_CH:
      vVfdAChGrpProc(bIdx);
      break;
    case VFD_GRP_AUD_LR:
      vVfdALRGrpProc(bIdx);
      break;
    case VFD_GRP_AUD_KEY:    
      vVfdAKeyGrpProc(bIdx);
      break;
    case VFD_GRP_PLAYINFO:    
      vVfdPlayInfoGrpProc(bIdx);
      break;
    case VFD_GRP_COLON:    
      vVfdColonGrpProc(bIdx);
      break;      
    case VFD_GRP_MISC:
      vVfdMiscGrpProc(bIdx);
      break;   
  #if  defined(DVD_RECEIVER)
    case VFD_GRP_LOCK:
      vVfdLockGrpProc(bIdx);    
      break; 
    case VFD_GRP_TUNER:
      vVfdTunerGrpProc(bIdx);
      break;    
  #endif    
  }
}



/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdMessage(BYTE bMsgIdx) large
{
  vVfdShowMsg(bMsgIdx, FALSE);
  vVfdSymbol(VFD_SYM_COLON_NONE);
  vVfdSymbol(VFD_SYM_PLAYINFO_NONE);  
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdMessageClr(void) large
{
  vVfdMessage(VFD_MESSAGE_CLR_ALL);
  vVfdSymbol(VFD_SYM_COLON_NONE);
  vVfdSymbol(VFD_SYM_PLAYINFO_NONE);
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
#if 0//DVD_AMP
void vVfdDirectMessage(BYTE bMsgIdx) large
{
  vVfdShowMsg(bMsgIdx, TRUE);
}
#endif

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdTempMessage(BYTE bMsgIdx, BYTE bTimeOut) large
{
#ifdef VFD_TEMP_TEXT
  vVfdShowTempMsg(bMsgIdx, bTimeOut);
  vVfdSymbol(VFD_SYM_COLON_NONE);
  vVfdSymbol(VFD_SYM_PLAYINFO_NONE);  
  if (_bPWRMode >= 4)   
     vVfdSymbol(VFD_SYM_TUNER_FMAM_OFF); 
#endif  
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdWord(BYTE bSegIdx, BYTE bNum, BOOL fgZeroExt) large
{
  if(bSegIdx >= VFD_SEG_MAX)
  {
    return;
  }
  if(bSegIdx == VFD_WORD_HR)
  {
    vVfdSegDisplay(VFD_WORD_HR, (bNum & 0x0f)?(bNum & 0x0f):SEG_CLEAN, FALSE); //BillDen
  }
  else if(bSegIdx == VFD_WORD_CH100)
  {
    vVfdSegDisplay(VFD_WORD_CH100, bNum & 0x0f, FALSE);
  }
  else
  {
    if((bNum & 0xF0) == 0)
    {
      if(fgZeroExt)
      {
        vVfdSegDisplay(bSegIdx, 0, FALSE);
      }
      else
      {
        vVfdSegDisplay(bSegIdx, SEG_CLEAN, FALSE);
      }
    }
    else
    {
      vVfdSegDisplay(bSegIdx, (bNum & 0xF0) >> 4, FALSE);
    }
    vVfdSegDisplay(bSegIdx+1, bNum & 0x0f, FALSE);
  }  
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdWordClr(BYTE bSegIdx) large
{
  if(bSegIdx >= VFD_SEG_MAX)
  {
    return;
  }
  
  if((bSegIdx == VFD_WORD_HR) || (bSegIdx == VFD_WORD_CH100))
  {
    vVfdSegDisplay(bSegIdx, SEG_CLEAN, FALSE);
  }
  else
  {
    vVfdSegDisplay(bSegIdx, SEG_CLEAN, FALSE);
    vVfdSegDisplay(bSegIdx + 1, SEG_CLEAN, FALSE);
  }
}


/************************************************************************
     Function :
  Description :
    Parameter :
    Return    : None
************************************************************************/
void vVfdBrightSwitch(BYTE bLevel) large
{
  switch(bLevel)
  {
    case VFD_BRIGHT_HIGH:
      vVfdSetPulseWidth(6, TRUE);
      break;
    case VFD_BRIGHT_LOW:
      vVfdSetPulseWidth(3, TRUE);
      break;
    default:
      vVfdSetPulseWidth(0, FALSE);
      break;      
  }
}


/************************************************************************
     Function :
  Description :
    Parameter :