📄 lcd_func.c
字号:
ucSelect = ulRate * 368 / 1000000;
ucSelect = 32 >= ucSelect ? 32 - ucSelect : 64 - ucSelect;
// Calculate the absolute value from the selected phase to transition
Data[0] = (phase >= ucSelect) ? phase - ucSelect : ucSelect - phase;
ucX_Ctrl = (6 < Data[0] && 26 > Data[0]) ? 0x00 : 0x10;
Data[0] = PROGRAM_HDELAY + (stMUD.H_POSITION - ucH_Min_Margin);
// Compensate the H position shift due to the phase select
if (6 < ucSelect)
ucSelect = (phase + 6) < ucSelect ? Data[0] - 1 : Data[0];
else
ucSelect = phase < (ucSelect + 26) ? Data[0] - 1 : Data[0];
Wait_For_Event(EVENT_IEN_STOP);
RTDSetByte(IHS_DELAY_8D, ucSelect); // Compensate IHS delay
RTDSetByte(PLL_PHASE_9F, ucY_Ctrl); // Set phase
RTDSetByte(MEAS_HS_LATCH_4E, ucX_Ctrl); // Select a correct edge to latch the stable data
Delay_Xms(2);
RTDSetByte(STATUS0_01, 0x00); // Clear status
RTDSetByte(STATUS1_1F, 0x00); // Clear status
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
void Set_Bright_Contrast(void)
{
// Set RTD's contrast and brightness
if (100 < stGUD0.CONTRAST) stGUD0.CONTRAST = 50;
if (100 < stGUD0.RTD_R_CONTRAST) stGUD0.RTD_R_CONTRAST = 50;
if (100 < stGUD0.RTD_G_CONTRAST) stGUD0.RTD_G_CONTRAST = 50;
if (100 < stGUD0.RTD_B_CONTRAST) stGUD0.RTD_B_CONTRAST = 50;
Data[0] = 9;
Data[1] = Y_INC;
Data[2] = BRIGHT_R_5E;
if (SOURCE_VGA == (stGUD1.INPUT_SOURCE & 0x07))
{
Data[3] = 0x7d;
Data[4] = 0x7d;
Data[5] = 0x7d;
}
else
{
Data[3] = 0x7f;
Data[4] = 0x7f;
Data[5] = 0x7f;
}
switch ((stGUD1.INPUT_SOURCE & 0x18) >> 3)
{
case 0 :
Data[13] = stGUD4.C1_G;
Data[14] = stGUD4.C1_B;
Data[15] = stGUD4.C1_R;
break;
case 1 :
Data[13] = stGUD4.C2_G;
Data[14] = stGUD4.C2_B;
Data[15] = stGUD4.C2_R;
break;
case 2 :
Data[13] = stGUD4.C3_G;
Data[14] = stGUD4.C3_B;
Data[15] = stGUD4.C3_R;
break ;
default :
Data[13] = stGUD0.RTD_G_CONTRAST;
Data[14] = stGUD0.RTD_B_CONTRAST;
Data[15] = stGUD0.RTD_R_CONTRAST;
break;
}
#if (ANALOG_CONTRAST)
// If using the analog gain to adjust contrast, digital gain alway set to 128
if (SOURCE_VGA == (stGUD1.INPUT_SOURCE & 0x07))
Data[6] = 0x80;
else
Data[6] = (50 >= stGUD0.CONTRAST) ? 78 + stGUD0.CONTRAST : 104 + (stGUD0.CONTRAST >> 1);
#else
Data[6] = (50 >= stGUD0.CONTRAST) ? 78 + stGUD0.CONTRAST : 104 + (stGUD0.CONTRAST >> 1);
#endif
Data[7] = (50 >= Data[13]) ? (unsigned int)Data[6] * (75 + (Data[13] >> 1)) / 100
: (unsigned int)Data[6] * (88 + (Data[13] >> 2)) / 100;
Data[8] = (50 >= Data[14]) ? (unsigned int)Data[6] * (75 + (Data[14] >> 1)) / 100
: (unsigned int)Data[6] * (88 + (Data[14] >> 2)) / 100;
Data[6] = (50 >= Data[15]) ? (unsigned int)Data[6] * (75 + (Data[15] >> 1)) / 100
: (unsigned int)Data[6] * (88 + (Data[15] >> 2)) / 100;
Data[9] = 0;
RTDWrite(Data);
if (100 < stGUD0.BRIGHT) stGUD0.BRIGHT = 50;
Data[0] = 6;
Data[1] = Y_INC;
Data[2] = OSD_ADDR_MSB_90;
#if (PWM0 == BRIGHTNESS_PWM) //PWM0 OUTPUT
Data[3] = 0x00;
Data[4] = 0x01;
#elif (PWM1 == BRIGHTNESS_PWM) //PWM1 OUTPUT
Data[3] = 0x40;
Data[4] = 0x01;
#else //PWM2 OUTPUT
Data[3] = 0x80;
Data[4] = 0x01;
#endif
#if (INV_BRIGHTNESS)
Data[5] = MIN_BRIGHTNESS + (unsigned int)(MAX_BRIGHTNESS - MIN_BRIGHTNESS) * (100 - stGUD0.BRIGHT) / 100;
#else
Data[5] = MIN_BRIGHTNESS + (unsigned int)(MAX_BRIGHTNESS - MIN_BRIGHTNESS) * stGUD0.BRIGHT / 100;
#endif
Data[6] = 0;
RTDWrite(Data);
}
void Set_Gamma(void)
{
switch (stGUD1.FUNCTION & 0x60)
{
case 0x20 :
WriteGamma(GAMMA_1, GAMMA_1, GAMMA_1);
break;
case 0x40 :
WriteGamma(GAMMA_2, GAMMA_2, GAMMA_2);
break;
case 0x60 :
WriteGamma(GAMMA_3, GAMMA_3, GAMMA_3);
break;
default :
RTDSetBit(COLOR_CTRL_5D, 0xeb, 0x00); // Disable gamma function and its access channel
break;
}
}
void Set_Dithering(void)
{
#if (NEW_DITHER)
WriteDither(DITHER_1, 0);
WriteDither(NEW_DITHER_TABLE, 1);
#else
WriteDither(DITHER_1, 0);
#endif
#if (DISP_BIT == DISP_24BIT)
RTDSetBit(COLOR_CTRL_5D, 0x97, 0x00); // Disable dithering function and its access channel
#endif
}
void Sharpness(void)
{
if (MODE_NOSIGNAL != ucMode_Curr && MODE_NOSUPPORT != ucMode_Curr)
{
// For RTD2020 rev.B and later
RTDSetByte(FILTER_CTRL0_1B, 0xc4);
switch (stGUD1.FILTER)
{
case 0 :
WriteSU_COEF(SU_COEF_1, SU_COEF_1);
break;
case 1 :
WriteSU_COEF(SU_COEF_2, SU_COEF_2);
break;
case 2 :
if((usIPH_ACT_WID == 1280) && (DISP_SIZE == DISP_1280x1024))
{
WriteSU_COEF(SU_COEF_7, SU_COEF_3);
}
else
{
WriteSU_COEF(SU_COEF_3, SU_COEF_3);
}
break;
case 3 :
WriteSU_COEF(SU_COEF_4, SU_COEF_4);
break;
default :
WriteSU_COEF(SU_COEF_5, SU_COEF_5);
break;
}
RTDSetByte(FILTER_CTRL0_1B, 0xc7);
}
}
#if (ANALOG_CONTRAST)
unsigned char Set_Contrast_Gain(unsigned char ContrastValue, unsigned char ColorValue)
{
if (45 <= ContrastValue)
{
// Decrease ADC gain
if (ColorValue & 0x80)
{
ColorValue &= 0x7f;
ColorValue = ColorValue + ContrastValue - 45;
if (ColorValue > 0x7f)
ColorValue = 0xff; //(minus)
else
ColorValue |= 0x80; //(minus)
}
else
{
if (ColorValue > (ContrastValue - 45))
ColorValue = ColorValue - (ContrastValue - 45);
else
ColorValue = 0x80 | (ContrastValue - 45 - ColorValue);
}
}
else
{
// Increase ADC gain
if (ColorValue & 0x80)
{
ColorValue &= 0x7f;
if ((45 - ContrastValue) > ColorValue)
ColorValue = 45 - ContrastValue - ColorValue;
else
ColorValue = 0x80 | (ColorValue - (45 - ContrastValue));
}
else
ColorValue = ColorValue + (45 - ContrastValue);
}
return ColorValue;
}
#endif
void SetColorGainOffset(unsigned char addr, unsigned char parameter, unsigned char bios)
{
if (bios & 0x80)
{
//(minus)
bios &= 0x7f;
RTDSetByte(addr, (parameter >= bios) ? parameter - bios : 0);
}
else
{
//(plus)
RTDSetByte(addr, (parameter >= (0xff - bios)) ? 0xff : parameter + bios);
}
}
void SetADC_Gain(void)
{
unsigned char ucRed, ucGreen, ucBlue;
unsigned char ucTemp = 0;
unsigned char ucRate = (unsigned long)RTD_XTAL * usADC_Clock / usHsync / 1000; // Pixel clock in MHz
do
{
if (ucRate > ADC_Gain_FineTune[ucTemp][0])
{
ucRed = ADC_Gain_FineTune[ucTemp][1];
ucGreen = ADC_Gain_FineTune[ucTemp][2];
ucBlue = ADC_Gain_FineTune[ucTemp][3];
break;
}
if (0 == ADC_Gain_FineTune[ucTemp][0]) break;
}
while (++ucTemp);
ucTemp = 50;
#if (ANALOG_CONTRAST)
if (100 < stGUD0.CONTRAST) stGUD0.CONTRAST = 50;
ucTemp = (unsigned int)stGUD0.CONTRAST * 9 / 10;
ucRed = Set_Contrast_Gain(ucTemp, ucRed);
ucGreen = Set_Contrast_Gain(ucTemp, ucGreen);
ucBlue = Set_Contrast_Gain(ucTemp, ucBlue);
#endif
SetColorGainOffset(GRNGAIN_E1, stGUD2.AD_G_GAIN, ucGreen);
#if (SWAP_RED_BLUE)
SetColorGainOffset(REDGAIN_E0, stGUD2.AD_B_GAIN, ucBlue);
SetColorGainOffset(BLUGAIN_E2, stGUD2.AD_R_GAIN, ucRed);
#else
SetColorGainOffset(REDGAIN_E0, stGUD2.AD_R_GAIN, ucRed);
SetColorGainOffset(BLUGAIN_E2, stGUD2.AD_B_GAIN, ucBlue);
#endif
}
void SetADC_Offset(void)
{
unsigned char ucRed, ucGreen, ucBlue;
unsigned char ucTemp = 0;
unsigned char ucRate = (unsigned long)RTD_XTAL * usADC_Clock / usHsync / 1000; // Pixel clock in MHz
do
{
if (ucRate > ADC_Offset_FineTune[ucTemp][0])
{
ucRed = ADC_Offset_FineTune[ucTemp][1];
ucGreen = ADC_Offset_FineTune[ucTemp][2];
ucBlue = ADC_Offset_FineTune[ucTemp][3];
break;
}
if (0 == ADC_Offset_FineTune[ucTemp][0]) break;
}
while (++ucTemp);
SetColorGainOffset(GRNOFST_E4, stGUD2.AD_G_OFFSET, ucGreen);
#if (SWAP_RED_BLUE)
SetColorGainOffset(REDOFST_E3, stGUD2.AD_B_OFFSET, ucBlue);
SetColorGainOffset(BLUOFST_E5, stGUD2.AD_R_OFFSET, ucRed);
#else
SetColorGainOffset(REDOFST_E3, stGUD2.AD_R_OFFSET, ucRed);
SetColorGainOffset(BLUOFST_E5, stGUD2.AD_B_OFFSET, ucBlue);
#endif
}
void SetADC_GainOffset(void)
{
if (0 == usADC_Clock || 0 == usHsync) return;
SetADC_Gain();
SetADC_Offset();
}
#if (VIDEO_CHIP != VDC_NONE)
void SetVDC_Color(void)
{
if (SOURCE_YUV == (stGUD1.INPUT_SOURCE & 0x07))
{
Data[0] = 6;
Data[1] = ADDR_VIDEO;
Data[2] = VDC_BRIGHT_YUV_CTRL;
Data[3] = ((LP_VIDEO_MODE_USER_DATA)&stMUD)->VBRIGHT;
Data[4] = ((LP_VIDEO_MODE_USER_DATA)&stMUD)->VCONTRAST ^ 0x80;
Data[5] = ((LP_VIDEO_MODE_USER_DATA)&stMUD)->VSATURATION ^ 0x80;
I2CWrite(Data);
}
else
{
Data[0] = 7;
Data[1] = ADDR_VIDEO;
Data[2] = VDC_BRIGHT_CTRL;
Data[3] = ((LP_VIDEO_MODE_USER_DATA)&stMUD)->VBRIGHT;
Data[4] = ((LP_VIDEO_MODE_USER_DATA)&stMUD)->VCONTRAST ^ 0x80;
Data[5] = ((LP_VIDEO_MODE_USER_DATA)&stMUD)->VSATURATION ^ 0x80;
Data[6] = ((LP_VIDEO_MODE_USER_DATA)&stMUD)->VHUE ^ 0x80;
I2CWrite(Data);
}
}
#endif
#if (MCU_TYPE == MCU_STD8051)
bit Wait_For_Event(unsigned char event)
{
unsigned char ucDelayCnt = 30; // 30ms timeout
RTDSetByte(STATUS1_1F, 0x00); // Clear status (status register will be cleared after write)
bNotify_Timer1_Int = 0;
Data[0] = 0;
TR1 = 1;
do
{
if (bNotify_Timer1_Int)
{
bNotify_Timer1_Int = 0;
if (--ucDelayCnt) TR1 = 1;
}
RTDRead(STATUS1_1F, 1, N_INC); // Read Status1
//if ((Data[0] & EVENT_IVS) && 25 < ucDelayCnt) ucDelayCnt = 25;
Data[0] &= event;
}
while (0 == Data[0] && 0 != ucDelayCnt);
return ucDelayCnt ? 0 : 1;
}
#else
bit Wait_For_Event(unsigned char event)
{
unsigned char ucDelayCnt = 30; // 30ms timeout
RTDSetByte(STATUS1_1F,0x00); // Clear status (status register will be cleared after write)
bNotify_Timer1_Int = 0;
Data[0] = 0;
do
{
if (bNotify_Timer1_Int)
{
bNotify_Timer1_Int = 0;
ucDelayCnt -= 1;
}
RTDRead(STATUS1_1F, 1, N_INC); // Read Status1
//if ((Data[0] & EVENT_IVS) && 25 < ucDelayCnt) ucDelayCnt = 25;
Data[0] &= event;
}
while (0 == Data[0] && 0 != ucDelayCnt);
return ucDelayCnt ? 0 : 1;
}
#endif
void Set_Background_Color(unsigned char Red, unsigned char Green, unsigned char Blue)
{
RTDSetBit(OVL_CTRL_6D, 0x3f, 0x00); //Red
RTDSetByte(BGCOLOR_CONTROL_6C, Red);
RTDSetBit(OVL_CTRL_6D, 0x3f, 0x40); //Green
RTDSetByte(BGCOLOR_CONTROL_6C, Green);
RTDSetBit(OVL_CTRL_6D, 0x3f, 0x80); //Blue
RTDSetByte(BGCOLOR_CONTROL_6C, Blue);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -