ttfc.c

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

       {
          wtemp = wtemp / 2;
       }
       TrmBuf[1] = LOBYTE(wtemp);
       TrmBuf[2] = HIBYTE(wtemp);
#if  ZURAC_HSCALING
       if( (InputSource==INPUT_ANALOG) && (HScaling!=32) )
       {
          /*** Linear scaling by on-line calculation *********************
          if( (hscaling_table[ModeNum] & 0xF0)<=0x10 )
          {
            if( ((hscaling_table[ModeNum] & 0xF0)==0x00) || (HScaling>32) )
            {
               wtemp = MAKEWORD(Scale_input_para_table[ModeNum][3],
                                Scale_input_para_table[ModeNum][2]);
               ZuracHsf(wtemp,PANEL_WIDTH-64+HScaling*2);
            }
          }
          ***************************************************************/
          /*** Linear scaling by table-look-up ***/
          if( (hscaling_table[ModeNum] & 0xF0)<=0x10 )
          {
            switch( hscaling_table[ModeNum] & 0x0F )
            {
             case 0 : DataPointer = Hsf640_1024;   break;
             case 1 : DataPointer = Hsf720_1024;   break;
             case 2 : DataPointer = Hsf800_1024;   break;
             case 3 : DataPointer = Hsf832_1024;   break;
             case 4 :
             default: DataPointer = Hsf1024_1024;  break;
            };
            if( ((hscaling_table[ModeNum] & 0xF0)==0x00) || (HScaling>32) )  
            {
               wtemp = (Word)HScaling * 3;
               TrmBuf[7]  = *(DataPointer+wtemp);
               TrmBuf[8]  = *(DataPointer+wtemp+1);
               TrmBuf[9]  = *(DataPointer+wtemp+2);      
            }
          }
       }
#endif    
    }
    TrmBuf[15] |= (ScalingMode << 6);   /* Reg6E[7:6] : Scaling algorithm */
    SendData();
    
    /*** send SCALING_FACTOR Control register[0x71..0x73] ***/
    DataPointer = Scale_scaling_factor_table[ModeNum];
    DataPointer += 17;
    ByteCnt   = 4;
    TrmBuf[0] = SCALING_FAC_ADDR+17;
    for( i=1; i<=3; i++ )
       TrmBuf[i] = *(DataPointer++);
    SendData();   
    
    ZuracWriteByte(0xB6,AlphaBlending+0x08);  /* AlphaBlending */
#if (OUTPUT_MODE==OUTPUT_SXGA)
//    ZuracWriteByte(0xC2,0x00);   /* OSD  freq */    //mk20011106
#if    ( PANEL_DEFAULT == PANEL_CHIMEI )
    ZuracWriteByte(0xC2,0x00);
#else    
    ZuracWriteByte(0xC2,0x02);
#endif
#else
    ZuracWriteByte(0xC2,0x01);   /* OSD  freq */
#endif
#if (ZURAC_HWMD==0)
    ZuracWriteByte(0xD0,0x00);   /* ZuracII: dsb hw-mode-detect */
#endif
}
/************************************************************************/
/*   Function : ZuracWriteControl                                       */
/************************************************************************/
void ZuracWriteControl(Byte addr,Byte RDATA *dptr,Byte count)
{
    Byte i;

    SlvAdr  = ZURAC_ADDRESS;
    ByteCnt = 2;
    for( i=0; i<count; i++ )
    {
       TrmBuf[0] = addr+i;
       TrmBuf[1] = *(dptr+i);
       SendData();
    }
    return;
}
/************************************************************************/
/*   Function : ZuracWriteWord                                          */
/************************************************************************/
void ZuracWriteWord(Byte addr,Word wval)
{
    SlvAdr    = ZURAC_ADDRESS;
    ByteCnt   = 3;
    TrmBuf[0] = addr;
    TrmBuf[1] = LOBYTE(wval);
    TrmBuf[2] = HIBYTE(wval);
    SendData();
    return;
}
/************************************************************************/
/*   Function : ZuracWriteByte                                          */
/************************************************************************/
void ZuracWriteByte(Byte addr,Byte bval)
{
    SlvAdr    = ZURAC_ADDRESS;
    ByteCnt   = 2;
    TrmBuf[0] = addr;
    TrmBuf[1] = bval;
    SendData();
    return;
}
/*************************************************************************/
/*   Function : ZuracRead                                                */
/*************************************************************************/
void ZuracRead(Byte addr,Byte count)
{   
   SlvAdr = ZURAC_ADDRESS;
   ReadI2CData(addr,count);
}
//*************************************************************************
// ZuracInitGamma
//*************************************************************************

void ZuracInitGamma(void)
{
    Byte i,j,k;
    Byte IDATA v0,v1;
    Word IDATA v2;
    SlvAdr  = ZURAC_ADDRESS;
    for( i=0; i<3; i++ )
    {
       DataPointer = Gamma_table+(GammaIndex*16);
//     DataPointer = Gamma_table+ 2*16;
       for( j=v0=0; j<16; j++ )
       {
          v1 = *DataPointer++;
          for( k=1; k<=16; k++ )
          {
             v2  = (Word)(v1-v0) * (Word)k;
             v2 /= 16;
             v2 += v0;
             ZuracWriteByte(0xB2+i,(Byte)(v2 << 2));
             ZuracWriteByte(0xB2+i,(Byte)(v2 >> 6));
          }
          v0 = v1;
       }
    }
}


/**************************************************************/
/* Zurac Brightness and Contrast adjust, plus PWM setting     */
/**************************************************************/
void  ZuracBCAdjust(void)
{
    Word  bval,bval2;

    bval2 = 128 +  ContrastValueZ - 50;        // range is 0 .. 100

    bval =  ZRContrast + 28;
    bval = (bval * bval2) / 128;
    ZuracWriteByte(0xAE,(Byte)(128+bval));      // R contrast

    bval =  ZGContrast + 28;
    bval = (bval * bval2) / 128;
    ZuracWriteByte(0xB0,(Byte)(128+bval));      // G contrast

    bval =  ZBContrast + 28;
    bval = (bval * bval2) / 128;
    ZuracWriteByte(0xB7,(Byte)(128+bval));      // B contrast

    bval = ZRBrightness;
    bval = bval + BrightnessValueZ - 50;
    if(bval > 255)
        bval = 255;
    if(bval > 0x0FFF)
        bval = 0;
    ZuracWriteByte(0xAF,(Byte)(128+bval));      // R brightness

    bval = ZGBrightness;
    bval = bval + BrightnessValueZ - 50;
    if(bval > 255)
        bval = 255;
    if(bval > 0x0FFF)
        bval = 0;
    ZuracWriteByte(0xB1,(Byte)(128+bval));      // R brightness

    bval = ZBBrightness;
    bval = bval + BrightnessValueZ - 50;
    if(bval > 255)
        bval = 255;
    if(bval > 0x0FFF)
        bval = 0;
    ZuracWriteByte(0xB8,(Byte)(128+bval));      // R brightness


    /* Zurac-II PWM value */ 
    bval = BrightnessValue;	//algu 1120 undo
//algu 1120    bval = 255;

#if (INVERTER_POL==1)
    ZuracWriteByte(0x79,bval);
#else
    ZuracWriteByte(0x79,0xFF-bval);
#endif

}

/**************************************************************/
/* Set Zurac Register#03 value for various Panels             */
/**************************************************************/
Byte  Zurac03Value(Byte mode_num)
{   
    Byte tmp1;
    
    tmp1 = *(Scale_IO_control_table[mode_num]+3);    
#if   ( OUTPUT_MODE==OUTPUT_VGA )
    switch( PanelType )
    {                
     case PANEL_LG :
     default : 
        tmp1 = tmp1 & 0xFE;       
        break;
    };
#elif ( OUTPUT_MODE==OUTPUT_VGAW )
    switch( PanelType )
    {                
     case PANEL_LG :
     default : 
        tmp1 = tmp1 & 0xFE;       
        break;
    };
#elif ( OUTPUT_MODE==OUTPUT_SVGA )   
    switch( PanelType )
    {
     case PANEL_LG :
     default : 
        tmp1 = tmp1 & 0xEE;       
        break;
    };    
#elif ( OUTPUT_MODE==OUTPUT_XGA )
    switch( PanelType )
    {
     case PANEL_LG :
     case PANEL_LGX4 :
        tmp1 = tmp1 & 0xEE;
        break;
     case PANEL_SEC150XH :
        tmp1 = tmp1 & 0xF2;
        tmp1 = tmp1 | 0x10;
        break;
     case PANEL_SHARP :
        tmp1 = tmp1 | 0x10;
        break;
     case PANEL_HOSIDEN :
     case PANEL_CHUNGHWA :
     case PANEL_SANYO :
     default :
        tmp1 = tmp1 & 0xEF;
        break;
    };    
#else /* OUTPUT_MODE==OUTPUT_SXGA */
    switch( PanelType )
    {
        case PANEL_ACER :
        case PANEL_UNIPAC :
           tmp1 = 0x11;
           break;
        case PANEL_LG :
        case PANEL_SAMSUNG :
           tmp1 |= 0x11;
           break;
        case PANEL_SHARP :
        case PANEL_HOSIDEN :
        case PANEL_CHUNGHWA :
        default :
           tmp1 = tmp1 | 0x01;
           break;
    };
#endif

    tmp1 &= 0x9F;
    if( DitherMode==3 )       tmp1 |= 0x60;  /* 4 bit dither */
    else if( DitherMode==2 )  tmp1 |= 0x40;  /* 2 bit dither */
    else if( DitherMode==1 )  tmp1 |= 0x20;  /* 1 bit dither */
    
    return tmp1;
}    
// void  Zurac06toggle(void)
// {
//  // ZuracWriteByte(0x06,0x00);
//  // ShortDelay(40);
//  // ZuracWriteByte(0x06,0x01);
// }

void  Zurac0Atoggle(void)
{
//  Byte  z0aval;

//  if( FgGammaEnable )  z0aval = 0x8A;
//  else                 z0aval = 0x0A;

//  ZuracWriteByte(0x0A,z0aval );
    ZuracWriteByte(0x0A,0x0A );
    ShortDelay(20);
    ZuracWriteByte(0x0A,0x00 );
    ShortDelay(20);
    if(GammaIndex!=0)
    	ZuracWriteByte(0x0A,0x8A);
    else
//  ZuracWriteByte(0x0A,z0aval );
        ZuracWriteByte(0x0A,0x0A );
}

// void  ZuracEnableGamma()
// {
//     Byte  bval;
//
//     bval = *(Scale_IO_control_table[ModeCounter]+10);
//     if( FgGammaEnable )  bval |= 0x80;
//     else                 bval &= 0x7F;
//
//     ZuracWriteByte(0x0A,bval );
// }
/**************************************************************/
void  ZuracSphEmu( void )
{
    Byte  zbtemp,zbtemp2;
    Word  zwtemp;

    if( ModeCounter < TOTAL_MODE_NUMBER )
    {
       zbtemp  = mode_factor[ModeCounter] * 4;
       zbtemp2 = scale_factor_table[ zbtemp+2 ];
       zbtemp  = scale_factor_table[ zbtemp+3 ];
       zwtemp  = (Word) (((Long)ClockValue * (Long)zbtemp) / (Long)zbtemp2);
    }

    if( InputSource==INPUT_ANALOG )
    {
       if( ModeInputport[ModeCounter]==2 )   /* double input port */
             zwtemp = zwtemp / 2;
    }