vfd_hw.~c

MTK 1389e版 MINI组合音响代码

  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;
  BOOL fgRelease = TRUE;

  if(_bVfdKeyScan != IR_NONE)  // the Key scan haven't been processed
  {
    return;
  }

  vVfdStrobe(FALSE);         // begin to write the VFD command
  vVfdUpdate(KEY_SCAN);
  vVfdClk(TRUE);          // waiting for the Twait (1 us)

  vVfdData(TRUE);          // pull the data inout line to high
  vVfdClk(TRUE);

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

    // get the bits from the datout pin
    if(DATA_PIN)
    {
      if(!_fgVfdHold)
      {
#ifdef TEST_VFD
        if(_bCon_Key_flag;)
           DRS232LogB(0x0f, 0x0f, i, i) ;
#endif
        _bVfdKeyScan = _pbVfdKeyScan[i];
        _fgVfdHold = TRUE;
      }
      fgRelease = FALSE;
    }

    vVfdClk(TRUE);   // to prevent clear clock to fast, maybe can be removed
  }
  vVfdStrobe(TRUE);     // pull the strobe to high

  if((_fgVfdHold) && (fgRelease))
  {
    _fgVfdHold = FALSE;   // release the LOCK here
  }

#if  !defined(DVD_RECEIVER) 
  if(fgPwrDown)
  {
    //re key-map here
    switch(_bVfdKeyScan)
    {
      case IR_POWER:
      case IR_EJECT:
        break;

      /* panel play key is power key */
      case IR_PLAY:
      case IR_PLAY_PAUSE:
      case IR_PLAY_ENTER:
        _bVfdKeyScan = IR_POWER;
        break;
      default:
        _bVfdKeyScan = IR_NONE;
        break;
    }
  }
#else
    if (_bSysState == DVD_STATE)
       return  ;
    //_fgVfdLongKeyProced,_bVfdLongKeyCounter
    if (_bVfdKeyScan == IR_FF)
    {
      if (_fgVfdLongKeyProced != 0x04 && _fgVfdLongKeyProced != 0x0f)   //First pushed the IR_FF key
      {
      	   _bVfdLongKeyCounter = 0;
      	   _fgVfdLongKeyProced = 0x04;
      }	   

      _bVfdKeyScan = IR_NONE;
    }	
    else if (_bVfdKeyScan == IR_FR)
    {
      if (_fgVfdLongKeyProced != 0x40 && _fgVfdLongKeyProced != 0xf0 )   //First pushed the IR_FF key
      {
      	   _bVfdLongKeyCounter = 0;       
      	   _fgVfdLongKeyProced = 0x40;
      }	   
      _bVfdKeyScan = IR_NONE;
    }
    else  if (!_fgVfdHold)  //because when _fgVfdHold is TRUE and fgRelease is FALSE, _bVfdKeyScan == IR_NONE
    {
         //判断原先是否有IR_FF 或 IR_FR 按下
         if (_fgVfdLongKeyProced == 0x04)
         {
             if (_bVfdLongKeyCounter >= LONGKEYTIME)
                 _bVfdKeyScan = IR_UPSEARCH ;
             else 
                 _bVfdKeyScan =  IR_FF;
         }    
         else if (_fgVfdLongKeyProced == 0x40)
         {
              if (_bVfdLongKeyCounter >= LONGKEYTIME)
                  _bVfdKeyScan = IR_DOWNSEARCH ;
              else 
                  _bVfdKeyScan =  IR_FR;
         }
         _bVfdLongKeyCounter = 0;
         _fgVfdLongKeyProced = FALSE;
     }	
     else if (_bVfdLongKeyCounter >= LONGKEYTIME)
     {
         if (_fgVfdLongKeyProced == 0x04)
             _bVfdKeyScan = IR_UPSEARCH ;
          else if (_fgVfdLongKeyProced == 0x40)   
             _bVfdKeyScan = IR_DOWNSEARCH ;
     }
#endif  
}


void vVfdClearAll(void) large
{
  BYTE i;

  if(_bVfdTimer) //BillDen
  {
    return;
  }

  for(i = 0; i <= MAX_VFD_ADDR; i++)
  {
#if defined(DVD_RECEIVER)
//    if (_bSysState != DVD_STATE)
   if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
       pbVFDShadow[i] = 0;   //When PowerDown Use these to replace shareinfo
    else
#endif  	
    vSetSharedInfo(SI_VFD_TMPBUF_START + i, 0);  // reset the tmpbuf to zero
    vVfdSetQueueMark(i);
//    vVfdWrite(i);                                // initial the display memory(the shadow will also initial here)
//    vSetSharedInfo(SI_VFD_SHADOW_START + i, 0);
//    vVfdDirectWrite(i, 0);
  }

  for(i = 0; i < VFD_SEG_BAK_SIZE; i++)
  {
  #if defined(DVD_RECEIVER)
//     if (_bSysState != DVD_STATE) 
     if (_bPWRMode < 4)     //#define SV_PWR_STANDBY 4
  #endif	
         vSetSharedInfo(SI_VFD_SEG_BAK + i, 0xff);
  }
 
  #if defined(DVD_RECEIVER)
//     if (_bSysState != DVD_STATE)
     if (_bPWRMode >= 4)     //#define SV_PWR_STANDBY 4
         bVfdRefreshPos = 0;
     else    
  #endif	
        vSetSharedInfo(SI_VFD_UPDATE_WRIDX, 0);
        
    
  _bVfdDiscPos = MAX_DISC_NUM;
  _bVfdTimer = 0;
}


void vVfdDirectClrAll(void) large
{
  BYTE i;

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

  for(i = 0; i <= MAX_VFD_ADDR; i++)
  {
    vVfdDirectWrite(i, 0);
  }

  _bVfdDiscPos = MAX_DISC_NUM;
  _bVfdTimer = 0;


}

// lvl : 0 for 1/16
//       1 for 2/16
//       2 for 4/16
//       3 for 10/16
//       4 for 11/16
//       5 for 12/16
//       6 for 13/16
//       7 for 14/16
void vVfdSetPulseWidth(BYTE bLvl, BOOL fgDispOn) large
{
  _bVfdPulseLvl = (((BYTE)fgDispOn << 3) + bLvl + 0x80);

  vVfdStrobe(FALSE);
  vVfdUpdate(_bVfdPulseLvl);
  vVfdStrobe(TRUE);
}

//======================= Test Vfd function============

#ifdef TEST_VFD
void vVfdSetConfigMode(void)large;
 void vVfdSetNode(BYTE bAddr, BYTE bData) large
{
  if(bAddr == 0xff)
  {
    return;
  }

  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);
}
void vVfdSetAllNode(BYTE bOnOff)large
{
  BYTE i;
     
  for(i = 0; i <= TEST_MAX_VFD_ADDR; i++)
  {
    vVfdSetNode(i,0xff * bOnOff);
  }
}

void vVfdSetConfigMode(void)large
{
   vVfdStrobe(FALSE);         // begin to write the VFD command
   vVfdUpdate(MODESET);
   vVfdStrobe(TRUE); 
   vVfdStrobe(FALSE);         // begin to write the VFD command
   vVfdUpdate(VFD_CONTROL);
   vVfdStrobe(TRUE); 
}
#endif
//================================
void vVfdFlash(void) large
{
  _bVfdPulseLvl ^= 0x8;
  
  vVfdStrobe(FALSE);
  vVfdUpdate(_bVfdPulseLvl);
  vVfdStrobe(TRUE);
}

static void vVfdFlashState(void) large
{
  _bVfdFlashTimer--;
  if(_bVfdFlashTimer == 0)
  {
    vVfdFlash();                        // should flash
  }

  if(_bVfdFlashTimer > FLASH_INTERVAL)  // for bug prevention
  { 
     // should be removed
    _bVfdFlashTimer = FLASH_INTERVAL;
  }
}


// bOption : 0xff => light on all
// bOption : 0    => off all wheel
// bOption : 1    => spin to the next position depends on the style
// bVfdWheelPos : 0xff => light on all, MAX_WHEEL_NUM => all off, others => the current spinning position
// initial , the wheel are all off, and _bVfdDiscPos set as MAX_WHEEL_NUM
void vVfdRotate(BYTE bOption) large
{
  BYTE bAddr = VFD_ADDR_LIMIT;
  BYTE bData;
  BYTE i;
  WORD wDiscData;

  if(MAX_DISC_NUM == 0)
  {
    return;
  }


  switch(bOption)
  {
    case VFD_DISC_LIGHT_ALL:
      wDiscData = 0xffff;
      _bVfdDiscPos = 0xff;
      break;
    case VFD_DISC_LIGHT_OFF:
      wDiscData = 0;
      _bVfdDiscPos = MAX_DISC_NUM;
      break;
    case VFD_DISC_SPIN:
      if(_bVfdDiscPos >= MAX_DISC_NUM)
      {
        _bVfdDiscPos = 0;
      }
      else
      {      
// may need add more option here      
#if (DISC_STYLE == 0) 
        _bVfdDiscPos++;
        if(_bVfdDiscPos == (MAX_DISC_NUM >> 1))
        {
          _bVfdDiscPos = 0;
        }
      }
      wDiscData = (1 << _bVfdDiscPos) + (1 << (_bVfdDiscPos + (MAX_DISC_NUM >> 1)));
#elif (DISC_STYLE == 1)  
        _bVfdDiscPos--;
        if(_bVfdDiscPos == 0xff)
        {
          _bVfdDiscPos = ((MAX_DISC_NUM >> 1) - 1);
        }
      }
      wDiscData = (1 << _bVfdDiscPos) + (1 << (_bVfdDiscPos + (MAX_DISC_NUM >> 1)));
#elif (DISC_STYLE == 2)
        _bVfdDiscPos++;
        if(_bVfdDiscPos == (MAX_DISC_NUM))
        {
          _bVfdDiscPos = 0;
        }
      }
      wDiscData = (~(1 << _bVfdDiscPos)) & 0xffff;
#elif (DISC_STYLE == 3)      
        _bVfdDiscPos--;
        if(_bVfdDiscPos == 0xff)
        {
          _bVfdDiscPos = MAX_DISC_NUM - 1;
        }
      }
      wDiscData = (~(1 << _bVfdDiscPos)) & 0xffff;
#elif (DISC_STYLE == 4)
        _bVfdDiscPos++;
        if(_bVfdDiscPos == (MAX_DISC_NUM >> 1))
        {
          _bVfdDiscPos = 0;
        }
      }
      wDiscData = (1 << _bVfdDiscPos) + (1 << (_bVfdDiscPos + (MAX_DISC_NUM >> 1)));
      wDiscData = (~wDiscData) & 0xffff;
#endif
      break;
    default:
      break;
  }

  vVfdSequenceUpdate(MAX_DISC_NUM, _pbVfdDisc, wDiscData);
}

#else

static code BYTE pbVfdHw[1] = { 0 };

void vVfdInit(void) large
{
  _bVfdState = pbVfdHw[0];
  _bVfdKeyScan = IR_NONE;
}

void vVfdPwrDownInit(BOOL fgCleanAll) large
{
  _bVfdState = pbVfdHw[0];
  _bVfdKeyScan = IR_NONE;  
}

void vVfdTimerState(BOOL fgPowerDown) large    // 20 ms timer routine
{
  _bVfdKeyScan = IR_NONE;   // always IR_NONE
}

#endif