vfd_hw.c

MTK 1389e版 MINI组合音响代码

{
  BYTE i;
  BYTE bCnt = 0;    // initial value to 0
  BYTE bLimit;

#if  defined(DVD_RECEIVER)
//   if (_bSysState != DVD_STATE)
   if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
      i = bVfdRefreshPos;
   else
#endif
       i = bSharedInfo(SI_VFD_UPDATE_WRIDX);
  bLimit = i;

  while(TRUE)
  {
    if(bCnt > VFD_MAX_UPDATE_CNT)
    {
#if defined(DVD_RECEIVER)
//      if (_bSysState != DVD_STATE)
      if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
         bVfdRefreshPos = i;
      else   
#endif   	
         vSetSharedInfo(SI_VFD_UPDATE_WRIDX, i);
      break;
    }

    if(fgVfdQueueMark(i))
    {
      vVfdWrite(i);
      bCnt++;
    }    

    i++;

    if(i == VFD_MAX_ADDR)
    {
      i = 0;    // reset i to 0, wrap around to the head of the ring buffer
    }
    
    if(i == bLimit)    // all loop finish
    {
      break;   // write index not change in this case
    }
  }

}

static void vVfdDirectWrite(BYTE bAddr, BYTE bData) large
{
  
  if(bAddr == 0xff)
  {
    return;
  }
  #ifdef 	RDS_USE_BU1924
	  sFlagI2C.fgbusy_VFD = TRUE;
	  SET_4094_PIN(SET_DTSCE);
  #endif
  vVfdStrobe(FALSE);
  vVfdUpdate(DATA_SET_INC) ;  // issue the write data command
  vVfdStrobe(TRUE);

  
  vVfdStrobe(FALSE);
  vVfdUpdate(ADDR_SET | bAddr);  // after setting the address, the strobe need not to pull high
  vVfdStrobe(FALSE);

  vVfdUpdate(bData);   // the final data is written , strobe pull high
  vVfdStrobe(TRUE);
  #ifdef 	RDS_USE_BU1924
  sFlagI2C.fgbusy_VFD = FALSE;
  #endif
}


static vVfdWriteQueue(BYTE bAddr, BYTE bData) large
{
  BYTE bShadowData;

  if(bAddr == 0xff)
  {
    return;
  }

#if defined(DVD_RECEIVER)
// if (_bSysState != DVD_STATE)
  if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
     bShadowData = pbVFDShadow[bAddr] ;
  else   
#endif
     bShadowData = bSharedInfo(SI_VFD_SHADOW_START + bAddr);

  if(bShadowData != bData)  // if it is the same as VFD display data, ignore this command
  {
#if defined(DVD_RECEIVER)  
//    if (_bSysState != DVD_STATE)
   if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
      pbVFDShadow[bAddr] = bData;
    else  
#endif	
       vSetSharedInfo(SI_VFD_TMPBUF_START + bAddr, bData);   // set the tmp buf data

    if(!fgVfdQueueMark(bAddr))  // the position is not in update queue already
    {
      vVfdSetQueueMark(bAddr);  // add the queue mark
    }
  }
  else
  {
#if defined(DVD_RECEIVER)  
//    if (_bSysState == DVD_STATE)
   if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
   {
       pbVFDShadow[bAddr]=bShadowData;
       if(!fgVfdQueueMark(bAddr))  // the position is not in update queue already
       {
         vVfdSetQueueMark(bAddr);  // add the queue mark
       }
   }
   else
#endif		
    { 
       vSetSharedInfo(SI_VFD_TMPBUF_START + bAddr, bShadowData);
       vVfdClrQueueMark(bAddr);
    }    
  } 
}

#ifdef VFD_LED      
static void vVfdLedUpdate(void) large
{
#if defined(DVD_RECEIVER)    //XIAO 03-05-23
//   if(_bSysState == TUNER_STATE && _fgLedOnOff)
//   {
//     _bLedPort = 0x80;
//     _fgLedOnOff = FALSE;
//   }
#endif	
  if(_bLedPort & 0x80)   // the msb indicate that the LED has something change
  {
    vVfdStrobe(FALSE);
    vVfdUpdate(DATA_SET_LED) ;  // issue the write data command
    vVfdStrobe(FALSE);
    vVfdUpdate(_bLedPort & 0x1f);   // 16311 at least 5 led ports
    vVfdStrobe(TRUE);
    _bLedPort &= 0x7f;   // mask the msb bit 
  }  
}

void vVfdLed(BYTE bLedNum, BOOL fgOn) large
{
  BYTE bLed;

#if defined(DVD_RECEIVER)
  if (fgOn)
  {
    _bLedPort = bLedNum | 0x80;	
  }
  else
  {
    _bLedPort = 0x8f; 
  }
#else
  bLed = _bLedPort;

  if(fgOn)
  {
    bLed |= (1 << bLedNum);
  }
  else
  {
    bLed |= 0x1f; //BillDen
    bLed &= (~(1 << bLedNum));
  }

  if(bLed != _bLedPort || _bPWRMode == SV_PWR_STANDBY) //BillDen
  {
    _bLedPort = (bLed | 0x80);    // set the msb to 1 to indicate LED change
  }
#endif  
}
#endif      

static void vVfdSequenceUpdate(BYTE bSize,BYTE *pbData, WORD wSegInfo) large
{
  BYTE bAddr = VFD_ADDR_LIMIT;
  BYTE bData;
  BYTE i;
  
  for(i = 0; i < bSize; i++)
  {
    i = i << 1;
    if(bAddr != (pbData[i]))   // write into share memory
    {    
      if(bAddr != VFD_ADDR_LIMIT)    // should update into tmpbuf first
      {
        vVfdWriteQueue(bAddr, bData);
      }      
      bAddr = pbData[i];      // initial address
#if defined(DVD_RECEIVER)  
//    if (_bSysState != DVD_STATE)
    if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
       bData = pbVFDShadow[bAddr];
    else
#endif	
      bData = bSharedInfo(SI_VFD_TMPBUF_START + bAddr);
    }

    if(wSegInfo & 0x1)
    {
      bData = bData | (pbData[i + 1]);
    }
    else
    {
      bData = bData & (~pbData[i + 1]);
    }

    wSegInfo >>= 1;
    i >>= 1;     // restore the i
  }
  // update into tmp buf here
  vVfdWriteQueue(bAddr, bData);  
}


static void vDirectSequenceUpd(BYTE bSize,BYTE *pbData, WORD wSegInfo) large
{
  BYTE bAddr;
  BYTE bData;
  BYTE i;
  BYTE bTotalCnt = 0;
  WORD wUpdateData;

  for(i = 0; i < QUEUEMARKSIZE; i++)
  {
    _bVfdQueueMark[i] = 0;
  }

  bAddr = pbData[0];
  vVfdSetQueueMark(bAddr);

  while(TRUE)
  {
    wUpdateData = wSegInfo;
    bData = 0;
    for(i = 0; i < bSize; i++)
    {
      i = i << 1;
      if(bAddr == (pbData[i]))    // if address match, then update
      {
        if(wUpdateData & 0x1)
        {
          bData = bData | (pbData[i + 1]);
        }
        else
        {
          bData = bData & (~pbData[i + 1]);
        }

        bTotalCnt++;
      }
      wUpdateData >>= 1;
      i >>= 1;     // restore the i
    }
    vVfdDirectWrite(bAddr, bData);
    // looking for the next address here

    if(bTotalCnt >= bSize)
    {
      break;
    }
    else
    {
      for(i = 0; i < bSize; i++)
      {
        bData = pbData[i << 1];
        if((bData != bAddr) && (!fgVfdQueueMark(bData)))
        {
          bAddr = bData;
          vVfdSetQueueMark(bAddr);
          break;
        }
      }
    }
  }
}




void vVfdTimerState(BOOL fgPowerDown) large    // 20 ms timer routine
{
  BYTE bCnt;

  
#if defined(DVD_RECEIVER)
  if (_bVfdTimer)
#else
  if((!fgPowerDown) && (_bVfdTimer))
#endif  
  {
    _bVfdTimer--;
    if(_bVfdTimer == 0)
    {
      vVfdRecoverSeg();
      return;
    }
  }

#if !defined(DVD_RECEIVER)
  if(fgPowerDown)
  {
    _bVfdTimer++;
    if(_bVfdTimer >= VFD_KEYSCAN_LOOP_CNT)
    {
      _bVfdTimer = 0;
      _bVfdState = VFD_STATE_KEY_SCAN;
    }
    else
    {
#ifdef VFD_LED //BillDen      
      if (_bVfdState == VFD_STATE_LED_UPDATE)
        vVfdLed(1, FALSE);
      else	
#endif      
      return;
    }
  }
#endif

  if(_fgVfdFlash)
  {
    vVfdFlashState();
  }

  switch(_bVfdState & 0xf)
  {
  #ifdef DVD_RECEIVER
    case VFD_STATE_CTL_MODE_SET:
    	vVfdStrobe(FALSE);         // begin to write the VFD command
        vVfdUpdate(VFD_CONTROL);
        _bVfdPulseLvl = VFD_CONTROL;
        vVfdStrobe(TRUE); 
        _bVfdState=VFD_STATE_MEM_UPDATE;
    	break;
  #endif  	
    case VFD_STATE_MEM_UPDATE:    
      vVfdUpdateState();
      bCnt = ((_bVfdState & 0xf0) >> 4) + 1;
      if(bCnt > VFD_KEYSCAN_LOOP_CNT)
      {
        _bVfdState = VFD_STATE_KEY_SCAN;
      }
      else
      {
        _bVfdState = (_bVfdState & 0xf) + (bCnt << 4);
      }
      break;
#ifdef VFD_LED      
    case VFD_STATE_LED_UPDATE:
      vVfdLedUpdate();
    #if  defined(DVD_RECEIVER)
      _bVfdState = VFD_STATE_CTL_MODE_SET;
    #else  
      _bVfdState = VFD_STATE_MEM_UPDATE;
    #endif  
      break;
#endif
    case VFD_STATE_KEY_SCAN:
      vVfdKeyScan(fgPowerDown);
#ifdef  VFD_LED
      _bVfdState = VFD_STATE_LED_UPDATE;
#else
      _bVfdState = VFD_STATE_MEM_UPDATE;
#endif
      break;
    default:
      _bVfdState = VFD_STATE_MEM_UPDATE;
      break;
  }
}

#ifdef TEST_VFD
extern void DRS232LogB(BYTE bV1, BYTE bV2, BYTE bV3, BYTE bV4);
#endif

static void vVfdKeyScan(BOOL fgPwrDown) large
{
  BYTE i,tempbuff=0xff;
  BOOL fgRelease = TRUE;
   static  xdata   BYTE  _bKeyData=0;
   static  xdata  BYTE   _bKeyBuff=0xff;
  if(_bVfdKeyScan != IR_NONE)  // the Key scan haven't been processed
  {
    return;
  }
#if  1
  vVfdStrobe(FALSE);         // begin to write the VFD command
  vVfdUpdate(KEY_SCAN);
  vVfdClk(TRUE);          // waiting for the Twait (1 us)

vI2CDelay2us(0x04);
  vVfdData(TRUE);          // pull the data inout line to high
 vI2CDelay2us(0x04);

  vVfdClk(TRUE);
vI2CDelay2us(0x04);

  for(i = 0; i < SCANSIZE; i++)      // how many bits we should scan here
  {
    vVfdClk(FALSE);
	vI2CDelay2us(0x04);
    vVfdClk(FALSE);   // may can be removed
    vI2CDelay2us(0x04);
    vVfdClk(TRUE);
vI2CDelay2us(0x04);

    // get the bits from the datout pin
    if(DATA_PIN)
    {
	if(_bKeyData)
		{
		//  if(!_fgVfdHold)
		      {
		      //  _bVfdKeyScan = _pbVfdKeyScan[i];
			tempbuff=_pbVfdKeyScan[i];
		        _fgVfdHold = TRUE;
		      }
	      		//fgRelease = FALSE;
		}
	else
		{
			if(!_fgVfdHold)