auto.c

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

          {
             shtemp5 = shtemp2 - shtemp1 + 1;
             shtemp6 = autoInfo[ModeCounter].width_def;
             if( (shtemp5 <= (shtemp6+4)) && (shtemp5 >= (shtemp6-4)) )
                HPosOK = 1;
          }
       }

       if( VPosOK==0 )
       {
           if( (svtemp1==svtemp3) && (svtemp2==svtemp4) )
           {
             shtemp5 = svtemp2 - svtemp1 + 1;
             shtemp6 = autoInfo[ModeCounter].length_def;
             if( (shtemp5 <= (shtemp6+4)) && (shtemp5 >= (shtemp6-4)) )
                VPosOK = 1;
           }
       }
       if( (HPosOK==1) && (VPosOK==1) )
           break;
    }

    if( HPosOK==0 )   /* no same value read */
    {
       /* select the biggest value */
       if( shtemp1<shtemp3 )   shtemp1 = shtemp3;
       if( shtemp2<shtemp4 )   shtemp2 = shtemp4;
    }
    shtemp2 = shtemp2 - shtemp1 + 1;
    if( shtemp1 != 0x07FF )
    {
       if( (ModeCounter==DosModeTable[0][0]) ||  /* 720x400/70Hz */
           ((shtemp2+8) >= autoInfo[ModeCounter].width_def) )
       {
          if( ModeInputport[ModeCounter]==2 )
          {
             HorPositionValue = shtemp1 + 1;
          }
          else if( ModeInputport[ModeCounter]==1 )  /* single port 2 dual port */
          {
             HorPositionValue = shtemp1 - 1;
          }
          else /* ModeInputport[ModeCounter]==0 */
          {
             HorPositionValue = shtemp1 - 1;
          }
          HorPositionValue += VPositionValue[ModeCounter][1];
       
          // Set H position
          SlvAdr    = ZURAC_ADDRESS;
          ByteCnt   = 3;
          TrmBuf[0] = ZRC_IH_ASTART;      //  input horizontal active start
          TrmBuf[1] = LOBYTE(HorPositionValue);
          TrmBuf[2] = HIBYTE(HorPositionValue);
          SendData();
       }
    }

    if( VPosOK==0 )   /* no same value read */
    {
       /* select the biggest value */
       if( svtemp1<svtemp3 )   svtemp1 = svtemp3;
       if( svtemp2<svtemp4 )   svtemp2 = svtemp4;
    }
    svtemp2 = svtemp2 - svtemp1 + 1;
    if( (svtemp2+4) >= autoInfo[ModeCounter].length_def )
    {
       VerPositionValue = svtemp1;
       if( VerPositionValue > 1 )
       {
          VerPositionValue -= VPositionValue[ModeCounter][0];
          // Set V position
          SlvAdr    = ZURAC_ADDRESS;
          ByteCnt   = 3;
          TrmBuf[0] = ZRC_IV_ASTART;      // input vertical active start
          TrmBuf[1] = LOBYTE(VerPositionValue);
          TrmBuf[2] = HIBYTE(VerPositionValue);
          SendData();
       }
    }

    return;
#else
    Bool  HPosOK,VPosOK;
    Byte  DATA  i;
    Word  IDATA shtemp1,shtemp2;
    Word  IDATA svtemp1,svtemp2;

    HPosOK = VPosOK = 0;
    auto_min_threshold( MIN_THRESHOLD );
    for( i=0; i<10; i++)
    {
       auto_set_mline(0);
       auto_wait_mline(0);
       auto_get_zurac(ZRC_AVSTART,8);
       if( HPosOK==0 )
       {
          shtemp1 = MAKEWORD(TrmBuf[5],TrmBuf[4]);
          shtemp2 = MAKEWORD(TrmBuf[7],TrmBuf[6]);
          shtemp2 = shtemp2 - shtemp1 + 1;
          if( shtemp1 != 0x07FF )   HPosOK = 1;
       }
       if( VPosOK==0 )
       {
           svtemp1 = MAKEWORD(TrmBuf[1],TrmBuf[0]);
           svtemp2 = MAKEWORD(TrmBuf[3],TrmBuf[2]);
           svtemp2 = svtemp2 - svtemp1 + 1;
           if( svtemp1 != 0x07FF )   VPosOK = 1;
       }
       if( (HPosOK==1) && (VPosOK==1) )
           break;
    }

    if( (ModeCounter==DosModeTable[0][0]) ||  /* 720x400/70Hz */
        ((shtemp2+8) >= autoInfo[ModeCounter].width_def) )
    {
       if( ModeInputport[ModeCounter]==2 )
       {
          HorPositionValue = shtemp1 + 1;
       }
       else if( ModeInputport[ModeCounter]==1 )  /* single port 2 dual port */
       {
          HorPositionValue = shtemp1 - 1;
       }
       else /* ModeInputport[ModeCounter]==0 */
       {
          HorPositionValue = shtemp1 - 1;
       }
       HorPositionValue += VPositionValue[ModeCounter][1];
       // Set H position
       SlvAdr    = ZURAC_ADDRESS;
       ByteCnt   = 3;
       TrmBuf[0] = ZRC_IH_ASTART;      //  input horizontal active start
       TrmBuf[1] = LOBYTE(HorPositionValue);
       TrmBuf[2] = HIBYTE(HorPositionValue);
       SendData();
    }

    if( (svtemp2+4) >= autoInfo[ModeCounter].length_def )
    {
       VerPositionValue = svtemp1;
       if( VerPositionValue > 1 )
       {
          VerPositionValue -= VPositionValue[ModeCounter][0];
       }
       // Set V position
       SlvAdr    = ZURAC_ADDRESS;
       ByteCnt   = 3;
       TrmBuf[0] = ZRC_IV_ASTART;      // input vertical active start
       TrmBuf[1] = LOBYTE(VerPositionValue);
       TrmBuf[2] = HIBYTE(VerPositionValue);
//algu 1107       SendData();
    }

    return;
#endif
}   

// Word auto_get_hpos()
// {
//     Byte  DATA  i;
//     Word  IDATA shtemp1,shtemp2;
//
//     auto_min_threshold( MIN_THRESHOLD );
//     for( i=0; i<10; i++)
//     {
//        auto_set_mline(0);
//        auto_wait_mline(0);
//        auto_get_zurac(ZRC_AVSTART,8);
//
//        shtemp1 = MAKEWORD(TrmBuf[5],TrmBuf[4]);
//        shtemp2 = MAKEWORD(TrmBuf[7],TrmBuf[6]);
//        if( shtemp1 != 0x07FF )   break;
//     }
//
//
//     if( ModeInputport[ModeCounter]==2 )
//     {
//        shtemp2 = shtemp1 + 1;
//     }
//     else if( ModeInputport[ModeCounter]==1 )  /* single port 2 dual port */
//     {
//        shtemp2 = shtemp1 - 1;
//     }
//     else /* ModeInputport[ModeCounter]==0 */
//     {
//        shtemp2 = shtemp1 - 1;
//     }
//     shtemp2 += VPositionValue[ModeCounter][1];
//
//     return shtemp2;
// }
/***************************************************************************
  Function : auto_coarse_phase
  Purpose  : get the best ADC sampling phase
  Input    :
  Output   : Byte  PhaseValue          adjusted phase value
  External : Byte  TruBuf[]            i2c i/o buffer
  Return   : Horizontal Length
***************************************************************************/
Word  auto_coarse_phase()
{
#if (GOOD_AUTO==0)
    Byte i,j;
    Word IDATA acpv1,acpv2;
    Long IDATA cplval0,cplval1;

    auto_set_asod();
    cplval1 = 0xFFFFFFFF;
    for( i=4; i<32; i+=8 )
    {
       auto_adc_phase( i );
       auto_wait_asod();
       auto_get_zurac(ZRC_ASUM,8);

       cplval0 = 0;
       for(j=0; j<3; j++)
          cplval0 = cplval0 * 256 + TrmBuf[j];

       for(j=0; j<4; j++)
       {
          if( TrmBuf[j]!=TrmBuf[4+j] )
          {
             cplval0 /= 2;          /* error,ASUM and ASOD not euqal */
             break;
          }
       }

       if( cplval0 < cplval1 )
       {
          cplval1 = cplval0;
          PhaseValue = i;          /* best phase, maximum ASUM */
       }
    }
    PhaseValue = (PhaseValue+16) % 32;

    /***********************************************************/
    auto_adc_clockphase();
    auto_min_threshold( MIN_THRESHOLD );
    for(i=0; i<8; i++)
    {
       auto_set_mline(0);
       auto_wait_mline(0);
       auto_get_zurac(ZRC_AMLHSTA,4);
       acpv1 = MAKEWORD(TrmBuf[3],TrmBuf[2]) - MAKEWORD(TrmBuf[1],TrmBuf[0]) + 1;

       auto_set_mline(0);
       auto_wait_mline(0);
       auto_get_zurac(ZRC_AMLHSTA,4);
       acpv2 = MAKEWORD(TrmBuf[3],TrmBuf[2]) - MAKEWORD(TrmBuf[1],TrmBuf[0]) + 1;

       if( acpv1==acpv2 )
          break;
    }

    return  acpv1;
#else
    Byte i,j;
    Word IDATA acpv;
    Long IDATA cplval0,cplval1;

    auto_set_asod();
    cplval1 = 0xFFFFFFFF;
    for( i=4; i<32; i+=8 )
    {
       auto_adc_phase( i );
       auto_wait_asod();
       auto_get_zurac(ZRC_ASUM,8);

       cplval0 = 0;
       for(j=0; j<3; j++)
          cplval0 = cplval0 * 256 + TrmBuf[j];

       if( cplval0 < cplval1 )
       {
          cplval1 = cplval0;
          PhaseValue = i;          /* best phase, maximum ASUM */
       }
    }
    PhaseValue = (PhaseValue+16) % 32;

    /***********************************************************/
    auto_adc_clockphase();
    auto_min_threshold( MIN_THRESHOLD );
    auto_set_mline(0);
    auto_wait_mline(0);
    auto_get_zurac(ZRC_AMLHSTA,4);
    acpv = MAKEWORD(TrmBuf[3],TrmBuf[2]) - MAKEWORD(TrmBuf[1],TrmBuf[0]) + 1;

    return  acpv;
#endif
}

#if  ( FINETUNE_PHASE && (SMOOTH_PHASE>=1) )
Word  auto_get_width()
{
 #if (GOOD_AUTO==0)
    Byte i;    
    Word IDATA acpv1,acpv2;

    auto_min_threshold( MIN_THRESHOLD );
    for(i=0; i<8; i++)
    {
       auto_set_mline(0);     
       auto_wait_mline(0);
       auto_get_zurac(ZRC_AMLHSTA,4);
       acpv1 = MAKEWORD(TrmBuf[3],TrmBuf[2]) - MAKEWORD(TrmBuf[1],TrmBuf[0]) + 1;
       
       auto_set_mline(0);     
       auto_wait_mline(0);
       auto_get_zurac(ZRC_AMLHSTA,4);       
       acpv2 = MAKEWORD(TrmBuf[3],TrmBuf[2]) - MAKEWORD(TrmBuf[1],TrmBuf[0]) + 1;
       
       if( acpv1==acpv2 )
          break;
    }  
    return  acpv1;
 #else
    Word IDATA acpv1;
    
    auto_min_threshold( MIN_THRESHOLD );
    auto_set_mline(0);     
    auto_wait_mline(0);
    auto_get_zurac(ZRC_AMLHSTA,4);
    acpv1 = MAKEWORD(TrmBuf[3],TrmBuf[2]) - MAKEWORD(TrmBuf[1],TrmBuf[0]) + 1;  
    return  acpv1;
 #endif
}
#endif
/***************************************************************************
  Function : auto_get_asod
  Purpose  : get best_sod - worst_sod
  Input    :
  Output   :
  External : Byte  TruBuf[]            i2c i/o buffer
             Byte  SlvAdr              i2c slave address
             Byte  ByteCnt             i2c i/o byte count
  Return   :
***************************************************************************/
Long auto_get_asod(void)
{
#if (GOOD_AUTO==0)
    Byte i,j;
    Long IDATA bplval0,bplval1,bplval2,bplval3;

    auto_set_asod();
    bplval2 = 0xFFFFFFFF;
    bplval1 = 0;
    for( i=1; i<32; i+=2 )
    {
       if( isVGAabsent() )   break;
       auto_adc_phase( i );
       auto_short_delay(2);

       auto_wait_asod();
       auto_get_zurac(ZRC_ASUM,8);

       bplval0 = 0;
       for(j=0; j<3; j++)
          bplval0 = bplval0 * 256 + TrmBuf[j];

       for(j=0; j<4; j++)
          if( TrmBuf[j]!=TrmBuf[4+j] )   break;
       if( j!=4 )
       {
          auto_wait_asod();
          auto_get_zurac(ZRC_ASUM,8);
          bplval3 = 0;
          for(j=0; j<3; j++)
             bplval3 = bplval3 * 256 + TrmBuf[j];

          for(j=0; j<4; j++)
             if( TrmBuf[j]!=TrmBuf[4+j] )  break;

          if( j==4 )
          {
             bplval0 = bplval3;
          }
          else
          {
             if( bplval0 > bplval3 )
                bplval0 = bplval3 / 2;
             else
                bplval0 = bplval0 / 2;
          }
       }

       if( bplval0 < bplval2 )
       {
          bplval2 = bplval0;       /* worst phase,minimum ASUM */
       }
       if( bplval0 > bplval1 )
       {
          bplval1 = bplval0;
          PhaseValue = i;          /* best phase, maximum ASUM */
       }
    }
    auto_adc_phase( PhaseValue );
    bplval0 = bplval1 - bplval2;   /* best_sod - worst_sod */
    bplval0 = (bplval1 << 3) + bplval0;

    return bplval0;
#else  /* of GOOD_AUTO==1 */
    Byte i,j;
    Long IDATA bplval0,bplval1,bplval2;

    auto_set_asod();
    bplval2 = 0xFFFFFFFF;
    bplval1 = 0;
    for( i=1; i<32; i+=2 )
    {
       if( isVGAabsent() )   break;
       auto_adc_phase( i );
       auto_wait_asod();
       auto_get_zurac(ZRC_ASUM,4);

       bplval0 = 0;
       for(j=0; j<3; j++)
          bplval0 = bplval0 * 256 + TrmBuf[j];

       if( bplval0 < bplval2 )
       {
          bplval2 = bplval0;       /* worst phase,minimum ASUM */
       }
       if( bplval0 > bplval1 )
       {
          bplval1 = bplval0;
          PhaseValue = i;          /* best phase, maximum ASUM */
       }