public void Update_Calculated_Vdata(DP173_or_Elgin model, Gamma_Set Set)
{
DP173_Model_Option_Form DP173 = (DP173_Model_Option_Form)Application.OpenForms["DP173_Model_Option_Form"];
RGB_Double[,] Temp_Calculated_Vdata = Get_Calculated_Vdata(Set);
double[] Temp_Calculated_Vreg1_Voltage = Get_Calculated_Vreg1_Voltage(Set);
//-------------Added on 200316-----------
if (model.band < 11)
{
//update Vreg1 , R/G/B AM2 Voltage
if (model.gray == 0)
{
int Dec_Vreg1 = DP173.DP173_Get_Normal_Initial_Vreg1(model.band, Set);//Current_Band Vreg1
Temp_Calculated_Vreg1_Voltage[model.band] = Imported_my_cpp_dll.DP173_Get_Vreg1_Voltage(Dec_Vreg1, DP173.Voltage_VREG1_REF2047, DP173.Voltage_VREG1_REF1635, DP173.Voltage_VREG1_REF1227, DP173.Voltage_VREG1_REF815, DP173.Voltage_VREG1_REF407, DP173.Voltage_VREG1_REF63, DP173.Voltage_VREG1_REF1);
Temp_Calculated_Vdata[model.band, model.gray].double_R = Imported_my_cpp_dll.DP173_Get_AM2_Gamma_Voltage(DP173.Voltage_VREG1_REF2047, Temp_Calculated_Vreg1_Voltage[model.band], model.Gamma.int_R);
Temp_Calculated_Vdata[model.band, model.gray].double_G = Imported_my_cpp_dll.DP173_Get_AM2_Gamma_Voltage(DP173.Voltage_VREG1_REF2047, Temp_Calculated_Vreg1_Voltage[model.band], model.Gamma.int_G);
Temp_Calculated_Vdata[model.band, model.gray].double_B = Imported_my_cpp_dll.DP173_Get_AM2_Gamma_Voltage(DP173.Voltage_VREG1_REF2047, Temp_Calculated_Vreg1_Voltage[model.band], model.Gamma.int_B);
}
//update R/G/B Normal Voltage
else
{
Temp_Calculated_Vdata[model.band, model.gray].double_R = Imported_my_cpp_dll.DP173_Get_GR_Gamma_Voltage(DP173.Voltage_VREG1_REF2047, Temp_Calculated_Vreg1_Voltage[model.band], model.R_AM1_Dec, Temp_Calculated_Vdata[model.band, (model.gray - 1)].double_R, model.Gamma.int_R, model.gray);
Temp_Calculated_Vdata[model.band, model.gray].double_G = Imported_my_cpp_dll.DP173_Get_GR_Gamma_Voltage(DP173.Voltage_VREG1_REF2047, Temp_Calculated_Vreg1_Voltage[model.band], model.G_AM1_Dec, Temp_Calculated_Vdata[model.band, (model.gray - 1)].double_G, model.Gamma.int_G, model.gray);
Temp_Calculated_Vdata[model.band, model.gray].double_B = Imported_my_cpp_dll.DP173_Get_GR_Gamma_Voltage(DP173.Voltage_VREG1_REF2047, Temp_Calculated_Vreg1_Voltage[model.band], model.B_AM1_Dec, Temp_Calculated_Vdata[model.band, (model.gray - 1)].double_B, model.Gamma.int_B, model.gray);
}
}
//---------------------------------------
}
public RGB AM1_Convert_Voltgae_to_Dec(Gamma_Set Set, int band, RGB_Double AM1_Voltage)
{
RGB AM1_Dec = new RGB();
AM1_Dec.int_R = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Dec(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), AM1_Voltage.double_R);
AM1_Dec.int_G = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Dec(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), AM1_Voltage.double_G);
AM1_Dec.int_B = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Dec(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), AM1_Voltage.double_B);
if (AM1_Dec.int_R > DP213_Static.AM1_AM0_Max)
{
AM1_Dec.int_R = DP213_Static.AM1_AM0_Max;
}
if (AM1_Dec.int_G > DP213_Static.AM1_AM0_Max)
{
AM1_Dec.int_G = DP213_Static.AM1_AM0_Max;
}
if (AM1_Dec.int_B > DP213_Static.AM1_AM0_Max)
{
AM1_Dec.int_B = DP213_Static.AM1_AM0_Max;
}
if (AM1_Dec.int_R < 0)
{
AM1_Dec.int_R = 0;
}
if (AM1_Dec.int_G < 0)
{
AM1_Dec.int_G = 0;
}
if (AM1_Dec.int_B < 0)
{
AM1_Dec.int_B = 0;
}
return(AM1_Dec);
}
protected bool Get_Initial_RVreg1B_Using_LUT_MCI(Gamma_Set Set, int band, OC_Mode Mode)
{
if ((band >= 1) && (band <= DP213_Static.Max_HBM_and_Normal_Band_Amount) && (vars.Target.double_Lv > Algorism_Lower_Skip_LV) && (vars.Target.double_Lv < Algorism_Upper_Skip_LV))
{
f1().GB_Status_AppendText_Nextline("Before) R/G/B/Vreg1 = " + vars.Gamma.int_R.ToString() + "/" + vars.Gamma.int_G.ToString().ToString() + "/" + vars.Gamma.int_B.ToString() + "/" + vars.Vreg1, Color.Blue);
int gray = 0;
RGB_Double Gray = DP213_Main_OC_Flow.init_gray_lut.Get_LUT_RGB(band, gray, Mode);
RGB_Double Gamma_Voltage = new RGB_Double();
Gamma_Voltage.double_R = InterpolationFomulaFactory.GetPrevBand_Red_Volatge(Gray.double_R);
Gamma_Voltage.double_G = InterpolationFomulaFactory.GetPrevBand_Green_Volatge(Gray.double_G);
Gamma_Voltage.double_B = InterpolationFomulaFactory.GetPrevBand_Blue_Volatge(Gray.double_B);
double Voltage_VREF0 = storage.Get_Voltage_VREF0();
double Voltage_VREF4095 = storage.Get_Voltage_VREF4095();
double Vreg1_voltage = Voltage_VREF4095 + ((Gamma_Voltage.double_G - Voltage_VREF4095) * (900.0 / (storage.Get_All_band_gray_Gamma(Set, (band - 1), gray).int_G + 389.0))); //just use HBM_Gamma[0], because other normal band copy G255 R/G/B From HBM
vars.Vreg1 = Imported_my_cpp_dll.DP213_Get_Vreg1_Dec(Voltage_VREF4095, Voltage_VREF0, Vreg1_voltage);
vars.Gamma.int_R = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Dec(Voltage_VREF4095, Vreg1_voltage, Gamma_Voltage.double_R);
vars.Gamma.int_B = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Dec(Voltage_VREF4095, Vreg1_voltage, Gamma_Voltage.double_B);
f1().GB_Status_AppendText_Nextline("After C++) R/G/B/Vreg1 = " + vars.Gamma.int_R.ToString() + "/" + vars.Gamma.int_G.ToString().ToString() + "/" + vars.Gamma.int_B.ToString() + "/" + vars.Vreg1, Color.Red);
init_algorithm_storage_cpp.Set_All_band_gray_Gamma(Set, band, gray, vars.Gamma);
return(true);
}
else
{
f1().GB_Status_AppendText_Nextline("Skip)Get_Initial_RVreg1B_Using_LUT_MCI()", Color.DarkRed);
return(false);
}
}
public RGB_Double Get_Band_Set_Voltage_AM0(Gamma_Set Set, int band)
{
int Set_Index = Convert.ToInt16(Set);
Voltage_AM0[Set_Index, band].double_R = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM0(Set, band).int_R);
Voltage_AM0[Set_Index, band].double_G = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM0(Set, band).int_G);
Voltage_AM0[Set_Index, band].double_B = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM0(Set, band).int_B);
return(Voltage_AM0[Set_Index, band]);
}
public void Set_and_Send_VREF0(double New_VREF0_Voltage)
{
ocparam.Set_Normal_REF0(Convert.ToByte(Imported_my_cpp_dll.DP213_VREF0_Voltage_to_Dec(New_VREF0_Voltage)));
api.WriteLine("New VREF0 :" + ocparam.Get_Normal_REF0());
byte[][] Output_CMD = ModelFactory.Get_DP213_Instance().Get_REF4095_REF0_CMD(ocparam.Get_Normal_REF4095(), ocparam.Get_Normal_REF0());
cmd.SendMipiCMD(Output_CMD);
}
public void Set_OC_Mode_Vreg1(int Vreg1, OC_Mode mode, int band)
{
dprotocal.api.WriteLine($"[Mode{mode}/Band{band}] Vreg1 : {Vreg1}", Color.Purple);
int[] OCMode_Vreg1 = Get_OC_Mode_Vreg1(mode);
double[] OCMode_Vreg1_Voltage = Get_OC_Mode_Vreg1_Voltage(mode);
OCMode_Vreg1[band] = Vreg1;
OCMode_Vreg1_Voltage[band] = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), ref0ref4095.Get_Normal_REF0_Voltage(), Vreg1);
}
private void Sub_ELVSS_and_Vinit2_Compensation(OC_Mode mode, int band, double ELVSS_Voltage_Max, double ELVSS_Voltage_Min)
{
if (vars.Optic_Compensation_Stop == false)
{
double[] First_Five_Lv = new double[5];
double Found_ELVSS_Voltage = Double.MinValue;
List <double> ELVSS_list = new List <double>();
List <double> Lv_list = new List <double>();
int index = 0;
for (double elvss_voltage = elvss_oc_obj.Get_First_ELVSS_Voltage(); elvss_voltage < elvss_oc_obj.Get_Last_ELVSS_Voltage(); elvss_voltage += elvss_oc_obj.ELVSS_Minimum_Step())
{
Set_and_Send_ELVSS_CMD(mode, band, Imported_my_cpp_dll.DP213_ELVSS_Voltage_to_Dec(elvss_voltage));
Thread.Sleep(20);
ELVSS_list.Add(elvss_voltage);
XYLv[] MultiMeasured = Get_Multitimes_Measured_Values(how_many_times: 5);
double final_lv = elvss_oc_obj.Get_Average_XYLv_After_Remove_Min_Max(MultiMeasured).double_Lv;
Lv_list.Add(final_lv);
api.WriteLine(index + ")elvss_voltage :" + elvss_voltage);
if (index < 5)
{
First_Five_Lv[index] = final_lv;
api.WriteLine(index + ") First_Five_Lv[index] :" + First_Five_Lv[index]);
}
else if (Math.Round(elvss_voltage - (elvss_oc_obj.Get_ELVSSArrayLength() - 2) * 0.1, 1) >= ELVSS_Voltage_Min)
{
api.WriteLine("elvss_voltage / ELVSS_Voltage_Min : " + elvss_voltage + " / " + ELVSS_Voltage_Min);
api.WriteLine(Math.Round((elvss_voltage - (elvss_oc_obj.Get_ELVSSArrayLength() - 2) * 0.1), 1) + " >= " + ELVSS_Voltage_Min);
double[] ELVSS;
double[] Lv;
Update_ELVSS_LV_Array(out ELVSS, out Lv, ELVSS_list, Lv_list);
for (int k = 0; k < ELVSS.Length; k++)
{
api.WriteLine(ELVSS[k] + " / " + Lv[k]);
}
Found_ELVSS_Voltage = elvss_oc_obj.FindELVSS(First_Five_Lv, ELVSS, Lv);
api.WriteLine("Found_ELVSS_Voltage / ELVSS_Voltage_Max : " + Found_ELVSS_Voltage + " / " + ELVSS_Voltage_Max);
api.WriteLine("elvss_compensation_obj.Is_ELVSS_Found() : " + elvss_oc_obj.Is_ELVSS_Found());
if (elvss_oc_obj.Is_ELVSS_Found() || Found_ELVSS_Voltage >= ELVSS_Voltage_Max)
{
break;
}
}
index++;
}
Set_and_Send_ELVSS_and_Vinit2(Found_ELVSS_Voltage);
Set_and_Send_Cold_ELVSS_and_Vinit2();
}
}
private void RGBOpticCompensation(ref RGB Gamma, OC_Mode mode, int band, int gray)
{
XYLv Measured = ocparam.Get_OC_Mode_Measure(mode, band, gray);
XYLv Target = ocparam.Get_OC_Mode_Target(mode, band, gray);
XYLv Limit = ocparam.Get_OC_Mode_Limit(mode, band, gray);
XYLv ExtensionXY = ocparam.Get_OC_Mode_ExtensionXY(mode, band, gray);
int loopCount = ocparam.Get_OC_Mode_LoopCount(mode, band, gray);
vars.Check_InfiniteLoop(loopCount, Gamma);
Imported_my_cpp_dll.Sub_Compensation(loopCount, vars.IsInfiniteLoop, ref vars.InfiniteLoopCount, ref Gamma.int_R, ref Gamma.int_G, ref Gamma.int_B, Measured.double_X, Measured.double_Y, Measured.double_Lv, Target.double_X, Target.double_Y, Target.double_Lv, Limit.double_X, Limit.double_Y, Limit.double_Lv, ExtensionXY.double_X, ExtensionXY.double_Y, DP213_Static.Gamma_Register_Max, ref vars.Gamma_Out_Of_Register_Limit, ref vars.Within_Spec_Limit);
}
public double Get_OC_Mode_Vreg1_Voltage(OC_Mode mode, int band)
{
if (band > DP213_Static.Max_HBM_and_Normal_Band_Amount)
{
throw new Exception("band should be less than " + DP213_Static.Max_HBM_and_Normal_Band_Amount);
}
int[] OCMode_Vreg1 = Get_OC_Mode_Vreg1(mode);
double[] OCMode_Vreg1_Voltage = Get_OC_Mode_Vreg1_Voltage(mode);
OCMode_Vreg1_Voltage[band] = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), ref0ref4095.Get_Normal_REF0_Voltage(), OCMode_Vreg1[band]);
return(OCMode_Vreg1_Voltage[band]);
}
public void Set_Band_Set_AM0(Gamma_Set Set, int band, RGB New_AM0)
{
if (band < DP213_Static.Max_HBM_and_Normal_Band_Amount)
{
int Set_Index = Convert.ToInt16(Set);
AM0[Set_Index, band] = New_AM0;
Voltage_AM0[Set_Index, band].double_R = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM0(Set, band).int_R);
Voltage_AM0[Set_Index, band].double_G = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM0(Set, band).int_G);
Voltage_AM0[Set_Index, band].double_B = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM0(Set, band).int_B);
}
}
private void RVreg1BOpticCompensation(ref RGB Gamma, ref int vreg1, OC_Mode mode, int band, int gray)
{
XYLv Measured = ocparam.Get_OC_Mode_Measure(mode, band, gray);
XYLv Target = ocparam.Get_OC_Mode_Target(mode, band, gray);
XYLv Limit = ocparam.Get_OC_Mode_Limit(mode, band, gray);
XYLv ExtensionXY = ocparam.Get_OC_Mode_ExtensionXY(mode, band, gray);
int loopCount = ocparam.Get_OC_Mode_LoopCount(mode, band, gray);
Imported_my_cpp_dll.Vreg1_Compensation(loopCount, Vreg1_Infinite_Loop: false, Vreg1_Infinite_Loop_Count: 0, ref Gamma.int_R, ref vreg1, ref Gamma.int_B, Measured.double_X, Measured.double_Y, Measured.double_Lv,
Target.double_X, Target.double_Y, Target.double_Lv, Limit.double_X, Limit.double_Y, Limit.double_Lv, ExtensionXY.double_X, ExtensionXY.double_Y, DP213_Static.Gamma_Register_Max,
DP213_Static.Vreg1_Register_Max, ref vars.Gamma_Out_Of_Register_Limit, ref vars.Within_Spec_Limit);
}
protected bool Get_Initial_RGB_Using_LUT_MCI(Gamma_Set Set, int band, int gray, OC_Mode Mode)
{
if ((band >= 1) && (band <= DP213_Static.Max_HBM_and_Normal_Band_Amount) && (vars.Target.double_Lv > Algorism_Lower_Skip_LV) && (vars.Target.double_Lv < Algorism_Upper_Skip_LV))
{
RGB_Double Gray = DP213_Main_OC_Flow.init_gray_lut.Get_LUT_RGB(band, gray, Mode);
RGB_Double Gamma_Voltage = new RGB_Double();
Gamma_Voltage.double_R = InterpolationFomulaFactory.GetPrevBand_Red_Volatge(Gray.double_R);
Gamma_Voltage.double_G = InterpolationFomulaFactory.GetPrevBand_Green_Volatge(Gray.double_G);
Gamma_Voltage.double_B = InterpolationFomulaFactory.GetPrevBand_Blue_Volatge(Gray.double_B);
f1().GB_Status_AppendText_Nextline("Before) R/G/B/Vreg1 = " + vars.Gamma.int_R.ToString() + "/" + vars.Gamma.int_G.ToString().ToString() + "/" + vars.Gamma.int_B.ToString() + "/" + vars.Vreg1, Color.Blue);
if (gray == 0)
{
double Voltage_VREF4095 = storage.Get_Voltage_VREF4095();
double Vreg1_Voltage = storage.Get_Normal_Voltage_Vreg1(Set, band);
vars.Gamma.int_R = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Dec(Voltage_VREF4095, Vreg1_Voltage, Gamma_Voltage.double_R);
vars.Gamma.int_G = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Dec(Voltage_VREF4095, Vreg1_Voltage, Gamma_Voltage.double_G);
vars.Gamma.int_B = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Dec(Voltage_VREF4095, Vreg1_Voltage, Gamma_Voltage.double_B);
}
else
{
RGB_Double AM1_Voltage = storage.Get_Band_Set_Voltage_AM1(Set, band);
RGB_Double Prvious_Gray_Gamma_Voltage;
if (gray == 4 || gray == 6 || gray == 8)
{
Prvious_Gray_Gamma_Voltage = storage.Get_Voltage_All_band_gray_Gamma(Set, band, (gray - 2));
}
else
{
Prvious_Gray_Gamma_Voltage = storage.Get_Voltage_All_band_gray_Gamma(Set, band, (gray - 1));
}
vars.Gamma.int_R = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Dec(AM1_Voltage.double_R, Prvious_Gray_Gamma_Voltage.double_R, Gamma_Voltage.double_R, gray);
vars.Gamma.int_G = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Dec(AM1_Voltage.double_G, Prvious_Gray_Gamma_Voltage.double_G, Gamma_Voltage.double_G, gray);
vars.Gamma.int_B = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Dec(AM1_Voltage.double_B, Prvious_Gray_Gamma_Voltage.double_B, Gamma_Voltage.double_B, gray);
}
f1().GB_Status_AppendText_Nextline("After C++) R/G/B/Vreg1 = " + vars.Gamma.int_R.ToString() + "/" + vars.Gamma.int_G.ToString().ToString() + "/" + vars.Gamma.int_B.ToString() + "/" + vars.Vreg1, Color.Red);
init_algorithm_storage_cpp.Set_All_band_gray_Gamma(Set, band, gray, vars.Gamma);
return(true);
}
else
{
f1().GB_Status_AppendText_Nextline("Skip)Get_Initial_RGB_Using_LUT_MCI()", Color.DarkRed);
return(false);
}
}
public void Set_OC_Mode_AM0(RGB_Double AM0_Voltage, OC_Mode mode, int band)
{
if (band > DP213_Static.Max_HBM_and_Normal_Band_Amount)
{
throw new Exception("band should be less than " + DP213_Static.Max_HBM_and_Normal_Band_Amount);
}
RGB AM0 = new RGB();
AM0.int_R = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Dec(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), AM0_Voltage.double_R);
AM0.int_G = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Dec(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), AM0_Voltage.double_G);
AM0.int_B = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Dec(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), AM0_Voltage.double_B);
Set_OC_Mode_AM0(AM0, mode, band);
}
public void Set_OC_Mode_AM0(RGB AM0, OC_Mode mode, int band)
{
AM0 = AM1_AM0_BoundaryCheck(AM0);
RGB[] OCMode_AM0 = Get_OC_Mode_AM0(mode);
RGB_Double[] OCMode_AM0_Voltage = Get_OC_Mode_AM0_Voltage(mode);
OCMode_AM0[band] = AM0;
if (band < DP213_Static.Max_HBM_and_Normal_Band_Amount)
{
OCMode_AM0_Voltage[band].double_R = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), AM0.int_R);
OCMode_AM0_Voltage[band].double_G = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), AM0.int_G);
OCMode_AM0_Voltage[band].double_B = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), AM0.int_B);
}
}
private void Sub_DP213_Gray255_Get_Intial_R_Vreg1_B_Using_Previous_Band_Method(Gamma_Set Set, int band, OC_Mode Mode)
{
int Previous_Band_Vreg1_Dec = storage.Get_Normal_Dec_Vreg1(Set, (band - 1));
double Voltage_VREF4095 = storage.Get_Voltage_VREF4095();
double Voltage_VREF0 = storage.Get_Voltage_VREF0();
RGB Prev_Band_AM1 = storage.Get_Band_Set_AM1(Set, (band - 1));
storage.Set_Band_Set_AM1(Set, band, Prev_Band_AM1);//update AM1 voltage
RGB_Double Prev_Band_Voltage_AM1 = storage.Get_Band_Set_Voltage_AM1(Set, (band - 1));
int[] Previous_Band_Gamma_Red = new int[DP213_Static.Max_Gray_Amount];
int[] Previous_Band_Gamma_Green = new int[DP213_Static.Max_Gray_Amount];
int[] Previous_Band_Gamma_Blue = new int[DP213_Static.Max_Gray_Amount];
double[] Previous_Band_Finally_Measured_Lv = new double[DP213_Static.Max_Gray_Amount];
for (int gray = 0; gray < DP213_Static.Max_Gray_Amount; gray++)
{
Previous_Band_Gamma_Red[gray] = storage.Get_All_band_gray_Gamma(Set, (band - 1), gray).int_R;
Previous_Band_Gamma_Green[gray] = storage.Get_All_band_gray_Gamma(Set, (band - 1), gray).int_G;
Previous_Band_Gamma_Blue[gray] = storage.Get_All_band_gray_Gamma(Set, (band - 1), gray).int_B;
Previous_Band_Finally_Measured_Lv[gray] = dp213_mornitoring().Get_Mode_Measured_Values((band - 1), gray, Mode).double_Lv;
}
f1().GB_Status_AppendText_Nextline("Before) R/G/B/Vreg1 = " + vars.Gamma.int_R.ToString() + "/" + vars.Gamma.int_G.ToString().ToString() + "/" + vars.Gamma.int_B.ToString() + "/" + vars.Vreg1, Color.Blue);
Imported_my_cpp_dll.DP213_Gray255_Get_Intial_R_Vreg1_B_Using_Previous_Band_Method_Through_MCI
(Prev_Band_Voltage_AM1.double_R,
Prev_Band_Voltage_AM1.double_G,
Prev_Band_Voltage_AM1.double_B,
ref vars.Vreg1,
ref vars.Gamma.int_R,
ref vars.Gamma.int_B,
Get_Is_Selected_Bands(Mode),
Previous_Band_Gamma_Red,
Previous_Band_Gamma_Green,
Previous_Band_Gamma_Blue,
band,
vars.Target.double_Lv,
Previous_Band_Vreg1_Dec,
Previous_Band_Finally_Measured_Lv,
Voltage_VREF4095,
Voltage_VREF0);
f1().GB_Status_AppendText_Nextline("After C++ Dll(MCI)) R/G/B/Vreg1 = " + vars.Gamma.int_R.ToString() + "/" + vars.Gamma.int_G.ToString().ToString() + "/" + vars.Gamma.int_B.ToString() + "/" + vars.Vreg1, Color.Red);
init_algorithm_storage_cpp.Set_All_band_gray_Gamma(Set, band, 0, vars.Gamma);
}
public RGB_Double Get_OC_Mode_AM0_Voltage(OC_Mode mode, int band)
{
if (band > DP213_Static.Max_HBM_and_Normal_Band_Amount)
{
throw new Exception("band should be less than " + DP213_Static.Max_HBM_and_Normal_Band_Amount);
}
RGB[] OCMode_AM0 = Get_OC_Mode_AM0(mode);
RGB_Double[] OCMode_AM0_Voltage = Get_OC_Mode_AM0_Voltage(mode);
OCMode_AM0_Voltage[band].double_R = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), OCMode_AM0[band].int_R);
OCMode_AM0_Voltage[band].double_G = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), OCMode_AM0[band].int_G);
OCMode_AM0_Voltage[band].double_B = Imported_my_cpp_dll.DP213_Get_AM0_RGB_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), OCMode_AM0[band].int_B);
return(OCMode_AM0_Voltage[band]);
}
private RGB_Double Update_HBM_Normal_Gamma_Voltage(OC_Mode mode, int band, int gray, RGB New_Gamma)
{
RGB_Double[,] OCMode_RGB_Voltage = Get_OC_Mode_RGB_Voltage(mode);
if (gray == 0)
{
OCMode_RGB_Voltage[band, gray].double_R = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), New_Gamma.int_R);
OCMode_RGB_Voltage[band, gray].double_G = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), New_Gamma.int_G);
OCMode_RGB_Voltage[band, gray].double_B = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(ref0ref4095.Get_Normal_REF4095_Voltage(), vreg1.Get_OC_Mode_Vreg1_Voltage(mode, band), New_Gamma.int_B);
}
else
{
RGB_Double Prev_GR_Gamma_Voltage = Get_Prev_GR_Gamma_Voltage(OCMode_RGB_Voltage, band, gray);
OCMode_RGB_Voltage[band, gray].double_R = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Voltage(am1am0.Get_OC_Mode_AM1_Voltage(mode, band).double_R, Prev_GR_Gamma_Voltage.double_R, New_Gamma.int_R, gray);
OCMode_RGB_Voltage[band, gray].double_G = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Voltage(am1am0.Get_OC_Mode_AM1_Voltage(mode, band).double_G, Prev_GR_Gamma_Voltage.double_G, New_Gamma.int_G, gray);
OCMode_RGB_Voltage[band, gray].double_B = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Voltage(am1am0.Get_OC_Mode_AM1_Voltage(mode, band).double_B, Prev_GR_Gamma_Voltage.double_B, New_Gamma.int_B, gray);
}
return(OCMode_RGB_Voltage[band, gray]);
}
private double Get_HBM_RGB_Min_AM2_Voltage()
{
RGB AM2 = ocparam.Get_OC_Mode_RGB(DP213OCSet.Get_WhiteCompensation_OCMode(), band: 0, gray: 0);
int Vreg1 = ocparam.Get_OC_Mode_Vreg1(DP213OCSet.Get_WhiteCompensation_OCMode(), band: 0);
int REF0 = ocparam.Get_Normal_REF0();
int REF4095 = ocparam.Get_Normal_REF4095();
double REF0_Voltage = Imported_my_cpp_dll.DP213_VREF0_Dec_to_Voltage(REF0);
double REF4095_Voltage = Imported_my_cpp_dll.DP213_VREF4095_Dec_to_Voltage(REF4095);
double Vreg1_Voltage = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(REF4095_Voltage, REF0_Voltage, Vreg1);
RGB_Double AM2_Voltage = new RGB_Double();
AM2_Voltage.double_R = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(REF4095_Voltage, Vreg1_Voltage, AM2.int_R);
AM2_Voltage.double_G = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(REF4095_Voltage, Vreg1_Voltage, AM2.int_G);
AM2_Voltage.double_B = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(REF4095_Voltage, Vreg1_Voltage, AM2.int_B);
api.WriteLine("AM2_Voltage R/G/B : " + AM2_Voltage.double_R + "/" + AM2_Voltage.double_G + "/" + AM2_Voltage.double_B);
api.WriteLine("Old VREF0 Voltage : " + REF0_Voltage);
return(Get_Min_RGB_Voltage(AM2_Voltage));
}
private bool AM0_Compensation()
{
RGB_Double AM0_Margin = DP213OCSet.Get_AM0_Margin();
double AM0_Resolution = Imported_my_cpp_dll.Get_DP213_EA9155_AM0_Resolution(ocparam.Get_Normal_REF0(), ocparam.Get_Normal_REF4095());
RGB New_AM0 = new RGB();
New_AM0.int_R = Convert.ToInt32(AM0_Margin.double_R / AM0_Resolution);
New_AM0.int_G = Convert.ToInt32(AM0_Margin.double_G / AM0_Resolution);
New_AM0.int_B = Convert.ToInt32(AM0_Margin.double_B / AM0_Resolution);
bool AM0_OC_Ok = (New_AM0.int_R <= DP213_Static.AM1_AM0_Max) && (New_AM0.int_G <= DP213_Static.AM1_AM0_Max) && (New_AM0.int_B <= DP213_Static.AM1_AM0_Max);
api.WriteLine("DP213_Static.AM1_AM0_Max : " + DP213_Static.AM1_AM0_Max);
api.WriteLine("New_AM0 R/G/B : " + New_AM0.int_R + "/" + New_AM0.int_G + "/" + New_AM0.int_B);
if (AM0_OC_Ok)
{
Set_All_AM0_WithSameValues(New_AM0);
}
return(AM0_OC_Ok);
}
public void Set_Band_Set_AM1(Gamma_Set Set, int band, RGB New_AM1)
{
if (New_AM1.int_R > DP213_Static.AM1_AM0_Max)
{
New_AM1.int_R = DP213_Static.AM1_AM0_Max;
}
if (New_AM1.int_G > DP213_Static.AM1_AM0_Max)
{
New_AM1.int_G = DP213_Static.AM1_AM0_Max;
}
if (New_AM1.int_B > DP213_Static.AM1_AM0_Max)
{
New_AM1.int_B = DP213_Static.AM1_AM0_Max;
}
if (New_AM1.int_R < 0)
{
New_AM1.int_R = 0;
}
if (New_AM1.int_G < 0)
{
New_AM1.int_G = 0;
}
if (New_AM1.int_B < 0)
{
New_AM1.int_B = 0;
}
if (band < DP213_Static.Max_HBM_and_Normal_Band_Amount)
{
int Set_Index = Convert.ToInt16(Set);
AM1[Set_Index, band] = New_AM1;
Voltage_AM1[Set_Index, band].double_R = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM1(Set, band).int_R);
Voltage_AM1[Set_Index, band].double_G = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM1(Set, band).int_G);
Voltage_AM1[Set_Index, band].double_B = Imported_my_cpp_dll.DP213_Get_AM1_RGB_Voltage(Get_Voltage_VREF4095(), Get_Normal_Voltage_Vreg1(Set, band), Get_Band_Set_AM1(Set, band).int_B);
}
}
private static double[] Get_Previous_Band_Gamma_Voltage(double Prev_Band_AM1_Voltage, int Previous_Band_Vreg1_Dec, int[] Previous_Band_Gamma, double Voltage_VREF4095, double Voltage_VREF0)
{
double[] Previous_Band_Gamma_Voltage = new double[DP213_Static.Max_Gray_Amount];
double Previous_Band_Vreg1_Voltage = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(Voltage_VREF4095, Voltage_VREF0, Previous_Band_Vreg1_Dec);
for (int gray = 0; gray < DP213_Static.Max_Gray_Amount; gray++)
{
if (gray == 0)
{
Previous_Band_Gamma_Voltage[gray] = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(Voltage_VREF4095, Previous_Band_Vreg1_Voltage, Previous_Band_Gamma[gray]);
}
else if (gray == 1 || gray == 2 || gray == 3 || gray == 5 || gray == 7 || gray == 9 || gray == 10)
{
Previous_Band_Gamma_Voltage[gray] = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Voltage(Prev_Band_AM1_Voltage, Previous_Band_Gamma_Voltage[gray - 1], Previous_Band_Gamma[gray], gray);
}
else if (gray == 4 || gray == 6 || gray == 8)
{
Previous_Band_Gamma_Voltage[gray] = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Voltage(Prev_Band_AM1_Voltage, Previous_Band_Gamma_Voltage[gray - 2], Previous_Band_Gamma[gray], gray);
}
}
return(Previous_Band_Gamma_Voltage);
}
public void Set_Normal_Dec_Vreg1(Gamma_Set Set, int band, int New_Vreg1)
{
Dec_Normal_Vreg1[Convert.ToInt16(Set), band] = New_Vreg1;
Vreg1_Voltage[Convert.ToInt16(Set), band] = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(Get_Voltage_VREF4095(), Get_Voltage_VREF0(), Get_Normal_Dec_Vreg1(Set, band));
}
public double Get_Voltage_Vinit2(Gamma_Set Set, int band)
{
Voltage_Vinit2[Convert.ToInt16(Set), band] = Imported_my_cpp_dll.DP213_VINI2_Dec_to_Voltage(Dec_Vinit2[Convert.ToInt16(Set), band]);
return(Voltage_Vinit2[Convert.ToInt16(Set), band]);
}
public void Set_Voltage_Vinit2(Gamma_Set Set, int band, double New_Vinit2_Voltage)
{
Voltage_Vinit2[Convert.ToInt16(Set), band] = New_Vinit2_Voltage;
Dec_Vinit2[Convert.ToInt16(Set), band] = Convert.ToByte(Imported_my_cpp_dll.DP213_VINI2_Voltage_to_Dec(New_Vinit2_Voltage));
}
public void Set_Dec_Vinit2(Gamma_Set Set, int band, byte New_Dec_Vinit2)
{
Dec_Vinit2[Convert.ToInt16(Set), band] = New_Dec_Vinit2;
Voltage_Vinit2[Convert.ToInt16(Set), band] = Imported_my_cpp_dll.DP213_VINI2_Dec_to_Voltage(New_Dec_Vinit2);
}
public double Get_Voltage_ELVSS(Gamma_Set Set, int band)
{
Voltage_ELVSS[Convert.ToInt16(Set), band] = Imported_my_cpp_dll.DP213_ELVSS_Dec_to_Voltage(Dec_ELVSS[Convert.ToInt16(Set), band]);
return(Voltage_ELVSS[Convert.ToInt16(Set), band]);
}
public void Set_Voltage_ELVSS(Gamma_Set Set, int band, double New_ELVSS_Voltage)
{
Voltage_ELVSS[Convert.ToInt16(Set), band] = New_ELVSS_Voltage;
Dec_ELVSS[Convert.ToInt16(Set), band] = Convert.ToByte(Imported_my_cpp_dll.DP213_ELVSS_Voltage_to_Dec(New_ELVSS_Voltage));
}
public void Set_Dec_ELVSS(Gamma_Set Set, int band, byte New_Dec_ELVSS)
{
Dec_ELVSS[Convert.ToInt16(Set), band] = New_Dec_ELVSS;
Voltage_ELVSS[Convert.ToInt16(Set), band] = Imported_my_cpp_dll.DP213_ELVSS_Dec_to_Voltage(New_Dec_ELVSS);
}
public double Get_Normal_Voltage_Vreg1(Gamma_Set Set, int band)
{
Vreg1_Voltage[Convert.ToInt16(Set), band] = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(Get_Voltage_VREF4095(), Get_Voltage_VREF0(), Get_Normal_Dec_Vreg1(Set, band));
return(Vreg1_Voltage[Convert.ToInt16(Set), band]);
}
public double Get_Voltage_VREF0()
{
Voltage_VREF0 = Imported_my_cpp_dll.DP213_VREF0_Dec_to_Voltage(Byte_VREF0);
return(Voltage_VREF0);
}
