📄 lcd_main.c
字号:
/////////////////////////////////////////////////////////
//------------------- Mode Detector -----------------//
/////////////////////////////////////////////////////////
void Mode_Detector(void)
{
switch (stGUD1.INPUT_SOURCE & 0x07)
{
case SOURCE_VGA :
// Save previous values of ucMode_Curr, bHpole_Curr and bVpole_Curr
bHpole_Prev = bHpole_Curr;
bVpole_Prev = bVpole_Curr;
if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
Detect_VGA_Mode();
else
Check_VGA_Mode();
break;
case SOURCE_DVI :
// Save previous values of ucMode_Curr, bHpole_Curr and bVpole_Curr
bHpole_Prev = bHpole_Curr;
bVpole_Prev = bVpole_Curr;
if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
Detect_DVI_Mode();
else
Check_DVI_Mode();
break;
#if(TV_CHIP != TV_NONE)
case SOURCE_TV :
if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
Detect_TV_Mode(); // Set default polarity
else
Check_TV_Mode(); // Set polarity after measure
break;
#endif
default :
if ((MODE_NOSIGNAL == ucMode_Curr) || (MODE_NOSUPPORT == ucMode_Curr))
Detect_Video_Mode(); // Set default polarity
else
Check_Video_Mode(); // Set polarity after measure
break;
}
Measure_Mode(); // Measure mode-timing
}
void Measure_Mode(void)
{
switch (stGUD1.INPUT_SOURCE & 0x07)
{
RTDSetByte(SYNC_CTRL_4A,0x00);
case SOURCE_VGA :
RTDSetByte(SYNC_POR_4C, (SYNC_SS == ucSync_Type) ? 0x02 : 0x32);
break;
case SOURCE_DVI :
RTDSetByte(SYNC_POR_4C, 0x02);
break;
default :
RTDSetByte(SYNC_POR_4C, 0x02);
break;
}
}
#if(SOURCE_AUTO_SCAN)
/////////////////////////////////////////////////////////
//---Detect which source with valid signal-------------//
/////////////////////////////////////////////////////////
void Measure_Source(unsigned char SOURCE)
{
switch(SOURCE)
{
case SOURCE_VGA:
RTDSetByte(SYNC_CTRL_4A,0x01);
break;
case SOURCE_DVI:
RTDSetByte(SYNC_CTRL_4A,0x03);
break;
case SOURCE_AV:
I2CWrite(V_ENABLE);
I2CWrite(AV_DETECT);
break;
case SOURCE_SV:
I2CWrite(V_ENABLE);
I2CWrite(SV_DETECT);
break;
}
//RTDSetByte(SYNC_POR_4C, 0x32);
//RTDSetByte(SYNC_POR_4C, 0x02);
//RTDSetByte(SYNC_POR_4C, (stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA ? 0x32 : 0x02);
if(((stGUD1.INPUT_SOURCE & 0x07) == SOURCE_VGA) && (SYNC_SS != ucSync_Type))
RTDSetByte(SYNC_POR_4C,0x32);
else
RTDSetByte(SYNC_POR_4C,0x02);
Delay_Xms(35);
//Delay_Xms(24);
}
#endif
/////////////////////////////////////////////////////////
//------------------ Detect VGA Mode ----------------//
/////////////////////////////////////////////////////////
void Detect_VGA_Mode(void)
{
unsigned char ucMode_Temp, m;
unsigned int usHS_Pulse;
RTDRead(SYNC_POR_4C, 0x09, Y_INC);
if (Data[0] & 0x02)
{
// Reset Sync Processor when sync signal timeout
RTDSetByte(SYNC_POR_4C, 0x20);
// Treat sync signal timeout as no signal
ucMode_Temp = MODE_NOSIGNAL;
}
else
{
/*
ucMode_Temp = (Data[8] & 0xe0 ) >> 5;
if(ucMode_Temp == 0 || ucMode_Temp >=4) //Test which edge of Hsync to latch Vsync will be safe
{
RTDSetBit(MEAS_VS_HI_54,0xf7,0x08); //Use positive edge of Hsync to latch Vsync
ucDebug_Value0 = 0x08;
}
else
{
RTDSetBit(MEAS_VS_HI_54,0xf7,0x00); //Use negtive edge of Hsync to latch Vsync
ucDebug_Value0 = 0x18;
}
*/
usStdHS = usHsync; // Save previous usHsync in usStdHS
usStdVS = usVsync; // Save previous usVsync in usStdVS
bVpole_Curr = (bit)(Data[0] & 0x08); // Save current usVsync polarity
bHpole_Curr = (bit)(Data[0] & 0x04); // Save current usHsync polarity
Data[7] = Data[5];
Data[6] = Data[6] & 0x0f;
Data[5] = Data[3];
Data[4] = Data[4] & 0x87;
Data[3] = Data[1];
Data[2] = Data[2] & 0x8f;
usHsync = ((unsigned int *)Data)[1]; // Current HSYNC timing
usVsync = ((unsigned int *)Data)[2]; // Current VSYNC timing
usHS_Pulse = ((unsigned int *)Data)[3]; // Current HSYNC pulse width
// Calculate Vertical Refresh Rate
// Original Formula :
// ucRefresh = 24.576M / (usHsync * usVsync)
// Use Data[0~3] as a temporary long variable
((unsigned long *)Data)[0] = (unsigned long)usHsync * usVsync;
ucRefresh = (unsigned long)49152000 / ((unsigned long *)Data)[0];
ucRefresh = (ucRefresh & 0x01) ? ((ucRefresh + 1) >> 1) : (ucRefresh >> 1);
// Treat small change of usHsync/usVsync as no change
if (usStdHS <= usHsync && (usStdHS + 2) >= usHsync) usHsync = usStdHS;
if (usStdVS <= usVsync && (usStdVS + 2) >= usVsync) usVsync = usStdVS;
// Polarity must be correct
if ((bVpole_Curr != bVpole_Prev) || (bHpole_Curr != bHpole_Prev))
{
RTDRead(VGIP_SIGINV_05, 0x01, N_INC);
Data[0] &= 0xd7; // HS_RAW & VS positive
if (!bHpole_Curr) Data[0] |= 0x20;
if (!bVpole_Curr && SYNC_SS == ucSync_Type) Data[0] |= 0x08; // Seperate sync
RTDSetByte(VGIP_SIGINV_05, Data[0]);
ucMode_Temp = MODE_NOSUPPORT;
}
else
{
if (0x07ff <= usHsync || 0x07ff <= usVsync || 0 == usHsync || 0 == usVsync)
{
ucMode_Temp = MODE_NOSIGNAL; // Treat overflow as no signal
}
else
{
Data[0] = usHS_Pulse * 12 / usHsync; // 0 : 720x350; 1 : 640x350;
ucMode_Temp = MODE_NOSUPPORT;
/* // Search for Standard Mode
#if(DISP_SIZE == DISP_640x480)
m = MODE_0640x0480x75HZ;
#endif
#if(DISP_SIZE == DISP_800x600)
m = MODE_0800x0600x75HZ;
#endif*/
#if(DISP_SIZE <= DISP_1024x768) //V225
m = MODE_1024x0768x75HZ;
#endif
#if(DISP_SIZE == DISP_1280x1024)
m = MODE_1280x1024x75HZ;
#endif
#if(DISP_SIZE > DISP_1280x1024)
m = MODE_1600x1200x60HZ;
#endif
do
{
if ((usHsync > VGA_Mode[m][0]) && (usHsync < VGA_Mode[m][1]))
{
if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
{
if (MODE_1280x1024x75HZ == m)
{
if (0 == (bVpole_Curr | bHpole_Curr)) m = MODE_1280x1024x76HZ; // SUN 1024-76
}
else if (MODE_1024x0768x75HZ == m)
{
if (0 == (bVpole_Curr | bHpole_Curr)) m = MODE_1024x0768x74HZ; // MAC768-75
}
else if (MODE_0640x0480x60HZ == m && bVpole_Curr != bHpole_Curr)
{
// MODE_VGA350x60Hz : 640x350 60Hz
// MODE_VGA350x60Hz | 0x40 : 720x350 60Hz
// MODE_VGA400x60Hz : 640x400 60Hz
// MODE_VGA400x60Hz | 0x40 : 720x400 60Hz
if (bHpole_Curr)
m = Data[0] ? MODE_VGA350x60Hz : MODE_VGA350x60Hz | 0x40;
else
m = (stGUD1.INPUT_SOURCE & 0x80) ? MODE_VGA400x60Hz : MODE_VGA400x60Hz | 0x40;
}
else if (MODE_0640x0480x50HZ == m && bVpole_Curr != bHpole_Curr)
{
// MODE_VGA350x50Hz : 640x350 50Hz
// MODE_VGA350x50Hz | 0x40 : 720x350 50Hz
// MODE_VGA400x50Hz : 640x400 50Hz
// MODE_VGA400x50Hz | 0x40 : 720x400 50Hz
if (bHpole_Curr)
m = Data[0] ? MODE_VGA350x50Hz : MODE_VGA350x50Hz | 0x40;
else
m = (stGUD1.INPUT_SOURCE & 0x80) ? MODE_VGA400x50Hz : MODE_VGA400x50Hz | 0x40;
}
else if (MODE_0720x0400x85HZ == m)
{
if (1 == bHpole_Curr && 0 == bVpole_Curr)
m = MODE_0640x0350x85HZ;
else if (stGUD1.INPUT_SOURCE & 0x80)
m = MODE_0640x0400x85HZ;
}
else if (MODE_0720x0400x70HZ == m)
{
if (1 == bHpole_Curr && 0 == bVpole_Curr)
m = Data[0] ? MODE_0640x0350x70HZ : MODE_0720x0350x70HZ;
else if (stGUD1.INPUT_SOURCE & 0x80)
m = MODE_0640x0400x70HZ;
}
ucMode_Temp = m;
}
}
}
while ((0 != --m) && (MODE_NOSUPPORT == ucMode_Temp));
// Search for User Mode
if (MODE_NOSUPPORT == ucMode_Temp)
{
/* usIPV_ACT_LEN = 0;
#if(DISP_SIZE == DISP_640x480)
m = MODE_USER640x480;
#endif
#if(DISP_SIZE == DISP_800x600)
m = MODE_USER800x600;
#endif*/
#if(DISP_SIZE <= DISP_1024x768) //V225
m = MODE_USER1024x768;
#endif
#if(DISP_SIZE == DISP_1280x1024)
m = MODE_USER1280x1024;
#endif
#if(DISP_SIZE > DISP_1280x1024)
m = MODE_USER1600x1200;
#endif
do
{
if ((usVsync >= VGA_Mode[m][2]) && (usVsync <= VGA_Mode[m][3]))
{
usIPV_ACT_LEN = CAP_WIN[m][4];
if ((usHsync >= VGA_Mode[m][0]) && (usHsync <= VGA_Mode[m][1]))
{
ucMode_Temp = m; // Support User Mode
}
}
}
while ((MODE_USER720x400 <= --m) && (MODE_NOSUPPORT == ucMode_Temp));
}
if (48 > ucRefresh || MAX_RATE < ucRefresh)
{
ucMode_Temp = MODE_NOSUPPORT; // We don't support vertical refresh rate lower than 50Hz
}
else if (MODE_NOSUPPORT == ucMode_Temp && 0 != usIPV_ACT_LEN)
{
if (DISP_LEN < usIPV_ACT_LEN) // V Scale-down
{
// Estimate display clock rate for full screen
// DCLK = (24.576MHz / usHsync) * DCLK per display line * (display image lines / input image lines)
((unsigned int *)Data)[0] = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * DISP_LEN
/ ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
if (MAX_DCLK < ((unsigned int *)Data)[0])
{
// If clock rate for full-screen display is too high, we can try partial-V display.
// Estimate clock for partial-V display
// DCLK = (24.576MHz / usHsync) * DCLK per display line * (min. display total lines / input total lines)
((unsigned int *)Data)[1] = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED1][0] * MIN_DV_TOTAL
/ ((unsigned long)100 * (usVsync - 1) * usHsync);
if (MAX_DCLK < ((unsigned int *)Data)[1])
{
// Decrease usIPV_ACT_LEN to DISP_LEN and go further to check if it can be displayed.
usIPV_ACT_LEN = DISP_LEN;
}
else
{
ucMode_Temp = MODE_UNDEFINED1 | 0x80; // Scale-down and partial-V display
}
}
else
ucMode_Temp = MODE_UNDEFINED1; // Scale-down and full-V display
}
if (DISP_LEN >= usIPV_ACT_LEN) // V Scale-up
{
((unsigned int *)Data)[0] = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * DISP_LEN
/ ((unsigned long)100 * usIPV_ACT_LEN * usHsync);
if (MAX_DCLK < ((unsigned int *)Data)[0])
{
if (MIN_DV_TOTAL >= (usVsync - 1))
{
((unsigned int *)Data)[1] = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0] * MIN_DV_TOTAL
/ ((unsigned long)100 * (usVsync - 1) * usHsync);
}
else
{
((unsigned int *)Data)[1] = (unsigned long)2458 * Mode_Preset[MODE_UNDEFINED0][0]
/ ((unsigned long)100 * usHsync);
}
if (MAX_DCLK < ((unsigned int *)Data)[1])
ucMode_Temp = MODE_NOSUPPORT; // Cannot display
else
ucMode_Temp = MODE_UNDEFINED0 | 0x80; // Scale-up and partial-V display
}
else
ucMode_Temp = MODE_UNDEFINED0; // Scale-up and full-V display
}
}
}
}
}
if (SYNC_SOG == ucSync_Type && 0 != (usHS_Pulse * 7 / usHsync))
{
// To prevent from SOG mode mistake
// HSYNC pulse width will never longer than 1/7*HSYNC period
ucMode_Temp = MODE_NOSIGNAL;
}
//-------------Check result-----------------------------------------
if (MODE_NOSUPPORT == ucMode_Temp || MODE_NOSIGNAL == ucMode_Temp)
{
// Treat illegal signal as no signal when SOG
if (SYNC_SOG == ucSync_Type) ucMode_Temp = MODE_NOSIGNAL;
if (MODE_NOSUPPORT != ucMode_Found && MODE_NOSIGNAL != ucMode_Found) ucMode_Times = 0;
ucMode_Found = ucMode_Temp;
LED_GREEN = 0X00;
LED_RED = 0X00;
if (NO_MODE_TIMES > ucMode_Times)
{
// Wait for signal stable
ucMode_Times ++;
}
else
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -