lcd_auto.c

液晶显示器程序代码

#endif
        // If we can't align upper bound, we try to align lower bound.
        if (NM && usH_End > usIPH_ACT_WID)
        {
            usH_Start   = usH_End - usIPH_ACT_WID + 1;
            NM          = 0;
        }
        else
        {
            Result  |= ERROR_SUCCESS_32;
            break;
        }
    }
/*
//////////////////////////////////////////////////////////////////////////////
    if(ucH_Min_Margin == (128 - ucTemp))
	{
        if(usTemp != usIPH_ACT_STA)
		{
		   stMUD.H_POSITION = stMUD.H_POSITION - (usTemp - usIPH_ACT_STA);
		   usIPH_ACT_STA = usTemp - 50 + ucTemp + (64 - (ucTemp1 >> 1));
		}
		else
		    usIPH_ACT_STA   = usIPH_ACT_STA - 50 + ucTemp + (64 - (ucTemp1 >> 1));

		ucH_Min_Margin  = 128 - 50;   
		Set_H_Position();
	}
////////////////////////////////////////////////////////////////////////////////
*/
    return Result;
}

unsigned char Min_Noise_Margin(void)
{
    unsigned char   Result, Noise;
    unsigned int    Curr_StartH, Curr_EndH;

    Result  = Measure_PositionV(VERTICAL_MARGIN);
    
    if (ERROR_SUCCEED != (Result & 0x80))   return Result;
	    
    if (0 == usVer_Start)
    {
        Result  = Measure_PositionV(VERTICAL_MARGIN + 0x20);
        if (ERROR_SUCCEED != (Result & 0x80))   return Result;
    }
    
    Noise   = 0x00;
    Result  = Measure_PositionH(Noise);
    if (ERROR_SUCCEED != (Result & 0x80))   return Result;
        
    Curr_StartH = usH_Start;    // Save H start position at noise margin = 0
    Curr_EndH   = usH_End;      // Save H end position at noise margin = 0

    do
    {
        Noise   = Noise + 0x10;
        Result  = Measure_PositionH(Noise);

        if (ERROR_SUCCEED != (Result & 0x80))   return Result;
    
        if (Curr_StartH >= usH_Start)
        {
            Curr_StartH = usH_Start;
        }
        else if (0x08 < (usH_Start - Curr_StartH))
        {
            break;  // A large gap of H start position is found.
        }
    }
    while (0x90 > Noise);

    if (0x80 < Noise)   return ERROR_NOISE_TOO_BIG;      

    while (1)
    {   
        Curr_StartH = usH_Start;
        Curr_EndH   = usH_End;

        Result  = Measure_PositionH(Noise + 0x28);
        
        if (ERROR_SUCCEED != (Result & 0x80))   return Result;

        if ((Curr_EndH - Curr_StartH) == (usH_End - usH_Start) || (Curr_EndH - Curr_StartH) >= (usH_End - usH_Start + 3))
        {
            break;  // We got noise margin with stable horizontal start/end position.
        }
        
        if (0xa0 <= Noise)
        {
            break;  // No stable horizontal start/end position are found.
        }

        Noise   = Noise + 0x10;        
        Result  = Measure_PositionH(Noise);

        if (ERROR_SUCCEED != (Result & 0x80))   return Result;
    };

    Data[0] = Noise + 0x10;

    return ERROR_SUCCEED;
}

unsigned char Auto_Phase(void)
{
    unsigned char   Result, Curr_PosV;

    bAutoInProgress = 1;

    Curr_PosV   = stMUD.V_POSITION;     // Save current stMUD.V_POSITION

    if (ucV_Max_Margin < stMUD.V_POSITION)
    {
        stMUD.V_POSITION    = ucV_Max_Margin;
        Set_V_Position();
    }

    // Set ADC to default
    RTDCodeW(ADC_DEFAULT);

    ///////////////////////////////
    //   Measure  NOISE_MARGIN   //
    ///////////////////////////////
    Result  = Min_Noise_Margin();

    if (ERROR_SUCCEED == (Result & 0x80))
    {   
        Result      = Auto_Phase_Do(Data[0]);   // Noise margin returned by Min_Noise_Margin() is saved in Data[0];
    }

    if (ERROR_SUCCEED != (Result & 0x80))
    {
        // Restore Phase
        Set_Phase(stMUD.PHASE);
    }
    else
    {
        Save_MUD(ucMode_Curr);
    }

    // Restore ADC Gain/Offset
    SetADC_GainOffset();

    // Restore vertical position
    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;

/*	
    //reduce the bandwidth of ADC to prevent overshoot
    if(ucMode_Curr <= MODE_1280x1024x75HZ)
       RTDSetByte(ADC_REG_TEST_E9, 0x08);
    else if(ucMode_Curr < MODE_1024x0768x70HZ)
       RTDSetByte(ADC_REG_TEST_E9, 0x00);
    else
       RTDSetByte(ADC_REG_TEST_E9, 0x10);
*/

    if (ERROR_SUCCEED != Measure_PositionN(NM))    return ERROR_ABORT;

    // Set auto-tracking window
    Data[0]     = 6;
    Data[1]     = Y_INC;
    Data[2]     = H_BND_STA_L_75;
    Data[3]     = (unsigned char)(usH_Start + MEAS_H_STA_OFFSET - 2);
    Data[4]     = (unsigned char)(usH_End + MEAS_H_END_OFFSET + 1);
    Data[5]     = ((unsigned char)((usH_Start + MEAS_H_STA_OFFSET - 2) >> 4) & 0x70) | ((unsigned char)((usH_End + MEAS_H_END_OFFSET + 1) >> 8) & 0x0f);
    Data[6]     = 0;
    RTDWrite(Data);

    RTDSetByte(DIFF_THRED_7E, 0x30);

    ulTemp0     = 0;
    ucDetect    = 0x7b;
    do
    {
        ucResult    = COLORS_GREEN;
        ucPhase     = COLORS_GREEN;
        do
        {
            RTDSetByte(MARGIN_B_7D, ucPhase);
            RTDSetByte(AUTO_ADJ_CTRL_7F, ucDetect);

            Wait_Finish();
            if (ERROR_SUCCEED != 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 (COLORS_GREEN == ucPhase)
                ucPhase = COLORS_BLUE;
            else if (COLORS_BLUE == ucPhase)
                ucPhase = COLORS_RED;
            else
                break;
        }
        while (1);

        if (0 != ulTemp0 || 0x7b != ucDetect)   break;

        ucDetect    = 0x77;
    }
    while (1);

    // Abort if no suitable color is found
    if (0 == ulTemp0)   return ERROR_NOTACTIVE;
   // NM = COLORS_GREEN;
    // Select color for auto-phase tracking
    RTDSetByte(MARGIN_B_7D, NM | ucResult);

#if(1)
    //NM = 136;
	NM = 100;
#else
    // Find suitable threshold
    // We use phase 8 and 24 to find out it

    ucPhase = 0x20;
    Set_Phase(ucPhase);

    ucResult    = 0x28;
    NM          = 0x00;
    do
    {
        do
        {
            ucResult    += 0x20;

            RTDSetByte(DIFF_THRED_7E, ucResult);
            RTDSetByte(AUTO_ADJ_CTRL_7F, ucDetect);

            Wait_Finish();
            if (ERROR_SUCCEED != Data[0])   return Data[0];

            Read_Auto_Info(1);

            if ((unsigned long)0x1000 > ((unsigned long *)Data)[1])
            {
                ucResult    -= 0x20;
                break;
            }
        }
        while (0x88 > ucResult);

        if (0x88 == ucResult)
        {
            NM  = ucResult;
            break;
        }
        else
        {
            if (0x20 == ucPhase)
            {
                NM  = ucResult;

                ucPhase = 0x60;
                Set_Phase(ucPhase);
            }
            else
            {
                if (NM < ucResult)      NM  = ucResult;
                
                break;
            }
        }
    }
    while (1);

    // Set threshold
    if(NM < 136) NM = 136;
#endif

    RTDSetByte(DIFF_THRED_7E, NM);

#if(1)  //FAST_AUTO method 1
        // Set phase 30
		Set_Phase(0x78);
		Delay_Xms(1);
		
		RTDSetByte(AUTO_ADJ_CTRL_7F, 0x77);

		Wait_Finish();
		if (ERROR_SUCCEED != Data[0])   return Data[0];

		Read_Auto_Info(1);
      
		ulTemp1     = ((unsigned long *)Data)[1];


#if(HARDWARE_AUTO)
        ulTemp2     = ulTemp1;
		ulTemp0     = 0;
        RTDSetByte(HW_AUTO_PHASE_9E,0x05);  //Step 2 auto phase
		//Wait_For_Event(EVENT_IVS);
		Wait_For_IVS();
		RTDSetByte(AUTO_ADJ_CTRL_7F,0x77); // Auto start
		//Wait_For_Event(EVENT_IVS);
		Wait_For_IVS();
        for(ucDetect = 0;ucDetect < 16; ucDetect++)
        {
               //Wait_For_Event(EVENT_IVS);
			   Wait_For_IVS();
               Read_Auto_Info(3);
            /*   
			   Data[0]     = 7;
               Data[1]     = ADDR_EROM1;
               Data[2]     = 0x40 + (ucDetect << 2);
               Data[3]     = (unsigned char)(((unsigned long *)Data)[3] >> 12);
               Data[4]     = (unsigned char)(((unsigned long *)Data)[3] >> 8);
               Data[5]     = (unsigned char)(((unsigned long *)Data)[3] >> 4);
               Data[6]     = 0x00;
               
			   I2CWrite(Data);
			  */ 

              if(ulTemp0 < ((unsigned long *)Data)[3])
              {
                   ulTemp0   = ((unsigned long *)Data)[3] & 0xffffff00; //Store the SOD of phase(n)
				   ulTemp1   = ulTemp2;                                 //Store the SOD of phase(n-2)
				   ucResult  = ucDetect << 3;                           //Save the phase
              }
              ulTemp2 = ((unsigned long*)Data)[3] & 0xffffff00;
			  
        }
			Wait_Finish();
			if (ERROR_SUCCEED != Data[0])   return Data[0];

        RTDSetByte(HW_AUTO_PHASE_9E,0x00);  //Switch back to software auto phase

#else
		// Set phase 0
		Set_Phase(0x00);
		Delay_Xms(1);
		
		RTDSetByte(AUTO_ADJ_CTRL_7F, 0x77);

		Wait_Finish();
		if (ERROR_SUCCEED != Data[0])   return Data[0];

		Read_Auto_Info(1);
      
		ulTemp0     = ((unsigned long *)Data)[1];
		ulTemp2     = ulTemp0;


		ucResult    = 0x00;

		ucPhase     = 0x08;//2 step rought scan
		do
		{
			Set_Phase(ucPhase);
			Delay_Xms(1);

			RTDSetByte(AUTO_ADJ_CTRL_7F, 0x77);
			
			Wait_Finish();
			if (ERROR_SUCCEED != Data[0])   return Data[0];

            Read_Auto_Info(3);
       
//			((unsigned long *)Data)[0]  = ulTemp1 + ulTemp2 + ((unsigned long *)Data)[1];

			if (ulTemp0 < ((unsigned long *)Data)[3])
			{
				ulTemp0     = ((unsigned long *)Data)[3];  //Save the SOD of phase(n)
				ulTemp1     = ulTemp2;                     //Save the SOD of phase(n-2)
				ucResult    = ucPhase;
			}
			

			ulTemp2 = ((unsigned long *)Data)[3];

			ucPhase = ucPhase + 0x08;
		}
		while (0x78 != ucPhase);


		if((ucResult == 0x00) && (ulTemp1 > ulTemp2))//Compare the value of phase 28 & phase 30
		{
		     ucResult = 0x78;  //The maximum equal to phase 30
			 ulTemp0 = ulTemp1; //Save the value of phase 30
			 ulTemp1 = ulTemp2; //Save the value of phase 28
		}
#endif

        ucPhase = ucResult == 0x00 ? 0x7c : (ucResult - 0x04 );
        ulTemp2 = 0;
        ucDetect = 2;
		

        Set_Phase(ucPhase); //set Phase(n-1)
		Delay_Xms(1);
		
		RTDSetByte(AUTO_ADJ_CTRL_7F, 0x77);

		Wait_Finish();
		if (ERROR_SUCCEED != Data[0])   return Data[0];
        Read_Auto_Info(1);
        ulTemp2 = ((unsigned long*)Data)[1];   //Save the SOD of  phase(n-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 //detail scan by one step from phase(n-2) ~ pnase (n+2)
        {
           ucPhase = (ucPhase == 0x7c) ? 0x00 : ucPhase + 0x04;
           Set_Phase(ucPhase);
	       Delay_Xms(1);
		
		   RTDSetByte(AUTO_ADJ_CTRL_7F, 0x77);

           Wait_Finish();
		   if (ERROR_SUCCEED != 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];