auto.c

keil C51 LCD 驱动源码,其中还有I2C驱动,ADC驱动,键盘操作等,是一个完整的keil源代码,供大家参考

             Byte  ByteCnt             i2c i/o byte count
  Return   :
***************************************************************************/
void auto_min_threshold(Byte min_val)
{
    /* set minimum threhold value */
    SlvAdr    = ZURAC_ADDRESS;
    ByteCnt   = 3;
    TrmBuf[0] = ZRC_ARGB_MAX;
    TrmBuf[1] = max_threhold;
    TrmBuf[2] = min_val;
    SendData();
    return;
}
/***************************************************************************
  Function : auto_set_mline
  Purpose  : Set the Zurac M-Line
  Input    : Word  mline               value for M-Line
  Output   :
  External : Byte  TruBuf[]            i2c i/o buffer
             Byte  SlvAdr              i2c slave address
             Byte  ByteCnt             i2c i/o byte count
  Return   :
***************************************************************************/
void auto_set_mline(Word mline)
{
    SlvAdr    = ZURAC_ADDRESS;
    ByteCnt   = 3;
    TrmBuf[0] = ZRC_AMLNUM;
    TrmBuf[1] = LOBYTE(mline);
    TrmBuf[2] = HIBYTE(mline);
    SendData();

    ByteCnt   = 3;
    TrmBuf[0] = ZRC_SODCTR;
    TrmBuf[1] = 0x10;
    TrmBuf[2] = 0x00;
    SendData();

    mline     = autoInfo[ModeCounter].sync_width + autoInfo[ModeCounter].back_porch/8;
    ByteCnt   = 3;
    TrmBuf[0] = ZRC_AH_START;
    TrmBuf[1] = LOBYTE( mline );
    TrmBuf[2] = HIBYTE( mline );
    SendData();
}
void auto_set_fline(Word fline)
{
    fline += 2;   /* offset is 2 line */

    SlvAdr    = ZURAC_ADDRESS;
    ByteCnt   = 5;
    TrmBuf[0] = 0x82;
    TrmBuf[1] = LOBYTE(fline);
    TrmBuf[2] = HIBYTE(fline);
    TrmBuf[3] = 0x00;
    TrmBuf[4] = 0x00;
    SendData();

    ByteCnt   = 2;
    TrmBuf[0] = 0x03;
    TrmBuf[1] = (autoBval & 0x7F);   /* Bit[7]==LO */
    SendData();

    ByteCnt   = 2;
    TrmBuf[0] = 0x03;
    TrmBuf[1] = (autoBval | 0x80);   /* Bit[7]==HI */
    SendData();

    ByteCnt   = 2;
    TrmBuf[0] = 0x03;
    TrmBuf[1] = (autoBval & 0x7F);   /* Bit[7]==LO */
    SendData();
}
/***************************************************************************
  Function : auto_set_asod
  Purpose  : Set the Zurac sod boundary
  Input    :
  Output   :
  External : Byte  TruBuf[]            i2c i/o buffer
             Byte  SlvAdr              i2c slave address
             Byte  ByteCnt             i2c i/o byte count
  Return   :
***************************************************************************/
void  auto_set_asod()
{
    Word IDATA asaval,asaval2;

    SlvAdr    = ZURAC_ADDRESS;
    ByteCnt   = 9;
    TrmBuf[0] = ZRC_AWVSTART;
    asaval    = 10;                                          // y1
    TrmBuf[1] = LOBYTE(asaval);
    TrmBuf[2] = HIBYTE(asaval);

    asaval    = autoInfo[ModeCounter].length_def + 128;      // y2
    TrmBuf[5] = LOBYTE(asaval);
    TrmBuf[6] = HIBYTE(asaval);

    asaval2   = autoInfo[ModeCounter].sync_width + 6;
    asaval    = asaval2;                                     //x1
    if( ModeInputport[ModeCounter]==2 )  asaval = asaval / 2;
    TrmBuf[3] = LOBYTE(asaval);
    TrmBuf[4] = HIBYTE(asaval);

    asaval    = asaval2 + autoInfo[ModeCounter].clock_def + 128;   // x2
    if( ModeInputport[ModeCounter]==2 )  asaval = asaval / 2;
    TrmBuf[7] = LOBYTE(asaval);
    TrmBuf[8] = HIBYTE(asaval);
    SendData();

    ByteCnt   = 3;
    TrmBuf[0] = ZRC_SODCTR;
    TrmBuf[1] = 0x11;
    TrmBuf[2] = 0x40;
    SendData();
}
//tonny void  auto_set_asum()
//tonny {
//tonny     Word IDATA asaval,asaval2;
//tonny
//tonny     SlvAdr    = ZURAC_ADDRESS;
//tonny     ByteCnt   = 9;
//tonny     TrmBuf[0] = ZRC_AWVSTART;
//tonny     asaval    = 10;                                          // y1
//tonny     TrmBuf[1] = LOBYTE(asaval);
//tonny     TrmBuf[2] = HIBYTE(asaval);
//tonny
//tonny     asaval    = autoInfo[ModeCounter].length_def + 128;      // y2
//tonny     TrmBuf[5] = LOBYTE(asaval);
//tonny     TrmBuf[6] = HIBYTE(asaval);
//tonny
//tonny     asaval2   = autoInfo[ModeCounter].sync_width + 6;
//tonny     asaval    = asaval2;                                     //x1
//tonny     if( ModeInputport[ModeCounter]==2 )  asaval = asaval / 2;
//tonny     TrmBuf[3] = LOBYTE(asaval);
//tonny     TrmBuf[4] = HIBYTE(asaval);
//tonny
//tonny     asaval    = asaval2 + autoInfo[ModeCounter].clock_def + 128;   // x2
//tonny     if( ModeInputport[ModeCounter]==2 )  asaval = asaval / 2;
//tonny     TrmBuf[7] = LOBYTE(asaval);
//tonny     TrmBuf[8] = HIBYTE(asaval);
//tonny     SendData();
//tonny
//tonny     ByteCnt   = 3;
//tonny     TrmBuf[0] = ZRC_SODCTR;
//tonny     TrmBuf[1] = 0x10;
//tonny     TrmBuf[2] = 0x40;
//tonny     SendData();
//tonny }
/***************************************************************************
  Function : auto_wait_mline
  Purpose  : Wait for Zurac data ready
  Input    :
  Output   :
  External : Byte  TruBuf[]            i2c i/o buffer
  Return   :
***************************************************************************/
Bool auto_wait_mline(Word mline)
{
#if (GOOD_AUTO==0)
    Byte  i,j;

    ZuracWriteByte(ZRC_STATUS1,0x0F);         // clear Mline status
    for(i=0; i<10; i++)
    {
       ZuracWriteByte(ZRC_STATUS1,0x06);
       auto_short_delay(12);                  // Delay 12 ms
       for(j=0; j<48; j++)
       {
          auto_get_zurac(ZRC_STATUS1,1);
          if( (TrmBuf[0] & 0x01)!=0 )         // Only check M_Line
             break;
          auto_short_delay(1);                // Delay 1 ms
       }
       auto_get_zurac(ZRC_AMLHSTA,2);
       if( TrmBuf[0]!=0xFF && TrmBuf[1]!=0x07 && j!=48 )   // no Mline action been performed
           break;

       ZuracWriteByte(ZRC_STATUS1,0x0F);      // clear Mline status

       SlvAdr    = ZURAC_ADDRESS;             // write Mline address
       ByteCnt   = 3;
       TrmBuf[0] = ZRC_AMLNUM;
       TrmBuf[1] = LOBYTE(mline);
       TrmBuf[2] = HIBYTE(mline);
       SendData();
       auto_short_delay(1);
    }
    if( i==10 && j==48 )
       return FALSE;
    return TRUE;
#else
    Byte  i;
    mline = 0; // Alf. avoid warning.
    ZuracWriteByte(ZRC_STATUS1,0x0F);      // clear Mline status
    ZuracWriteByte(ZRC_STATUS1,0x0E);
    auto_short_delay(12);                  // Delay 12 ms
    for(i=0; i<48; i++)
    {
       auto_get_zurac(ZRC_STATUS1,1);
       if( (TrmBuf[0] & 0x01)!=0 )         // Only check M_Line
          break;
       auto_short_delay(1);                // Delay 1 ms
    }
    return TRUE;
#endif
}
Bool auto_wait_fline()
{
    ZuracWriteByte(0x0A,0x1A);      // freeze
    auto_short_delay(40);
    return TRUE;
}
Bool auto_free_fline()
{
    ZuracWriteByte(0x0A,0x0A);      // normal
    return TRUE;
}
/***************************************************************************
***************************************************************************/
Bool auto_wait_asod()
{
#if (GOOD_AUTO==0)
    Byte  i,j;

    ZuracWriteByte(ZRC_STATUS1,0x0F);      // clear status
    for(i=0; i<3; i++)
    {
       ZuracWriteByte(ZRC_STATUS1,0x0D);
       auto_short_delay(12);               // Delay 12 ms
       for(j=0; j<64; j++)
       {
          auto_get_zurac(ZRC_STATUS1,1);
          if( (TrmBuf[0] & 0x02)!=0 )      // Only check ASOD
              break;
          auto_short_delay(1);             // Delay 1 ms
       }
       if( j!=64 )  break;
       ZuracWriteByte(ZRC_STATUS1,0x0F);   // clear Mline status
       auto_short_delay(1);
    }
    return TRUE;
#else
    Byte  i;
    ZuracWriteByte(ZRC_STATUS1,0x0F);   // clear status
    ZuracWriteByte(ZRC_STATUS1,0x0D);
    auto_short_delay(12);               // Delay 12 ms
    for(i=0; i<64; i++)
    {
       auto_get_zurac(ZRC_STATUS1,1);
       if( (TrmBuf[0] & 0x02)!=0 )      // Only check ASOD
           break;
       auto_short_delay(1);             // Delay 1 ms
    }
    return TRUE;
#endif
}
/***************************************************************************
  Function : auto_abs_word
  Purpose  : absolute value function
  Input    : Word  value1              value to get its absolute value
  Output   :
  External :
  Return   : Word                      absolute value of input value
***************************************************************************/
//tonny static Word auto_abs_word(Word value1)
//tonny {
//tonny     if( value1 >= 0x8000 )
//tonny     {
//tonny        value1 = (~value1) + 1;
//tonny     }
//tonny     return value1;
//tonny }
/************************************************************************/
/************************************************************************/
void auto_short_delay(Byte count)
{
    Byte  i,j;

    for(i=0; i<count; i++)
       for(j=0; j<=142; j++)
          _nop_();
}

/***************************************************************************
  Function : white_balance
  Purpose  : set AD9884 gain and offset value
  Input    :
  Output   : Byte  ContrastValueZ      contrast value for Zurac
             Byte  BrightnessValueZ    brightness value for Zurac
             Byte  ContrastValue       contrast adjust value for ADC
             Byte  BrightnessValue     brightness value for BackLight
             Byte  U1RgainValue        red   gain   value for ADC
             Byte  U1GgainValue        green gain   value for ADC
             Byte  U1BgainValue        blue  gain   value for ADC
             Byte  M_BrightnessR       red   offset value for ADC
             Byte  M_BrightnessG       green offset value for ADC
             Byte  M_BrightnessB       blue  offset value for ADC
  External : Byte  TruBuf[]            i2c i/o buffer
             Byte  SlvAdr              i2c slave address
             Byte  ByteCnt             i2c i/o byte count
             Byte  ModeCounter         display mode index
           struct  autoInfo[]          default value for auto-adjust
  Return   : Bool                      TRUE for success
***************************************************************************/
Bool white_balance()
{
#if (ADC_CHIP==ADI_9884 || ADC_CHIP==FMS_9884 || ADC_CHIP==FMS_9874 || \
     ADC_CHIP==TMI_9884 || ADC_CHIP==SG_9884 )
    Byte i,wbtemp1;
    Byte IDATA  wbGain[3],wbOffset[3];
    Word IDATA  mline;

    autoBval = TrmBuf[0];    /* save Reg[03] for later use */
    auto_zurac_preset();

    SlvAdr     = AD9884_ADDR;
    ByteCnt    = 7;
    TrmBuf[0]  = 0x02;
    TrmBuf[1]  = 102;
    TrmBuf[2]  = 102;
    TrmBuf[3]  = 102;
    TrmBuf[4]  = 0x80;
    TrmBuf[5]  = 0x80;
    TrmBuf[6]  = 0x80;
    SendData();

    SlvAdr    = ZURAC_ADDRESS;
    ByteCnt   = 3;
    TrmBuf[0] = 0x10;
    TrmBuf[1] = LOBYTE(HorPositionValue-2);
    TrmBuf[2] = HIBYTE(HorPositionValue-2);
    SendData();

    /***********************************************************/
    /* Offset adjust                                           */
    /***********************************************************/
    for(i=0; i<3; i++)
       wbOffset[i] = 32;    /* middle offset */
    wbtemp1 = 16;
    while( wbtemp1!=0 )
    {
          SlvAdr    = AD9884_ADDR;
          ByteCnt   = 4;
          TrmBuf[0] = 0x05;
          TrmBuf[1] = wbOffset[0] << 2;
          TrmBuf[2] = wbOffset[1] << 2;
          TrmBuf[3] = wbOffset[2] << 2;
          SendData();
          auto_short_delay(40);

          for(i=0;i<32;i++)
          {
             auto_set_fline(mline);
             auto_wait_fline();
             auto_get_zurac(0x86,3);

             TrmBuf[8]  = TrmBuf[0];
             TrmBuf[9]  = TrmBuf[1];
             TrmBuf[10] = TrmBuf[2];

             auto_short_delay(40);

             auto_set_fline(mline);
             auto_wait_fline();
             auto_get_zurac(0x86,3);
             if( (TrmBuf[0]>0 && TrmBuf[8]==0)  || (TrmBuf[0]==0 && TrmBuf[8]>0)  )  continue;
             if( (TrmBuf[1]>0 && TrmBuf[9]==0)  || (TrmBuf[1]==0 && TrmBuf[9]>0)  )  continue;
             if( (TrmBuf[2]>0 && TrmBuf[10]==0) || (TrmBuf[2]==0 && TrmBuf[10]>0) )  continue;
             break;
          }
   #if  SWAP_RED_BLUE
          if( TrmBuf[2] > 1 )  wbOffset[0] += wbtemp1;
          else                 wbOffset[0] -= wbtemp1;
          if( TrmBuf[1] > 1 )  wbOffset[1] += wbtemp1;
          else                 wbOffset[1] -= wbtemp1;
          if( TrmBuf[0] > 1 )  wbOffset[2] += wbtemp1;
          else                 wbOffset[2] -= wbtemp1;
   #else
          if( TrmBuf[0] > 1 )  wbOffset[0] += wbtemp1;
          else                 wbOffset[0] -= wbtemp1;
          if( TrmBuf[1] > 1 )  wbOffset[1] += wbtemp1;
          else                 wbOffset[1] -= wbtemp1;
          if( TrmBuf[2] > 1 )  wbOffset[2] += wbtemp1;
          else                 wbOffset[2] -= wbtemp1;
   #endif
          auto_free_fline();
          wbtemp1 /= 2;
    }

    /**************************************************************/
    /* Gain Adjust                                                */
    /**************************************************************/
    for(i=0; i<3; i++)
       wbGain[i] = 128;    /* middle gain */
    wbtemp1 = 64;
    while( wbtemp1!=0 )
    {
          SlvAdr    = AD9884_ADDR;
          ByteCnt   = 4;
          TrmBuf[0] = 0x02;
          TrmBuf[1] = wbGain[0];
          TrmBuf[2] = wbGain[1];
          TrmBuf[3] = wbGain[2];
          SendData();
          auto_short_delay(40);

          for(i=0;i<32;i++)
          {
             auto_set_mline(0);
             auto_wait_mline(0);
             auto_get_zurac(0xAC,1);
             TrmBuf[8] = TrmBuf[0];

             auto_short_delay(40);

             auto_set_mline(0);
             auto_wait_mline(0);
             auto_get_zurac(0xAC,1);
             if( TrmBuf[0]==TrmBuf[8] )
                 break;
          }
   #if  SWAP_RED_BLUE
          if( TrmBuf[0] & 0x01 )  wbGain[0] += wbtemp1;
          else                    wbGain[0] -= wbtemp1;
          if( TrmBuf[0] & 0x02 )  wbGain[1] += w