lcd_auto.i

液晶显示器程序代码

 RTDRead(0x04, 1, 1);
 
 
 if (0x08 == (Data[0] & 0x0c))
 {
 ((unsigned int *)Data)[1]   += 0x03;
 ((unsigned int *)Data)[2]   += 0x03;
 }
 






 
 
 usH_Start   = (((unsigned int *)Data)[1] + stMUD.H_POSITION) >= (128 + (10 - 3))
 ? (((unsigned int *)Data)[1] + stMUD.H_POSITION) - (128 + (10 - 3)) : 0x0000;
 usH_End     = (((unsigned int *)Data)[2] + stMUD.H_POSITION) >= (128 + (10 - 3 + 1))
 ? (((unsigned int *)Data)[2] + stMUD.H_POSITION) - (128 + (10 - 3 + 1)) : 0x0fff;
 
 return 0x00;
 }
 
 
 
 
 
 
 
 
 unsigned char Measure_PositionN(unsigned char NM)
 {
 unsigned char Result;
 
 Result  = Measure_PositionV(NM);
 
 if (0x00 == Result)    
 {
 Result  = Measure_PositionH(NM);
 }
 
 return Result;
 }
 




























































































 
 void Read_Auto_Info(unsigned char index)
 {
 if(index == 0) return;
 
 RTDRead(0x88, 4, 0);
 
 Data[index << 2] = Data[3];
 Data[(index << 2) + 1] = Data[2];
 Data[(index << 2) + 2] = Data[1];
 Data[(index << 2) + 3] = Data[0];
 
 }
 
 unsigned char FindColor()
 {
 unsigned long ulTemp0;
 unsigned char ucDetect,ucResult,ucPhase;
 
 RTDSetByte(0x7E, 0x28);
 
 ulTemp0     = 0;
 ucDetect    = 0x77;
 do
 {
 ucResult    = 0x00;
 ucPhase     = 0x00;
 do
 {
 RTDSetByte(0x7D, ucPhase);
 RTDSetByte(0x7F, ucDetect);
 
 Wait_Finish();
 if (0x00 != Data[0])   return Data[0];
 
 Read_Auto_Info(1);
 
 if (ulTemp0 < ((unsigned long *)Data)[1])
 {
 ulTemp0     = ((unsigned long *)Data)[1];
 ucResult    = ucPhase;
 
 if (0x8000 < ulTemp0)   break;
 }
 
 if (0x00 == ucPhase)
 ucPhase = 0x01;
 else if (0x01 == ucPhase)
 ucPhase = 0x02;
 else
 break;
 }
 while (1);
 
 if (0 != ulTemp0 || 0x7b != ucDetect)   break;
 
 ucDetect    = 0x77;
 }
 while (1);
 
 return 0x00;
 }
 unsigned long GetMaxSum(unsigned char select)
 {
 unsigned char ucPhase,ucDetect;
 unsigned long ulTemp0;
 ucPhase = 0;  
 ulTemp0 = 0;
 Set_Phase(ucPhase);
 ucDetect    = (select == 0) ? 0x77 : 0x7b;
 
 
 
 RTDSetByte(0x9e,0x07);   
 Wait_For_IVS();
 
 RTDSetByte(0x7F, ucDetect);   
 
 Wait_For_IVS();
 for(ucPhase = 0;ucPhase < 4; ucPhase++)
 {
 
 Wait_For_IVS();
 Read_Auto_Info(1);
 
 if(ulTemp0 < ((unsigned long *)Data)[1])
 {
 ulTemp0   = ((unsigned long *)Data)[1] & 0xffffff00;
 }
 }
 RTDSetByte(0x9e,0x00);   
 Wait_Finish();
 if(0x00 != Data[0])     return (Data[0] & 0x000000ff);
 
 
#line 513 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 532 "Code\Lcd_auto.c" /0
 return ulTemp0;
 }
 
 
 
 
 
 
 
 
 
 
 unsigned char Auto_Clock_Do(unsigned char NM)
 {
 
#line 547 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 918 "Code\Lcd_auto.c" /0
 unsigned char   Result;
 unsigned char   count, delta, stop,start;    
 unsigned long   ulSum,ulCompare;
 ulCompare = 0;
 ulSum = 0;
 
 
 
 
 Result  = Measure_PositionV(NM);
 
 if (0x00 != (Result & 0x80))   return Result;
 
 NM      = NM + 0x10;     
 
 count   = 10;
 do
 {
 
 
 
 
 Result  = Measure_PositionH(NM);
 
 if (0x00 != (Result & 0x80))    return Result;
 
 usH_End = usH_End + 1 - usH_Start;
 
 
 if (usH_End < usIPH_ACT_WID)
 delta = (usIPH_ACT_WID - usH_End > 0x00ff) ? 0xff : (unsigned char)(usIPH_ACT_WID - usH_End);
 else 
 delta = (usH_End - usIPH_ACT_WID > 0x00ff) ? 0xff : (unsigned char)(usH_End - usIPH_ACT_WID);
 
 
 if((usIPH_ACT_WID/3) < delta)   
 {
 return (usH_End < usIPH_ACT_WID) ? 0xfa : 0xfb;
 }
 
 if (1 >= delta)     break;   
 
 delta   = delta + (delta >> 2); 
 
 
 
 if (usH_End < usIPH_ACT_WID)     
 {
 if ((178 - stMUD.CLOCK) < delta)    return 0xfa;
 
 stMUD.CLOCK  += delta;
 
 Set_Clock();
 Set_H_Position();
 }
 else                             
 {
 if ((stMUD.CLOCK - 78) < delta)     return 0xfb;
 
 stMUD.CLOCK -= delta;
 
 Set_H_Position();
 Set_Clock();
 }   
 
 
#line 984 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 1005 "Code\Lcd_auto.c" /0
 }
 while (--count);
 
 
 
 if (0 == count)  return 0xfd;
 
 stop    = 0;
 
 while (1)
 {
 count   = 0x10;      
 delta   = 0xff;
 
 while (1)
 {
 
 
 Set_Phase(count);
 
 
 Result  = Measure_PositionH(NM);
 
 if (0x00 != (Result & 0x80))
 {
 if (0xf8 == Result)
 {
 
 if (0x70 == count)
 {
 Set_Phase(stMUD.PHASE);  
 break;
 }
 else
 {
 count += 0x20;
 continue;
 }
 }
 
 Set_Phase(stMUD.PHASE);  
 
 return Result;
 }
 
 usH_End = usH_End + 1 - usH_Start;
 
 Result  = (usH_End < usIPH_ACT_WID)
 ? 0x80 - (unsigned char)(usIPH_ACT_WID - usH_End)
 : 0x80 + (unsigned char)(usH_End - usIPH_ACT_WID);
 
 if (Result < delta)
 {
 delta   = Result;        
 }
 
 if (0x70 == count)
 {
 Set_Phase(stMUD.PHASE);  
 break;
 }
 
 count += 0x10;
 }
 
 if (0x81 < delta)
 {
 stMUD.CLOCK -= 1;
 
 Set_H_Position();
 Set_Clock();
 
 stop    = 1;
 }
 else if (0x80 > delta)
 {
 if (stop && (0x7f == delta))    break; 
 
 stMUD.CLOCK += 1;
 
 Set_Clock();
 Set_H_Position();
 
 if (stop)   break;
 }
 else    
 break;
 }
 
 count = stMUD.PHASE;   
 start = stMUD.CLOCK ;
 
 
 if(FindColor() != 0x00) return 0xff;
 
 RTDSetByte(0x7E, 0x30);
 
 ulSum = GetMaxSum(1);  
 ulCompare = GetMaxSum(0);
 
 
 
 if((ulSum > 460000) || ((ulSum < 460000) && (ulCompare > 2000000)) )
 {
 
 ulCompare = 0;    
 
 
 if(0x80 < (start - 2) || 0x80 > start)
 {
 stMUD.CLOCK = 0x80;
 Set_H_Position();
 Set_Clock();
 ulSum = GetMaxSum(0);
 
 if(ulCompare < ulSum)
 {
 ulCompare = ulSum;
 Result = stMUD.CLOCK;
 }
 
 stMUD.CLOCK = start + 1;
 }
 else
 {
 stMUD.CLOCK = start;
 Set_H_Position();
 Set_Clock();
 ulSum = GetMaxSum(0);
 }
 
 
 
 while(1)
 {
 if(ulCompare < ulSum)
 {
 ulCompare = ulSum;
 Result = stMUD.CLOCK;
 }
 if(stMUD.CLOCK == start - 2)
 break;    
 
 stMUD.CLOCK -= 1;
 Set_Clock();
 Set_H_Position();
 ulSum = GetMaxSum(0);        
 }
 
 stMUD.CLOCK = Result;
 stMUD.PHASE = count;
 Set_Clock();
 Set_H_Position();
 Set_Phase(stMUD.PHASE);
 }  
 
 
 
 
 return (28 > stMUD.CLOCK) ? 0xfb : (228 < stMUD.CLOCK) ? 0xfa : 0x00;
 }
 
 
 
 
 unsigned char Auto_Position(void)
 {
 unsigned char   Result, Curr_PosH, Curr_PosV;
 
 bAutoInProgress = 1;
 
 Curr_PosH   = stMUD.H_POSITION;      
 Curr_PosV   = stMUD.V_POSITION;      
 
 if (ucV_Max_Margin < stMUD.V_POSITION)
 {
 stMUD.V_POSITION    = ucV_Max_Margin;
 Set_V_Position();
 }
 
 RTDCodeW(ADC_DEFAULT);
 
 
 
 
 Result  = Min_Noise_Margin();
 
 if (0x00 == (Result & 0x80))
 {   
 
 
 
 Result  = Auto_Position_Do(Data[0]);     
 }
 
 if (0x00 == (Result & 0x80))
 {
 Save_MUD(ucMode_Curr);
 }
 else
 {
 stMUD.H_POSITION    = Curr_PosH;
 stMUD.V_POSITION    = Curr_PosV;
 
 Set_H_Position();
 Set_V_Position();
 }
 
 
 SetADC_GainOffset();
 
 bAutoInProgress = 0;
 
 return Result;
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 unsigned char Auto_Position_Do(unsigned char NM)
 {
 unsigned char   Result; 
 
 





















 
 Result      = Measure_PositionN(NM);
 
 if (0x00 != (Result & 0x80))   return Result;
 Result  = 0x00;
 
 
 
 
 NM  = 1;
 while (1)
 {
 if ((usIPV_ACT_STA + ucV_Max_Margin - 128) >= usVer_Start)
 {
 if ((usIPV_ACT_STA + ucV_Min_Margin - 128) <= usVer_Start)
 {
 stMUD.V_POSITION = (usVer_Start + 128) - usIPV_ACT_STA;
 Set_V_Position();
 
 break;   
 }
 else
 Result  |= 0x02;
 }
 else
 Result  |= 0x01;
 
 
 if (NM && usVer_End > usIPV_ACT_LEN)
 {
 usVer_Start = usVer_End - usIPV_ACT_LEN + 1;
 NM          = 0;
 }
 else
 {
 Result  |= 0x04;
 break;
 }
 }
 
 
 
 
 NM  = 1;
 while (1)
 {
 
 
 if ((usIPH_ACT_STA + (stMUD.CLOCK >> 2) + ucH_Max_Margin - 32 - 128) >= usH_Start)
 {
 
 
 if(ucH_Min_Margin  <= 128 )
 ((unsigned int*)Data)[0] = usH_Start + 128 - stMUD.H_POSITION + 50; 
 else
 ((unsigned int*)Data)[0] = usH_Start; 
 
 
 if ((usIPH_ACT_STA + (stMUD.CLOCK >> 2) + ucH_Min_Margin - 32 - 128) <= ((unsigned int*)Data)[0])
 {
 
 stMUD.H_POSITION    = usH_Start + 128 + 32 - usIPH_ACT_STA - (stMUD.CLOCK >> 2);
 Set_H_Position();
 
 break;   
 }
 else
 Result  |= 0x10;
 }
 else
 Result  |= 0x08;
 
 
 
#line 1334 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 1359 "Code\Lcd_auto.c" /0
 
 if (NM && usH_End > usIPH_ACT_WID)
 {
 usH_Start   = usH_End - usIPH_ACT_WID + 1;
 NM          = 0;
 }
 else
 {
 Result  |= 0x20;
 break;
 }
 }
















 
 return Result;
 }
 
 unsigned char Min_Noise_Margin(void)
 {
 unsigned char   Result, Noise;
 unsigned int    Curr_StartH, Curr_EndH;
 
 Result  = Measure_PositionV(0x30);
 
 if (0x00 != (Result & 0x80))   return Result;
 
 if (0 == usVer_Start)
 {
 Result  = Measure_PositionV(0x30 + 0x20);
 if (0x00 != (Result & 0x80))   return Result;
 }
 
 Noise   = 0x00;
 Result  = Measure_PositionH(Noise);
 if (0x00 != (Result & 0x80))   return Result;
 
 Curr_StartH = usH_Start;     
 Curr_EndH   = usH_End;       
 
 do
 {
 Noise   = Noise + 0x10;
 Result  = Measure_PositionH(Noise);
 
 if (0x00 != (Result & 0x80))   return Result;
 
 if (Curr_StartH >= usH_Start)
 {
 Curr_StartH = usH_Start;
 }
 else if (0x08 < (usH_Start - Curr_StartH))
 {
 break;   
 }
 }
 while (0x90 > Noise);
 
 if (0x80 < Noise)   return 0xf9;      
 
 while (1)
 {   
 Curr_StartH = usH_Start;
 Curr_EndH   = usH_End;
 
 Result  = Measure_PositionH(Noise + 0x28);
 
 if (0x00 != (Result & 0x80))   return Result;
 
 if ((Curr_EndH - Curr_StartH) == (usH_End - usH_Start) || (Curr_EndH - Curr_StartH) >= (usH_End - usH_Start + 3))
 {
 break;   
 }
 
 if (0xa0 <= Noise)
 {
 break;   
 }
 
 Noise   = Noise + 0x10;        
 Result  = Measure_PositionH(Noise);
 
 if (0x00 != (Result & 0x80))   return Result;
 };
 
 Data[0] = Noise + 0x10;
 
 return 0x00;
 }
 
 unsigned char Auto_Phase(void)
 {
 unsigned char   Result, Curr_PosV;
 
 bAutoInProgress = 1;
 
 Curr_PosV   = stMUD.V_POSITION;      
 
 if (ucV_Max_Margin < stMUD.V_POSITION)
 {
 stMUD.V_POSITION    = ucV_Max_Margin;
 Set_V_Position();
 }
 
 
 RTDCodeW(ADC_DEFAULT);
 
 
 
 
 Result  = Min_Noise_Margin();
 
 if (0x00 == (Result & 0x80))
 {   
 Result      = Auto_Phase_Do(Data[0]);    
 }
 
 if (0x00 != (Result & 0x80))
 {
 
 Set_Phase(stMUD.PHASE);
 }
 else
 {
 Save_MUD(ucMode_Curr);
 }
 
 
 SetADC_GainOffset();
 
 
 if (Curr_PosV != stMUD.V_POSITION)
 {
 stMUD.V_POSITION    = Curr_PosV;
 Set_V_Position();
 }
 
 bAutoInProgress = 0;
 
 return Result;
 }
 
 
 unsigned char Auto_Phase_Do(unsigned char NM)
 {
 unsigned char idata ucDetect, ucPhase, ucResult;
 unsigned long idata ulTemp0, ulTemp1, ulTemp2;
 








 
 
 if (0x00 != Measure_PositionN(NM))    return 0xff;
 
 
 Data[0]     = 6;
 Data[1]     = 0;
 Data[2]     = 0x75;
 Data[3]     = (unsigned char)(usH_Start + (10 - 3) - 2);
 Data[4]     = (unsigned char)(usH_End + (10 - 3 + 1) + 1);
 Data[5]     = ((unsigned char)((usH_Start + (10 - 3) - 2) >> 4) & 0x70) | ((unsigned char)((usH_End + (10 - 3 + 1) + 1) >> 8) & 0x0f);
 Data[6]     = 0;
 RTDWrite(Data);
 
 RTDSetByte(0x7E, 0x30);
 
 ulTemp0     = 0;
 ucDetect    = 0x7b;
 do
 {
 ucResult    = 0x01;
 ucPhase     = 0x01;
 do
 {
 RTDSetByte(0x7D, ucPhase);
 RTDSetByte(0x7F, ucDetect);
 
 Wait_Finish();
 if (0x00 != Data[0])   return Data[0];
 
 Read_Auto_Info(1);
 if (ulTemp0 < ((unsigned long *)Data)[1])
 {
 ulTemp0     = ((unsigned long *)Data)[1];
 ucResult    = ucPhase;
 
 if (0x8000 < ulTemp0)   break;
 }
 
 if (0x01 == ucPhase)
 ucPhase = 0x00;
 else if (0x00 == ucPhase)
 ucPhase = 0x02;
 else
 break;
 }
 while (1);
 
 if (0 != ulTemp0 || 0x7b != ucDetect)   break;
 
 ucDetect    = 0x77;
 }
 while (1);
 
 
 if (0 == ulTemp0)   return 0xf8;
 
 
 RTDSetByte(0x7D, NM | ucResult);
 
 
 
 NM = 100;
 
#line 1593 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 1650 "Code\Lcd_auto.c" /0
 
 RTDSetByte(0x7E, NM);
 
 
 
 Set_Phase(0x78);
 Delay_Xms(1);
 
 RTDSetByte(0x7F, 0x77);
 
 Wait_Finish();
 if (0x00 != Data[0])   return Data[0];
 
 Read_Auto_Info(1);
 
 ulTemp1     = ((unsigned long *)Data)[1];
 
 
 
 ulTemp2     = ulTemp1;
 ulTemp0     = 0;
 RTDSetByte(0x9e,0x05);   
 
 Wait_For_IVS();
 RTDSetByte(0x7F,0x77);  
 
 Wait_For_IVS();
 for(ucDetect = 0;ucDetect < 16; ucDetect++)
 {
 
 Wait_For_IVS();
 Read_Auto_Info(3);










 
 
 if(ulTemp0 < ((unsigned long *)Data)[3])
 {
 ulTemp0   = ((unsigned long *)Data)[3] & 0xffffff00;  
 ulTemp1   = ulTemp2;                                  
 ucResult  = ucDetect << 3;                            
 }
 ulTemp2 = ((unsigned long*)Data)[3] & 0xffffff00;
 
 }
 Wait_Finish();
 if (0x00 != Data[0])   return Data[0];
 
 RTDSetByte(0x9e,0x00);   
 
 
#line 1709 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 1763 "Code\Lcd_auto.c" /0
 
 ucPhase = ucResult == 0x00 ? 0x7c : (ucResult - 0x04 );
 ulTemp2 = 0;
 ucDetect = 2;
 
 
 Set_Phase(ucPhase);  
 Delay_Xms(1);
 
 RTDSetByte(0x7F, 0x77);
 
 Wait_Finish();
 if (0x00 != Data[0])   return Data[0];
 Read_Auto_Info(1);
 ulTemp2 = ((unsigned long*)Data)[1];    
 
 ((unsigned long*)Data)[0] 
 = ulTemp1 + ulTemp2 + ulTemp0 
 -((ulTemp1 > ulTemp2 ? ulTemp1 - ulTemp2 : ulTemp2 - ulTemp1)/2)
 -((ulTemp2 > ulTemp0 ? ulTemp2 - ulTemp0 : ulTemp0 - ulTemp2)/2);
 
 ulTemp1 = ((unsigned long*)Data)[0];
 ucPhase = ucResult; 
 ucResult = ucResult == 0x00 ? 0x7c : ucResult - 0x04;
 
 do  
 {
 ucPhase = (ucPhase == 0x7c) ? 0x00 : ucPhase + 0x04;
 Set_Phase(ucPhase);
 Delay_Xms(1);
 
 RTDSetByte(0x7F, 0x77);
 
 Wait_Finish();
 if (0x00 != Data[0])   return Data[0];
 
 Read_Auto_Info(3);
 
 ((unsigned long *)Data)[0]  
 = ulTemp2 + ulTemp0 + ((unsigned long *)Data)[3]
 - ((ulTemp0 > ulTemp2 ? ulTemp0 - ulTemp2 : ulTemp2 - ulTemp0) / 2)
 - ((ulTemp0 > ((unsigned long *)Data)[3] ? ulTemp0 - ((unsigned long *)Data)[3] : ((unsigned long *)Data)[3] - ulTemp0) / 2);
 
 if(((unsigned long*)Data)[0] > ulTemp1)
 {
 ulTemp1 = ((unsigned long*)Data)[0];
 ucResult = (ucPhase == 0x00) ? 0x7c : ucPhase - 0x04;
 }
 ucDetect -= 1;
 
 ulTemp2 = ulTemp0;
 ulTemp0 = ((unsigned long *)Data)[3];
 
 }while(ucDetect);
 
 
 
#line 1820 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 1975 "Code\Lcd_auto.c" /0
 
 stMUD.PHASE = ucResult;
 Set_Phase(stMUD.PHASE);
 






 
 
 return 0x00;
 }
 
 unsigned char Auto_Config(void)
 {
 unsigned char   Result, Noise, Curr_PosH, Curr_PosV, Curr_Clock, Curr_Phase;
 
 unsigned char ucTemp1;
 unsigned int usTemp;
 
 
 bAutoInProgress = 1;
 
 Curr_PosH   = stMUD.H_POSITION;      
 Curr_PosV   = stMUD.V_POSITION;      
 Curr_Clock  = stMUD.CLOCK;           
 Curr_Phase  = stMUD.PHASE;           
 
 if (ucV_Max_Margin < stMUD.V_POSITION)
 {
 stMUD.V_POSITION    = ucV_Max_Margin - 1;
 Set_V_Position();
 }
 
 
 
 
 





















 
 
 
 
 
 
 stMUD.H_POSITION = 128; 
 
 
 
 
 if(stMUD.CLOCK > 128)
 ucTemp1 = 128;
 else
 ucTemp1 = stMUD.CLOCK;
 
 
 ucH_Min_Margin = 128 - (64 - (ucTemp1 >> 1));
 
 
 usIPH_ACT_STA   = CAP_WIN[ucMode_Curr][1];
 
 if(ucMode_Curr < 23)
 Data[0] = 2;
 else if(ucMode_Curr < 44)
 Data[0] = 5;
 else
 Data[0] = 3;
 
 
 
 
 usIPH_ACT_STA = CAP_WIN[ucMode_Curr][1] + Data[0] - 6 - (64 - (ucTemp1 >> 1));
 
 usTemp = usIPH_ACT_STA;
 
 Set_H_Position();
 
 RTDSetByte(0x01, 0x00);   
 RTDSetByte(0x1F, 0x00);   
 
 
 
 
 
 
 
 
 Result  = Min_Noise_Margin();   
 Noise   = Data[0];
 
 
 
 
 
 if (0x00 == (Result & 0x80))
 {   
 stMUD.CLOCK = (stMUD.CLOCK) & 0xfc;  
 
 if (stMUD.CLOCK != Curr_Clock)  Set_Clock();
 
 
 
 
 Result  = Auto_Clock_Do(Noise);
 
 
 if (0x00 != (Result & 0x80))
 {
 if (stMUD.CLOCK != Curr_Clock)
 {
 
 stMUD.H_POSITION    = Curr_PosH;
 stMUD.CLOCK         = Curr_Clock;
 
 Set_Clock();
 Set_H_Position();
 }
 }
 else
 {
 stMUD.H_POSITION    = usH_Start + 128 + 64 - usIPH_ACT_STA - (stMUD.CLOCK >> 1);
 
 if (ucH_Max_Margin < stMUD.H_POSITION)
 stMUD.H_POSITION    = ucH_Max_Margin;
 else if (ucH_Min_Margin > stMUD.H_POSITION)
 stMUD.H_POSITION    = ucH_Min_Margin;
 
 Set_H_Position();
 }
 }
 
 
 if (0x00 == (Result & 0x80))
 {   
 Result      = Auto_Phase_Do(Noise);
 
 if (0x00 != (Result & 0x80))
 {
 
 stMUD.PHASE = Curr_Phase;
 Set_Phase(stMUD.PHASE);
 
 if (0xf8 == Result)      Result  = 0x00;
 }
 }
 
 
 if (0x00 == (Result & 0x80))    
 {   
 
 
 
 Result  = Auto_Position_Do(Noise);
 
 
 }
 else
 {
 stMUD.V_POSITION    = Curr_PosV;
 Set_V_Position();
 }
 
 
 
 
















 
 
 
 
 
 if(ucH_Min_Margin == (128 - (64 - (ucTemp1 >> 1))))
 {
 if(usTemp != usIPH_ACT_STA)
 {   
 
 
 stMUD.H_POSITION = stMUD.H_POSITION - (usTemp - usIPH_ACT_STA);
 usIPH_ACT_STA = usTemp - 50 + (64 - (ucTemp1 >> 1));
 Data[3] = 0x80 | (78 - stMUD.H_POSITION);	    
 
 }
 else
 {
 usIPH_ACT_STA   = usIPH_ACT_STA - 50 + (64 - (ucTemp1 >> 1));
 Data[3] = 0;
 }
 
 
 Data[0] = 4;
 Data[1] = 0xAE;
 Data[2] = (ucMode_Curr - 1);          
 
 
 
 if(0x80 < stMUD.H_POSITION)
 {
 if(stMUD.H_POSITION - 0x80 < 10)
 {
 usIPH_ACT_STA += (stMUD.H_POSITION - 0x80);
 Data[3] += (stMUD.H_POSITION - 0x80);
 stMUD.H_POSITION = 0x80;                            
 }
 
 }
 else if(0x80 > stMUD.H_POSITION)
 {
 if(0x80 - stMUD.H_POSITION < 10)
 {
 usIPH_ACT_STA -= (0x80 - stMUD.H_POSITION);
 
 Data[3] = (0x80 - stMUD.H_POSITION ) | 0x80;
 stMUD.H_POSITION = 0x80;
 
 }
 }
 
 I2CWrite(Data);
 Delay_Xms(0x10);
 
 ucH_Min_Margin  = 128 - 50;   
 Set_H_Position();
 
 }
 Set_Phase(stMUD.PHASE);
 if (0x00 == (Result & 0x80))   Save_MUD(ucMode_Curr);
 
 RTDSetByte(0x01, 0x00);   
 RTDSetByte(0x1F, 0x00);   
 
 
 
 
 
 
 bAutoInProgress = 0;
 Set_Phase(stMUD.PHASE);
 
 return Result;
 }
 
 unsigned char Auto_Balance(void)
 {
 unsigned char Result, Curr_PosV;
 
 bAutoInProgress = 1;
 
 Curr_PosV   = stMUD.V_POSITION;      
 
 if (ucV_Max_Margin < stMUD.V_POSITION)
 {
 stMUD.V_POSITION    = ucV_Max_Margin;
 Set_V_Position();
 }
 
 
 Result  = Tune_Balance();
 
 
 if (Curr_PosV != stMUD.V_POSITION)
 {
 stMUD.V_POSITION    = Curr_PosV;
 Set_V_Position();
 }
 
 if (0x00 != Result)
 {
 
 Load_GUD2();
 SetADC_GainOffset();
 }
 else
 {
 stGUD0.CONTRAST         = 50;
 stGUD0.RTD_R_CONTRAST   = 50;
 stGUD0.RTD_G_CONTRAST   = 50;
 stGUD0.RTD_B_CONTRAST   = 50;
 stGUD0.RTD_R_BRIGHT     = 50;
 stGUD0.RTD_G_BRIGHT     = 50;
 stGUD0.RTD_B_BRIGHT     = 50;
 Set_Bright_Contrast();
 
 
 SetADC_Gain();
 
 
 Save_GUD0();







 
 Save_GUD2();
 }
 
 bAutoInProgress = 0;
 
 return Result;
 }
 
 unsigned char Tune_Balance(void)
 {
 unsigned char   Color, Count, Result, Margin, FineTune, Offset_Stop,ucTemp = 0;
 
 FineTune    = 0;
 
 
 ucTemp = stGUD0.CONTRAST;
 stGUD0.CONTRAST = 50;
 SetADC_Gain();
 
 
 RTDCodeW(ADC_DEFAULT);
 
 
 if (0x00 != Measure_PositionN(0x40))   return 0xff;
 
 if (0x00 != Measure_Color(0x01, 0x20))      return 0xff;
 if (0x60 > Data[0])     return 0xff;
 
 Margin  = Data[0];
 
 if (0x00 != Measure_Color(0x02, 0x20))    return 0xff;
 if (0x60 > Data[0])     return 0xff;
 
 Margin  = Margin > Data[0] ? Data[0] : Margin;
 
 if (0x00 != Measure_Color(0x04, 0x20))     return 0xff;
 if (0x60 > Data[0])     return 0xff;
 
 Margin  = Margin > Data[0] ? Data[0] : Margin;
 
 Margin  = (Margin - 0x20) & 0xfc;
 
 
 if (0x00 != Measure_PositionN(Margin))   return 0xff;
 
 
 
#line 2354 "Code\Lcd_auto.c" /1
 
 
#line 2356 "Code\Lcd_auto.c" /0
 SetADC_GainOffset();
 
 
 Offset_Stop = 0;
 Color   = 0x04;
 do
 {
 Count   = 0x30;
 
 do
 {
 
#line 2368 "Code\Lcd_auto.c" /1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#line 2441 "Code\Lcd_auto.c" /0
 
 
 
 
 
 
 if (0x00 != Measure_Color(Color, 0x20))   return 0xff;
 Margin  = Data[0];
 
 if (0xf2 < Margin)
 {
 Result  = Margin - 0xf2;
 
 
 if (Change_ADC_Gain(Color, Result, 0))               
 {
 if (Change_ADC_Offset(Color, 4, 0))     break;   
 }
 }
 else if (0xf2 > Margin)
 {
 Result  = 0xf2 - Margin;
 
 
 if (Change_ADC_Gain(Color, Result, 1))               
 {
 if (Change_ADC_Offset(Color, 4, 1))     break;   
 }
 }
 
 Result  = Margin;
 
 
 
 
 
 if (0x00 != Measure_Color(Color, 0x00))   return 0xff;
 Margin  = Data[0];
 
 if (0x0a < Margin)
 {
 Change_ADC_Offset(Color, 0x08, 0);           
 }
 else if (0x02 < Margin)
 {
 C