📄 lcd_auto.c
字号:
ucResult = (ucPhase == 0x00) ? 0x7c : ucPhase - 0x04;
}
ucDetect -= 1;
ulTemp2 = ulTemp0;
ulTemp0 = ((unsigned long *)Data)[3];
}while(ucDetect);
#else //FAST AUTO method 2
// 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);
ulTemp2 = ((unsigned long *)Data)[1];
// Set phase 0
//Set_Phase(0x00 | ucDetect);
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(2);
ulTemp1 = ((unsigned long *)Data)[2];
ulTemp0 = 0;
ucResult = 0x08;
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];
((unsigned long *)Data)[0]
= ulTemp2 + ulTemp1 + ((unsigned long *)Data)[3]
- ((ulTemp1 > ulTemp2 ? ulTemp1 - ulTemp2 : ulTemp2 - ulTemp1) / 2)
- ((ulTemp1 > ((unsigned long *)Data)[3] ? ulTemp1 - ((unsigned long *)Data)[3] : ((unsigned long *)Data)[3] - ulTemp1) / 2);
if (ulTemp0 < ((unsigned long *)Data)[0])
{
ulTemp0 = ((unsigned long *)Data)[0];
ucResult = ucPhase - 0x08;
}
ulTemp2 = ulTemp1;
ulTemp1 = ((unsigned long *)Data)[3];
ucPhase = ucPhase + 0x08;
}
while (0x78 != ucPhase);
// ((unsigned long *)Data)[0] = ulTemp1 + ulTemp2 + ((unsigned long *)Data)[3];
// ((unsigned long *)Data)[1] = ((unsigned long *)Data)[3] + ulTemp1 + ((unsigned long *)Data)[2];
((unsigned long *)Data)[0]//phase26+phase28+phase30
= ulTemp2 + ulTemp1 + ((unsigned long *)Data)[1]
- ((ulTemp1 > ulTemp2 ? ulTemp1 - ulTemp2 : ulTemp2 - ulTemp1) / 2)
- ((ulTemp1 > ((unsigned long *)Data)[1] ? ulTemp1 - ((unsigned long *)Data)[1] : ((unsigned long *)Data)[1] - ulTemp1) / 2);
((unsigned long *)Data)[3]//phase28+phase30+phase0
= ulTemp1 + ((unsigned long *)Data)[1] + ((unsigned long *)Data)[2]
- ((((unsigned long *)Data)[1] > ulTemp1 ? ((unsigned long *)Data)[1] - ulTemp1 : ulTemp1 - ((unsigned long *)Data)[1]) / 2)
- ((((unsigned long *)Data)[1] > ((unsigned long *)Data)[2] ? ((unsigned long *)Data)[1] - ((unsigned long *)Data)[2] : ((unsigned long *)Data)[2] - ((unsigned long *)Data)[1]) / 2);
if (ulTemp0 < ((unsigned long *)Data)[0])
{
ulTemp0 = ((unsigned long *)Data)[0];
ucResult = 0x70; //ucResult = phase28
}
if (ulTemp0 < ((unsigned long *)Data)[3])
{
ulTemp0 = ((unsigned long *)Data)[3];
ucResult = 0x78; //ucResult = phase30
}
ucPhase = ucResult >= 0x08 ? (ucResult - 0x08) : (ucResult + 0x80 - 0x08);
ulTemp0 = 0;
ulTemp1 = 0;
ulTemp2 = 0;
ucDetect = 3;
Set_Phase(ucPhase); //set Phase(n-2)
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];
ucPhase = (ucPhase == 0x7c) ? 0x00 : ucPhase + 0x04; //set Phase(n-1)
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(2);
ulTemp2 = ((unsigned long*)Data)[2];
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]
= ulTemp1 + ulTemp2 + ((unsigned long *)Data)[3]
- ((ulTemp1 > ulTemp2 ? ulTemp1 - ulTemp2 : ulTemp2 - ulTemp1) / 2)
- ((ulTemp2 > ((unsigned long *)Data)[3] ? ulTemp2 - ((unsigned long *)Data)[3] : ((unsigned long *)Data)[3] - ulTemp2) / 2);
if(((unsigned long*)Data)[0] > ulTemp0)
{
ulTemp0 = ((unsigned long*)Data)[0];
ucResult = (ucPhase == 0x00) ? 0x7c : ucPhase - 0x04;
}
ucDetect -= 1;
ulTemp1 = ulTemp2;
ulTemp2 = ((unsigned long *)Data)[3];
}while(ucDetect);
// ucDebug_Value1 = ucResult;
#endif
stMUD.PHASE = ucResult;
Set_Phase(stMUD.PHASE);
/*
//restore the bandwidth setup of ADC
if(ucMode_Curr < MODE_1024x0768x70HZ)
RTDSetByte(ADC_REG_TEST_E9, 0x08);
else
RTDSetByte(ADC_REG_TEST_E9, 0x10);
*/
return ERROR_SUCCEED;
}
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; // Save current stMUD.H_POSITION
Curr_PosV = stMUD.V_POSITION; // Save current stMUD.V_POSITION
Curr_Clock = stMUD.CLOCK; // Save current stMUD.CLOCK
Curr_Phase = stMUD.PHASE; // Save current stMUD.PHASE
if (ucV_Max_Margin < stMUD.V_POSITION)
{
stMUD.V_POSITION = ucV_Max_Margin - 1;
Set_V_Position();
}
// RTDCodeW(ADC_DEFAULT);
/////////original formula////////////////////////////////////////////
//Set the H Position center(without IHS_Delay)
/*
stMUD.H_POSITION = 128;
if(128 >= stMUD.H_POSITION)
{
ucTemp = 128 - stMUD.H_POSITION;
if(stMUD.CLOCK > 128)
ucTemp1 = 128;
else
ucTemp1 = stMUD.CLOCK;
//According to the H_Position adjust the IHS pre-delay
ucH_Min_Margin = 128 - ucTemp - (64 - (ucTemp1 >> 1));
//Return the IPH_ACT_STA to the original one first,and compensate the IHS pre-delay
//The h position must be equal after change the IHS delay and IPH_ACT_STA
usIPH_ACT_STA = usIPH_ACT_STA + 50 - ucTemp - (64 - (ucTemp1 >> 1));
usTemp = usIPH_ACT_STA;
Set_H_Position();
}
*/
///////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//Set the H Position center(without IHS_Delay)
stMUD.H_POSITION = 128;
//ucTemp = 128 - stMUD.H_POSITION;
if(stMUD.CLOCK > 128)
ucTemp1 = 128;
else
ucTemp1 = stMUD.CLOCK;
//According to the H_Position adjust the IHS pre-delay
ucH_Min_Margin = 128 - (64 - (ucTemp1 >> 1));
//Return the IPH_ACT_STA to the original one first,and compensate the IHS pre-delay
//The h position must be equal after change the IHS delay and IPH_ACT_STA
usIPH_ACT_STA = CAP_WIN[ucMode_Curr][1];
if(ucMode_Curr < MODE_0800x0600x75HZ)
Data[0] = 2;
else if(ucMode_Curr < MODE_1280x1024x75HZ)
Data[0] = 5;
else
Data[0] = 3;
// usIPH_ACT_STA = usIPH_ACT_STA + Data[0] - PROGRAM_HDELAY;
//usIPH_ACT_STA = usIPH_ACT_STA + 50 - (64 - (ucTemp1 >> 1));
usIPH_ACT_STA = CAP_WIN[ucMode_Curr][1] + Data[0] - PROGRAM_HDELAY - (64 - (ucTemp1 >> 1));
usTemp = usIPH_ACT_STA;
Set_H_Position();
RTDSetByte(STATUS0_01, 0x00); // Clear status
RTDSetByte(STATUS1_1F, 0x00); // Clear status
///////////////////////////////////////////////////////////////////
///////////////////////////////
// Measure NOISE_MARGIN //
///////////////////////////////
Result = Min_Noise_Margin();
Noise = Data[0];
//--------Auto_Clock-----------
if (ERROR_SUCCEED == (Result & 0x80))
{
stMUD.CLOCK = (stMUD.CLOCK) & 0xfc; // stMUD.CLOCK must be times of 4
if (stMUD.CLOCK != Curr_Clock) Set_Clock();
///////////////////////////////
// Adjust Clock //
///////////////////////////////
Result = Auto_Clock_Do(Noise);
if (ERROR_SUCCEED != (Result & 0x80))
{
if (stMUD.CLOCK != Curr_Clock)
{
// Fail to find out suitable clock. Restore original clock and H position.
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();
}
}
//---------Auto_Phase-----------
if (ERROR_SUCCEED == (Result & 0x80))
{
Result = Auto_Phase_Do(Noise);
if (ERROR_SUCCEED != (Result & 0x80))
{
// Restore Phase
stMUD.PHASE = Curr_Phase;
Set_Phase(stMUD.PHASE);
if (ERROR_NOTACTIVE == Result) Result = ERROR_SUCCEED;
}
}
//---------Auto_Position-----------
if (ERROR_SUCCEED == (Result & 0x80))
{
///////////////////////////////
// Adjust (H/V)Position //
///////////////////////////////
Result = Auto_Position_Do(Noise);
// Because Auto_Position_Do() never returns bit-7 error, we don't have to check here.
}
else
{
stMUD.V_POSITION = Curr_PosV;
Set_V_Position();
}
// if (ERROR_SUCCEED == (Result & 0x80)) Save_MUD(ucMode_Curr);
//////////////////////////////////////////////////////////////////////////////
/*
if(ucH_Min_Margin == (128 - ucTemp - (64 - (ucTemp1 >> 1))))
{
if(usTemp != usIPH_ACT_STA)
{ //if usIPH_ACT_STA has been modified, turn back to original set value
//stMUD.H_POSIITON also have to follow up the change of 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();
}
Set_Phase(stMUD.PHASE);
*/
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
if(ucH_Min_Margin == (128 - (64 - (ucTemp1 >> 1))))
{
if(usTemp != usIPH_ACT_STA)
{ //if usIPH_ACT_STA has been modified, turn back to original set value
//stMUD.H_POSIITON also have to follow up the change of usIPH_ACT_STA
//Data[3] = 78 - usIPH_ACT_STA; Save the usIPH_ACT_STA compensate value
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;
}
// Save Frame-Sync Settings
Data[0] = 4;
Data[1] = ADDR_EROM1;
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(SET_2404_DELAY);
ucH_Min_Margin = 128 - 50;
Set_H_Position();
}
Set_Phase(stMUD.PHASE);
if (ERROR_SUCCEED == (Result & 0x80)) Save_MUD(ucMode_Curr);
RTDSetByte(STATUS0_01, 0x00); // Clear status
RTDSetByte(STATUS1_1F, 0x00); // Clear status
/////////////////////////////////////////////////////////////////////////////////
// Restore ADC Gain/Offset
// SetADC_GainOffset();
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; // Save current stMUD.V_P⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -