private void DoExperiment1(ref TestInfo myTestInfo, ref UUTData myUUTData, ref CommonData myCommonData) { try { var loop = Convert.ToInt32(myTestInfo.TestParams[1].Value); var delay = Convert.ToInt32(myTestInfo.TestParams[2].Value); // Close all Test Valves InstrumentIO.CloseAllTestValve(mySw); Thread.Sleep(5000); InstrumentIO.OpenTestValve(mySw, 0); // open NIST valve Thread.Sleep(5000); // Configure Thermocouple measurement InstrumentIO.ConfigureThermocouple(mySw); myTestInfo.ResultsParams = new PIResultsArray(); List <PIResult> listOfPIResult = new List <PIResult>(); for (int i = 0; i < loop; i++) { listOfPIResult.Add(new PIResult { Label = string.Format("NistLeakRate#{0}", i + 1), SpecMin = "1E-7", SpecMax = "2E-7", Nominal = "1.5E-7", Unit = "std cc/sec" }); } for (int i = 0; i < loop; i++) { listOfPIResult.Add(new PIResult { Label = string.Format("NISTTemp#{0}", i + 1), SpecMin = "15", SpecMax = "30", Nominal = "22.5", Unit = "Deg C" }); } for (int i = 0; i < loop; i++) { listOfPIResult.Add(new PIResult { Label = string.Format("UUTTemp#{0}", i + 1), SpecMin = "15", SpecMax = "30", Nominal = "22.5", Unit = "Deg C" }); } for (int i = 0; i < loop; i++) { listOfPIResult.Add(new PIResult { Label = string.Format("UUTSensorTemp#{0}", i + 1), SpecMin = "15", SpecMax = "30", Nominal = "22.5", Unit = "Deg C" }); } myTestInfo.ResultsParams.PIResArray = listOfPIResult.ToArray(); myTestInfo.ResultsParams.NumResultParams = listOfPIResult.Count; // Test start here for (int i = 1; i <= loop; i++) // loop 5760 * 60 * 60 with 5sec delay = 8hrs { /* Read * (1) leak rate NIST, * (2) Temp NIST * (3) Temp UUT * (4) Temp Sensor Board */ var leakRate = Convert.ToDouble(myLD.ReadLeakRate().Trim()); var nistTemp = InstrumentIO.MeasureCalLeakTemp(mySw, 0); var uutTemp = InstrumentIO.MeasureCalLeakTemp(mySw, 1); var uutSensTemp = InstrumentIO.MeasureBoardTemperature(mySw, myScope, 1); Trace.WriteLine(string.Format("NIST Leak Rate #{0} = {1}std cc/sec & NIST Temp #{0} = {2} Deg C & DUT Temp #{0} = {3} Deg C & Board Temp #{0} = {4} Deg C", i, leakRate, nistTemp, uutTemp, uutSensTemp)); myTestInfo.ResultsParams[i].Result = Math.Round(leakRate, 8).ToString(); myTestInfo.ResultsParams[i + loop].Result = Math.Round(nistTemp, 3).ToString(); myTestInfo.ResultsParams[i + (loop * 2)].Result = Math.Round(uutTemp, 3).ToString(); myTestInfo.ResultsParams[i + (loop * 3)].Result = Math.Round(uutSensTemp, 3).ToString(); // Delay 5 seconds, maybe Thread.Sleep(delay * 1000); } } catch (Exception) { throw; } }
private void DoTempTest(ref TestInfo myTestInfo, ref UUTData myUUTData, ref CommonData myCommonData) { try { int loop = int.Parse(myTestInfo.TestParams[1].Value); int delay = int.Parse(myTestInfo.TestParams[2].Value); double deltaSpec = double.Parse(myTestInfo.TestParams[3].Value); double deltaSpec2 = double.Parse(myTestInfo.TestParams[4].Value); int trial = Convert.ToInt32(myTestInfo.TestParams[5].Value); int slot = Convert.ToInt32(myCommonData.Slot); // UUT Slot // Configure Thermocouple measurement Trace.WriteLine("Starting to initialize thermocouple and DUT's Temperature board."); InstrumentIO.ConfigureThermocouple(mySw); Trace.WriteLine("Measuring Thermocouple."); Trace.WriteLine("... waiting for the DUT's thermocouple to stabilized."); Trace.WriteLine("Loop 10 times"); int counter = 0; Repeat : List <double> tempReadings = new List <double>(); for (int i = 0; i < loop; i++) { var dutTemp = InstrumentIO.MeasureCalLeakTemp(mySw, slot); tempReadings.Add(dutTemp); Trace.WriteLine("DUT Temperature: " + Math.Round(dutTemp, 2).ToString()); Thread.Sleep(delay); } Trace.WriteLine("DUT Average Temperature: " + tempReadings.Average().ToString()); Trace.WriteLine("DUT Max Temperature: " + tempReadings.Max().ToString()); Trace.WriteLine("DUT Min Temperature: " + tempReadings.Min().ToString()); Trace.WriteLine("DUT Delta Temperature: " + (tempReadings.Max() - tempReadings.Min()).ToString()); var delta = tempReadings.Max() - tempReadings.Min(); counter++; if (delta > deltaSpec && counter < trial) { goto Repeat; } // Measure Board Temperature Trace.WriteLine("Measuring DUT Board Temperature."); Trace.WriteLine("... waiting for the DUT's board's temperature to stabilized."); Trace.WriteLine("Loop 10 times"); //InstrumentIO.SetupBoardTempMeasRoute(mySw, myScope, slot); // setup route for BoardTemp supply and output 5V and TTL signal output int counter2 = 0; Repeat2 : List <double> tempReadings2 = new List <double>(); for (int i = 0; i < loop; i++) // repeat 10times to make sure the temp is stable { var boardTemp = InstrumentIO.MeasureBoardTemperature(mySw, myScope, slot); boardTemp = Math.Round(boardTemp, 2); tempReadings2.Add(boardTemp); Trace.WriteLine("Board Temperature: " + boardTemp.ToString()); Thread.Sleep(delay); } Trace.WriteLine("Board Average Temperature: " + tempReadings2.Average().ToString()); Trace.WriteLine("Board Max Temperature: " + tempReadings2.Max().ToString()); Trace.WriteLine("Board Min Temperature: " + tempReadings2.Min().ToString()); Trace.WriteLine("Board Delta Temperature: " + (tempReadings2.Max() - tempReadings2.Min()).ToString()); var delta2 = tempReadings2.Max() - tempReadings2.Min(); counter2++; if (delta2 > deltaSpec2 && counter2 < trial) { goto Repeat2; } var boardTempFinal = InstrumentIO.MeasureBoardTemperature(mySw, myScope, slot); //InstrumentIO.DisconnectTempBoardMeasRoute(mySw, slot); // Save result if (counter == trial) // more than 3 times try to get stable temperature, considered failed { myTestInfo.ResultsParams[1].Result = "TIMEOUT"; } else { myTestInfo.ResultsParams[1].Result = "PASS"; } //var averageTemperature = tempReadings.Average(); var finalCanTemp = InstrumentIO.MeasureCalLeakTemp(mySw, 1); myTestInfo.ResultsParams[2].Result = Math.Round(delta, 3).ToString(); myTestInfo.ResultsParams[3].Result = Math.Round(finalCanTemp, 1).ToString(); myTestInfo.ResultsParams[4].Result = Math.Round(delta2, 3).ToString(); //var boardTempAve = tempReadings2.Average(); myTestInfo.ResultsParams[5].Result = Math.Round(boardTempFinal, 1).ToString(); // Get Temperature difference between Can's temperature and board temperature. (Factor) double diffTemp = boardTempFinal - finalCanTemp; //myTestInfo.ResultsParams[6].Result = Math.Round(diffTemp, 3).ToString(); } catch (Exception) { throw; } }
private void DoExternalCal(ref TestInfo myTestInfo, ref UUTData myUUTData, ref CommonData myCommonData) { try { var delay = Convert.ToInt32(myTestInfo.TestParams[1].Value); // Make sure all valve is closed. InstrumentIO.CloseAllTestValve(mySw); string retVal = string.Empty; // Rough vacuum Trace.WriteLine("Roughing in progress..."); myLD.Rough(); Thread.Sleep(10000); //bool isContraFlow = myLD.WaitForContraFlow(ref retVal); bool isMidStage = myLD.WaitForFineTest(ref retVal); if (!isMidStage) { myTestInfo.ResultsParams[1].Result = retVal; Trace.WriteLine("Unable to set to MIDSTAGE state."); } Thread.Sleep(5000); // Once in Fine-Test mode, let the leak rate to stabilize double zeroleakrate = Convert.ToDouble(myLD.ReadLeakRate()); int timerys = 0; while (zeroleakrate > 5E-10) { Thread.Sleep(1000); zeroleakrate = Convert.ToDouble(myLD.ReadLeakRate()); Trace.WriteLine("calibration wait time: " + timerys); timerys++; if (timerys == 180) { Trace.WriteLine("Zero-ing"); myLD.Zero(); Thread.Sleep(2000); //MessageBox.Show("to reach 5E-10 in 15 minutes","Fail",MessageBoxButtons.OK); //myTestInfo.ResultsParams[1].Result = "FAIL"; break; } } // Set LD to Hold state myLD.Hold(); Thread.Sleep(5000); // Open NIST Valve Trace.WriteLine("Open NIST Test Valve."); InstrumentIO.OpenTestValve(mySw, 0); Thread.Sleep(1000); // Now set the LD to TEST mode var stat = myLD.Rough(); Thread.Sleep(10000); isMidStage = myLD.WaitForFineTest(ref retVal); if (!isMidStage) { myTestInfo.ResultsParams[1].Result = retVal; Trace.WriteLine("Unable to set to MIDSTAGE state."); } else { myTestInfo.ResultsParams[1].Result = "FINETEST"; // Delay 2 minutes for the LD to stabilize. Trace.WriteLine("Waiting for the VS Leak Detector to stabilize in 2 minutes"); Thread.Sleep(delay * 1000); // wait for 2 minutes (120,000 miliseconds) Trace.WriteLine("VS Leak Detector is now stabilized"); var stab = ""; bool stabilized = myLD.WaitForStabilizedReading(ref stab); if (stabilized) { Trace.WriteLine("Leak rate reading is stabilized!"); } else { Trace.WriteLine("Timeout to get stable leak rate reading!"); } // Now calibrate the VS Leak Detector. string calStatus = myLD.Calibrate(); // Default timeout for calibration is 300seconds, change to overload method and provide new Timeout value Thread.Sleep(10000); bool isCalibrationOK = myLD.CalIsOK(); if (isCalibrationOK) { Trace.WriteLine("Last calibration status is OK"); } else { Trace.WriteLine("Fail Calibration!!"); } // Check the LeakRate Trace.WriteLine("Read back the LeakRate from the VS Leak Detector"); var leakRate = Convert.ToDouble(myLD.ReadLeakRate().Trim()); Trace.WriteLine(string.Format("NIST LeakRate Measurement = {0}", leakRate)); var storedLeakRate = Convert.ToDouble(myLD.GetExternalLeakValue().Trim()); var leakDelta = leakRate - storedLeakRate;//Math.Abs(storedLeakRate - leakRate); Trace.WriteLine("Difference between measured and stored leak rate = " + leakDelta.ToString()); // Save Result myTestInfo.ResultsParams[2].Result = leakRate.ToString(); double lowerLimit = storedLeakRate - 0.2E-7; double upperLimit = storedLeakRate + 0.2E-7; myTestInfo.ResultsParams[2].SpecMax = Math.Round(upperLimit, 9).ToString(); myTestInfo.ResultsParams[2].SpecMin = Math.Round(lowerLimit, 9).ToString(); myTestInfo.ResultsParams[3].Result = Math.Round(leakDelta, 10).ToString(); if (leakDelta > 0.2E-7) // If more than +-2 division. { // Calibrate fail. // todo: do we need to recalibrate or just proceed. } } // Close all Test Valves InstrumentIO.CloseAllTestValve(mySw); } catch (Exception) { throw; } }
private void StoreLeakRate(ref TestInfo myTestInfo, ref UUTData myUUTData, ref CommonData myCommonData) { try { Trace.WriteLine("Measuring NIST Temperature..."); var nistLeakTemp = InstrumentIO.MeasureCalLeakTemp(mySw, 0); Trace.WriteLine("NIST Temperature = " + nistLeakTemp.ToString()); int nistLeakTempInt = Convert.ToInt32(nistLeakTemp); Trace.WriteLine("NIST Temperature = " + nistLeakTempInt.ToString()); double leakRate = TestHelper.GetLeakRateFromTempMap(nistLeakTempInt, myNistData); Trace.WriteLine(String.Format("NIST Leak Rate @{0}deg C = {1}", nistLeakTempInt, leakRate)); Trace.WriteLine("External Cal-Leak configuration in progress..."); Trace.WriteLine("Set VS Leak Detector to use External Cal Leak"); myLD.UseExtCalLeakRef(); // Set LD to use External CAL Leak //leakRate = Math.Round(leakRate, 8); // the number in scientific must follow exactly this format (X.XE-7 or X.XE-8), else error will occurs string leakRateMod = ""; string strLeakRate = ""; if (leakRate < 1E-7) { leakRateMod = Math.Round(leakRate * 100000000, 1).ToString(); Trace.WriteLine("External Cal-Leak value to be stored in VS Leak Detector = " + leakRateMod.ToString() + "E-8"); strLeakRate = string.Format("{0}E-8", leakRateMod); Trace.WriteLine("Storing leak rate value...."); myLD.SetExtCalLeakValue(strLeakRate); Trace.WriteLine("Done!"); Trace.WriteLine("Leak rate = " + strLeakRate); } else { leakRateMod = Math.Round(leakRate * 10000000, 1).ToString(); Trace.WriteLine("External Cal-Leak value to be stored in VS Leak Detector = " + leakRateMod.ToString() + "E-7"); strLeakRate = string.Format("{0}E-7", leakRateMod); Trace.WriteLine("Storing leak rate value...."); myLD.SetExtCalLeakValue(strLeakRate); Trace.WriteLine("Done!"); Trace.WriteLine("Leak rate = " + strLeakRate); } var storedVal = myLD.GetExternalLeakValue().Trim(); Trace.WriteLine("Readback Leak Rate Value from Leak Detector = " + storedVal.ToString()); if (double.Parse(strLeakRate) == double.Parse(storedVal)) { // pass myTestInfo.ResultsParams[1].Result = "PASS"; myTestInfo.ResultsParams[2].Result = storedVal; } else { // FAIL myTestInfo.ResultsParams[1].Result = "FAIL"; myTestInfo.ResultsParams[2].Result = storedVal; } } catch (Exception) { throw; } }
private void DoLeakRateProfilingTest(ref TestInfo myTestInfo, ref UUTData myUUTData, ref CommonData myCommonData) { try { var slope = Convert.ToDouble(myTestInfo.TestParams[1].Value); var refTemp = Convert.ToDouble(myTestInfo.TestParams[2].Value); var loop = Convert.ToInt32(myTestInfo.TestParams[3].Value); var acquireDelay = Convert.ToInt32(myTestInfo.TestParams[4].Value); //var holdDelay = Convert.ToInt32(myTestInfo.TestParams[5].Value); int slot = Convert.ToInt32(myCommonData.Slot); // Step #1: Measure leak rate and calculate normalized leak rate // Close all valves Trace.WriteLine("Verifying test valves are closed..."); InstrumentIO.CloseAllTestValve(mySw); Thread.Sleep(5000); Trace.WriteLine("All valves are closed"); // hold valve Trace.WriteLine("Set VS Leak Detector to HOLD mode"); myLD.Hold(); Thread.Sleep(5000); // Open Test Port Trace.WriteLine(String.Format("Open SLOT#{0} DUT's Test Valve", slot)); InstrumentIO.OpenTestValve(mySw, slot); Thread.Sleep(1000); myLD.Rough(); // rough the LD //Thread.Sleep(holdDelay * 1000); // once LD in FineTest myTestInfo.ResultsParams = new PIResultsArray(); List <PIResult> listOfPIResult = new List <PIResult>(); for (int i = 0; i < loop; i++) { listOfPIResult.Add(new PIResult { Label = string.Format("LeakRate#{0}", i + 1), SpecMin = "1E-7", SpecMax = "2E-7", Nominal = "1.5E-7", Unit = "std cc/sec" }); } for (int i = 0; i < loop; i++) { listOfPIResult.Add(new PIResult { Label = string.Format("Temp#{0}", i + 1), SpecMin = "15", SpecMax = "30", Nominal = "22.5", Unit = "Deg C" }); } myTestInfo.ResultsParams.PIResArray = listOfPIResult.ToArray(); myTestInfo.ResultsParams.NumResultParams = listOfPIResult.Count; // Loop measurement for DUT's Leak Rate var listOfLeakRate = new List <double>(); var listOftemp = new List <double>(); var listOfBoardTemp = new List <double>(); // Configure Thermocouple measurement InstrumentIO.ConfigureThermocouple(mySw); Trace.WriteLine(String.Format("Measuring DUT's Leak Rate and Temperature for {0} times.", loop)); int cnt1 = 0; int cnt2 = 0; for (int i = 1; i <= loop; i++) { // read LeakRate double leakRate = Convert.ToDouble(myLD.ReadLeakRate()); var dutTemp = InstrumentIO.MeasureCalLeakTemp(mySw, slot); var boardTemp = InstrumentIO.MeasureBoardTemperature(mySw, myScope, slot); Trace.WriteLine(string.Format("Leak Rate #{0} = {1}std cc/sec & DUT Temp #{0} = {2} Deg C & Board Temp #{0} = {3} Deg C", i, leakRate, dutTemp, boardTemp)); listOfLeakRate.Add(leakRate); listOftemp.Add(dutTemp); listOfBoardTemp.Add(boardTemp); Thread.Sleep(acquireDelay * 1000); // delay in miliseconds myTestInfo.ResultsParams[i].Result = Math.Round(leakRate, 8).ToString(); myTestInfo.ResultsParams[i + loop].Result = Math.Round(dutTemp, 3).ToString(); } } catch (Exception) { throw; } }
private void DoLeakRateTest(ref TestInfo myTestInfo, ref UUTData myUUTData, ref CommonData myCommonData) { try { var slope = Convert.ToDouble(myTestInfo.TestParams[1].Value); var refTemp = Convert.ToDouble(myTestInfo.TestParams[2].Value); var loop = Convert.ToInt32(myTestInfo.TestParams[3].Value); var acquireDelay = Convert.ToInt32(myTestInfo.TestParams[4].Value); var stabilizeDelay = Convert.ToInt32(myTestInfo.TestParams[5].Value); int slot = Convert.ToInt32(myCommonData.Slot); // Step #1: Measure leak rate and calculate normalized leak rate // Close all valves Trace.WriteLine("Verifying test valves are closed..."); InstrumentIO.CloseAllTestValve(mySw); Thread.Sleep(3000); Trace.WriteLine("All valves are closed"); // hold valve Trace.WriteLine("Set VS Leak Detector to HOLD mode"); myLD.Hold(); Thread.Sleep(3000); // Open Test Port Trace.WriteLine(String.Format("Open SLOT#{0} DUT's Test Valve", slot)); InstrumentIO.OpenTestValve(mySw, slot); Thread.Sleep(2000); myLD.Rough(); string status = ""; bool isMidStage = myLD.WaitForFineTest(ref status); if (!isMidStage) { myTestInfo.ResultsParams[1].Result = status; Trace.WriteLine("Unable to set to MIDSTAGE state."); } bool isReadingStabilized = myLD.WaitForStabilizedReading(ref status); if (!isReadingStabilized) { Trace.WriteLine("Timeout to get stable leak rate reading"); } Thread.Sleep(stabilizeDelay * 1000); // Loop measurement for DUT's Leak Rate var listOfLeakRate = new List <double>(); var listOftemp = new List <double>(); var listOfBoardTemp = new List <double>(); // Configure Thermocouple measurement InstrumentIO.ConfigureThermocouple(mySw); Trace.WriteLine(String.Format("Measuring DUT's Leak Rate and Temperature for {0} times.", loop)); for (int i = 0; i < loop; i++) { // read LeakRate double leakRate = Convert.ToDouble(myLD.ReadLeakRate()); var dutTemp = InstrumentIO.MeasureCalLeakTemp(mySw, slot); var boardTemp = InstrumentIO.MeasureBoardTemperature(mySw, myScope, slot); Trace.WriteLine(string.Format("Leak Rate #{0} = {1}std cc/sec & DUT Temp #{0} = {2} Deg C & Board Temp #{0} = {3} Deg C", i + 1, leakRate, dutTemp, boardTemp)); listOfLeakRate.Add(leakRate); listOftemp.Add(dutTemp); listOfBoardTemp.Add(boardTemp); Thread.Sleep(acquireDelay * 1000); // delay in miliseconds } // calculate normalized leak rate var aveLeakRate = listOfLeakRate.Average(); Trace.WriteLine("Average Leak Rate = " + aveLeakRate.ToString()); var aveTemp = listOftemp.Average(); Trace.WriteLine("Average DUT's Temperature = " + aveTemp.ToString()); var aveBoardTemp = listOfBoardTemp.Average(); Trace.WriteLine("Average Board's Temperature = " + aveBoardTemp.ToString()); Trace.WriteLine(string.Format("Calculating DUT Normalized Leak Rate at {0} Deg Celcius reference temperature", refTemp)); var normLeakRateDouble = TestHelper.CalculateNormLeakRate(slope, refTemp, aveLeakRate, aveTemp); Trace.WriteLine("Normalized Leak Rate = " + normLeakRateDouble.ToString()); // store result var normLeakRate = Math.Round(normLeakRateDouble, 9); Trace.WriteLine("Normalized Leak Rate = " + normLeakRate.ToString()); //myTestInfo.ResultsParams[1].Result = normLeakRate.ToString(); myTestInfo.ResultsParams[1].Result = Math.Round(aveLeakRate, 9).ToString(); // Step #2: Temperature measurement to get Factor (Delta DegC between board and cal leak can's temperature // Get Can's temp //var cansTemp = InstrumentIO.MeasureCalLeakTemp(mySw, slot); Trace.WriteLine("DUT Temperature (Thermocouple) : " + aveTemp.ToString()); myTestInfo.ResultsParams[2].Result = Math.Round(aveTemp, 1).ToString(); // Measure Board Temperature //InstrumentIO.SetupBoardTempMeasRoute(mySw, myScope, slot); // setup route for BoardTemp supply and output 5V and TTL signal output myTestInfo.ResultsParams[3].Result = Math.Round(aveBoardTemp, 1).ToString(); //InstrumentIO.DisconnectTempBoardMeasRoute(mySw, slot); Trace.WriteLine("DUT Temperature (PCB) : " + aveBoardTemp.ToString()); // calc temp difference var deltaTemp = aveBoardTemp - aveTemp; Trace.WriteLine("Temperature Difference : " + deltaTemp.ToString()); // store result myTestInfo.ResultsParams[4].Result = Math.Round(deltaTemp, 1).ToString(); // Close Test Valve InstrumentIO.CloseTestValve(mySw, slot); // Set LeakRate and Factor properties to be used for averaging at the end of the test UUTLeakRate = Math.Round(aveLeakRate, 9);//normLeakRateDouble; UUTTempFactor = deltaTemp; UUTTemp = aveTemp; } catch (Exception) { throw; } }
public static TestInfo DoSeq5_13(VSLeakDetector myLD, ref TestInfo myTestInfo, ref UUTData myuutdata) { Boolean status = false; string reading; int step = 1; //Helper.comPort = comPort; try { switch (myTestInfo.TestLabel) { case "5.13.1 Power": { //Lock the DMM int checking = 1; string conStr = myTestInfo.TestParams[1].Value; while (checking > 0) { string DMMstatus = SQL_34970A.Read_DMM_Status(conStr); if (DMMstatus == "No") { SQL_34970A.Update_DMM_Status(myuutdata.Options, "Yes", conStr); //Yes = Lock No = Unlock break; } Thread.Sleep(5000); } //@@ Disconnect power from the UUT @@// Trace.WriteLine(iteSlot + "Disconnect power from the UUT..."); if (iteSlot.Contains("P1")) { InstrumentIO.DAS_Power_OFF("1"); Trace.WriteLine(iteSlot + "Unlocking the DMM..."); SQL_34970A.Update_DMM_Status("1", "No", conStr); } else { InstrumentIO.DAS_Power_OFF("2"); Trace.WriteLine(iteSlot + "Unlocking the DMM..."); SQL_34970A.Update_DMM_Status("2", "No", conStr); } Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "ok"; break; } case "5.13.3 Measure_Resistane": { string res_range = myTestInfo.TestParams[2].Value; //@@ Measure resistance between the gnd blade and tp metal (< 0.8) @@// Trace.WriteLine(iteSlot + "Measure resistance between the gnd blade and tp metal (< 0.8)..."); double res1 = InstrumentIO.Measure_Resistance(0, "100", "0.001"); //reading = InstrumentIO.Measure_Resistance(0, res_range); myTestInfo.ResultsParams[step].Result = res1.ToString(); //Trace.WriteLine(iteSlot + "Test point complete."); //if (Convert.ToDouble(reading) < 0.8) //{ // myTestInfo.ResultsParams[step].Result = reading; //} //else //{ // myTestInfo.ResultsParams[step].Result = reading; // //throw new Exception("Measured value out of acceptable range."); //} step++; //@@ Measure resistance between the ground blade and grounding stud. (< 0.8) @@// Trace.WriteLine(iteSlot + "Measure resistance between the ground blade and grounding stud. (< 0.8)..."); //reading = InstrumentIO.Measure_Resistance(1, res_range); double res2 = InstrumentIO.Measure_Resistance(0, "100", "0.001"); myTestInfo.ResultsParams[step].Result = res2.ToString(); Trace.WriteLine(iteSlot + "Test point complete."); //if (Convert.ToDouble(reading) < 0.8) //{ // myTestInfo.ResultsParams[step].Result = reading; //} //else //{ // myTestInfo.ResultsParams[step].Result = reading; // //throw new Exception("Measured value out of acceptable range."); //} step++; //@@ Measure resistance between line blade and neutral blade ON (Based on model) @@// List <string> listOfLimits = new List <string>(); listOfLimits.Add(myTestInfo.TestParams[3].Value); listOfLimits.Add(myTestInfo.TestParams[4].Value); listOfLimits.Add(myTestInfo.TestParams[5].Value); listOfLimits.Add(myTestInfo.TestParams[6].Value); listOfLimits.Add(myTestInfo.TestParams[7].Value); listOfLimits.Add(myTestInfo.TestParams[8].Value); Trace.WriteLine(iteSlot + "Measure resistance between line blade and neutral blade ON (Based on model)..."); string resReading = InstrumentIO.Measure_Res_LB_NB_ON(myuutdata.Model, res_range, listOfLimits.ToArray(), ref myTestInfo, step); Trace.WriteLine(iteSlot + "Test point completed"); myTestInfo.ResultsParams[step].Result = resReading; step++; //@@ Measure resistance between line blade and ground blade ON @@// Trace.WriteLine(iteSlot + "Measure resistance between line blade and ground blade ON..."); reading = InstrumentIO.Measure_Resistance(2, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } step++; //@@ Measure resistance between neutral blade and ground blade ON @@// Trace.WriteLine(iteSlot + "Measure resistance between neutral blade and ground blade ON..."); reading = InstrumentIO.Measure_Resistance(3, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } step++; MessageBox.Show("Please flip Leak Detector switch to OFF positions", "OFF Switch", MessageBoxButtons.OK, MessageBoxIcon.Information); //@@ Measure resistance between line blade and neutral blade OFF (0.8~1.2) @@// Trace.WriteLine(iteSlot + "Measure resistance between line blade and neutral blade OFF"); //reading = InstrumentIO.Measure_Resistance(4, res_range); reading = InstrumentIO.Measure_Res_LB_NB_OFF(); Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = reading; step++; //@@ Measure resistance between line blade and ground blade OFF @@// Trace.WriteLine(iteSlot + "Measure resistance between line blade and ground blade OFF..."); reading = InstrumentIO.Measure_Resistance(2, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } step++; //@@ Measure resistance between neutral blade and ground blade OFF @@// Trace.WriteLine(iteSlot + "Measure resistance between neutral blade and ground blade OFF..."); reading = InstrumentIO.Measure_Resistance(3, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } //Unlock DMM step++; } break; } } catch (Exception ex) { Trace.WriteLine(ex.Message); Helper.Fail_Test(ref myTestInfo, ex.Message, step); throw; } return(myTestInfo); }
public static TestInfo DoSeq5_1(VSLeakDetector myLD, ref TestInfo myTestInfo, ref UUTData myuutdata) { string reading; userprompt my_userprompt = new userprompt(); try { switch (myTestInfo.TestLabel) { case "5.1.1 Power": { //@@ Ensure that the power cord is not plugged into the UUT & the main AC supply outlet. @@// Trace.WriteLine(iteSlot + "Disconnect the power supply from the UUT..."); recheck: string conStr = "Data Source=wpsqldb21;Initial Catalog=VpdOF;Persist Security Info=True;User ID=VpdTest;Password=Vpd@123"; string DMMstatus = SQL_34970A.Read_DMM_Status(conStr); if (DMMstatus == "No") { } else { Trace.WriteLine("DMM locked"); Thread.Sleep(5000); goto recheck; } InstrumentIO.DAS_Power_OFF(myuutdata.Options); myTestInfo.ResultsParams[1].Result = "ok"; break; } case "5.1.2 Check_PumpVoltage": { /*@@ SKIP* Check the LD has the correct voltage mechanical pump installed (115VAC or 230VAC) or that the voltage selector switch * on the vacuum pump is set to meet the rated mains AC requirements for that model LD. @@*/ myTestInfo.ResultsParams[1].Result = "ok"; break; } case "5.1.3 Check_Setup": { //@@ Prompt user to ensure that all KF clamps, grounding straps, cable and wire connections between the PCBs, valves and pumps are in place. @@// string display = "Seq 5.1.3:\nEnsure that all KF clamps, grounding straps, cable and wire connections between the PCBs,\nvalves and pumps are in place. Enter 'ok' once done."; string Reading = Helper.LabelDisplay(display); myTestInfo.ResultsParams[1].Result = Reading; break; } case "5.1.5 Measure_Resistance": { //Lock the DDM from other test sockets while it is been used. Before that, verify whether it is locked or not. int step = 1; int checking = 1; string DMMstatus = ""; string conStr = myTestInfo.TestParams[1].Value; string res_range = myTestInfo.TestParams[2].Value; Trace.WriteLine(iteSlot + "Check before Locking the DMM..."); while (checking > 0) { recheck: DMMstatus = SQL_34970A.Read_DMM_Status(conStr); if (DMMstatus == "No") { SQL_34970A.Update_DMM_Status(myuutdata.Options, "Yes", conStr); //Yes = Lock No = Unlock Thread.Sleep(5000); break; } else { MessageBox.Show("DMM locked", "warning", MessageBoxButtons.OK); Thread.Sleep(5000); goto recheck; } } MessageBox.Show("Please flip Leak Detector switch to OFF positions", "OFF Switch", MessageBoxButtons.OK, MessageBoxIcon.Information); //@@ Measure resistance between line blade and neutral blade OFF (0.8~1.2) @@// Trace.WriteLine(iteSlot + "Measure resistance between line blade and neutral blade OFF"); //reading = InstrumentIO.Measure_Resistance(4, res_range); reading = InstrumentIO.Measure_Res_LB_NB_OFF(); Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = reading; step++; //@@ Measure resistance between line blade and ground blade OFF @@// Trace.WriteLine(iteSlot + "Measure resistance between line blade and ground blade OFF..."); reading = InstrumentIO.Measure_Resistance(2, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } step++; //@@ Measure resistance between neutral blade and ground blade OFF @@// Trace.WriteLine(iteSlot + "Measure resistance between neutral blade and ground blade OFF..."); reading = InstrumentIO.Measure_Resistance(3, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } step++; MessageBox.Show("Please flip Leak Detector switch to ON positions", "ON Switch", MessageBoxButtons.OK, MessageBoxIcon.Information); //@@ Measure resistance between the gnd blade and tp metal (< 0.8) @@// Trace.WriteLine(iteSlot + "Measure resistance between the gnd blade and tp metal (< 0.8)..."); double res1 = InstrumentIO.Measure_Resistance(0, "100", "0.001"); //reading = InstrumentIO.Measure_Resistance(0, res_range); myTestInfo.ResultsParams[step].Result = res1.ToString(); step++; //@@ Measure resistance between the ground blade and grounding stud. (< 0.8) @@// Trace.WriteLine(iteSlot + "Measure resistance between the ground blade and grounding stud. (< 0.8)..."); //reading = InstrumentIO.Measure_Resistance(1, res_range); double res2 = InstrumentIO.Measure_Resistance(0, "100", "0.001"); myTestInfo.ResultsParams[step].Result = res2.ToString(); Trace.WriteLine(iteSlot + "Test point complete."); step++; //@@ Measure resistance between line blade and neutral blade ON (Based on model) @@// List <string> listOfLimits = new List <string>(); listOfLimits.Add(myTestInfo.TestParams[3].Value); listOfLimits.Add(myTestInfo.TestParams[4].Value); listOfLimits.Add(myTestInfo.TestParams[5].Value); listOfLimits.Add(myTestInfo.TestParams[6].Value); listOfLimits.Add(myTestInfo.TestParams[7].Value); listOfLimits.Add(myTestInfo.TestParams[8].Value); Trace.WriteLine(iteSlot + "Measure resistance between line blade and neutral blade ON (Based on model)..."); string resReading = InstrumentIO.Measure_Res_LB_NB_ON(myuutdata.Model, res_range, listOfLimits.ToArray(), ref myTestInfo, step); Trace.WriteLine(iteSlot + "Test point completed"); myTestInfo.ResultsParams[step].Result = resReading; step++; //@@ Measure resistance between line blade and ground blade ON @@// Trace.WriteLine(iteSlot + "Measure resistance between line blade and ground blade ON..."); reading = InstrumentIO.Measure_Resistance(2, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } step++; //@@ Measure resistance between neutral blade and ground blade ON @@// Trace.WriteLine(iteSlot + "Measure resistance between neutral blade and ground blade ON..."); reading = InstrumentIO.Measure_Resistance(3, res_range); if (Convert.ToDouble(reading) > 10000000) { Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "100000000"; } else { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("Measured value out of acceptable range."); } step++; //Unlock DMM Trace.WriteLine(iteSlot + "Unlocking the DMM..."); conStr = myTestInfo.TestParams[1].Value; // SQL_34970A.Update_DMM_Status(myuutdata.Options, "No", conStr); step++; } break; } } catch (Exception ex) { Trace.WriteLine(ex.Message); Helper.Fail_Test(ref myTestInfo, ex.Message, 1); throw; } return(myTestInfo); }
/// <summary> /// This method is called when the test is completed /// </summary> /// <param name="_uutData"></param> /// <param name="_commonData"></param> public void UserCleanup(ref UUTData _uutData, ref CommonData _commonData) { try { // Disconnect 5V supply and TTL signal from the Sensor Board InstrumentIO.DisconnectTempBoardMeasRoute(mySw, TestPort); InstrumentIO.CloseAllTestValve(mySw); if (myLD != null) { // at the end of the test, vent the Leak Detector //Trace.WriteLine("Vent the Leak Detector"); //myLD.Vent(); Trace.WriteLine("Disconnecting Serial Port Communication...."); myLD.Close(); myLD = null; Trace.WriteLine(" ... disconnected"); } // Destruct the Test Classes myInitStationTest = null; myCalLeakTest = null; mySystemCalTest = null; myButtonUpTest = null; // Check FinalTest outcome, Pass/Fail flag P,F,A,E and the test is in Production Mode if (_commonData.TestOutcome.ToUpper() == "P" && _commonData.isProdMode) { Trace.WriteLine("Submitting Cal-Leak data summary to database..."); string sqlConStr = CalLeakConfigs.Default.SqlConString; myCalLeakData.IsPass = true; // Pass using (SqlConnection conn = new SqlConnection(sqlConStr)) { conn.Open(); var retVal = SqlHelper.SubmitFinalCalLeakData(conn, ref myCalLeakData); Trace.WriteLine("CalLeak Data transfered to database."); // Create certificate history for the unit int id = Convert.ToInt32(retVal); string eqIds = SqlHelper.GetCsvStringEquipmentUsed(conn, 2, 1); // save UUT certificate details SqlHelper.SaveCertDetails(conn, id, eqIds); } Trace.WriteLine("Generating new Serial Number..."); // Autogenerate Serial Number string modelNumber = _uutData.Model; string serialNumber = string.Empty; DateTime todayDate = DateTime.Now; int workWeek = DateTimeHelper.GetIso8601WeekOfYear(todayDate); SernumInfo mySerialNumInfo = new SernumInfo(); mySerialNumInfo.Model = modelNumber; using (SqlConnection conn = new SqlConnection(sqlConStr)) { Trace.WriteLine("Connecting to SQL Database for serial number retrieval"); conn.Open(); Trace.WriteLine("Connection succeeded"); var newSernum = SqlHelper.GetNextRunningNumber(conn, ref mySerialNumInfo); //serialNumber = string.Format("MY{0}{1}{2}", todayDate.ToString("yy"), todayDate.ToString("MM"), newSernum); // commented out due to serial number generation must use YYWW serialNumber = string.Format("MY{0}{1}{2}", todayDate.ToString("yy"), workWeek.ToString("00"), newSernum); Trace.WriteLine("New Serial Number is = " + serialNumber); } Trace.WriteLine("Submitting new serial number to database.."); DateTime date = DateTime.Now; mySerialNumInfo.DummySernum = _uutData.SerNum; mySerialNumInfo.Model = _uutData.Model; mySerialNumInfo.IsPassTest = true; mySerialNumInfo.Sernum = serialNumber; mySerialNumInfo.LogDate = date; mySerialNumInfo.RunningNumber = mySerialNumInfo.RunningNumber;// +1; string conStr = CalLeakConfigs.Default.SqlConString; using (SqlConnection conn = new SqlConnection(conStr)) { conn.Open(); var retVal = SqlHelper.SubmitAutoGeneratedSernum(conn, ref mySerialNumInfo); Trace.WriteLine(retVal.ToString()); } Trace.WriteLine("Done"); } else if (_commonData.isProdMode) { Trace.WriteLine("Submitting Cal-Leak data summary to database..."); string sqlConStr = CalLeakConfigs.Default.SqlConString; myCalLeakData.IsPass = false; // Failed using (SqlConnection conn = new SqlConnection(sqlConStr)) { conn.Open(); var retVal = SqlHelper.SubmitFinalCalLeakData(conn, ref myCalLeakData); Trace.WriteLine("CalLeak Data transfered to database."); } } } catch (Exception) { } finally { _uutData = null; //_commonData = null; // todo: play sound for test completion or tower light } }
public static TestInfo DoSeq5_2(VSLeakDetector myLD, ref TestInfo myTestInfo, ref UUTData myuutdata, ref CommonData myCommonData) { string Display; string reading; string retval; int step = 1; Helper.comPort = comPort; //VSLeakDetector myLD = new VSLeakDetector(comPort); try { switch (myTestInfo.TestLabel) { case "5.2.4 Communication_Setup": { step = 1; //@@ Connect the power cord to the main AC supply. @@// Trace.WriteLine("Power ON the UUT..."); InstrumentIO.DAS_Power_ON(myuutdata.Options); myTestInfo.ResultsParams[step].Result = "ok"; Trace.WriteLine("Test point complete."); step++; //@@ Serial port communication test @@// Trace.WriteLine("Verify the serial port communication between the UUT and the PC..."); //myLD.Open(); int timeout = 1; myLD.Timeout = 1000; myLD.Terminator = "\r\n"; while (timeout > 0) { retval = myLD.Read(); if (retval.Contains("ok")) { myTestInfo.ResultsParams[step].Result = "ok"; Trace.WriteLine("Test point complete."); break; } if (timeout > 100) { myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } Thread.Sleep(1000); timeout++; } //myLD.Close(); break; } case "5.2.4 PreheatSetup": { string conStr1 = "Data Source=wpsqldb21;Initial Catalog=VpdOF;Persist Security Info=True;User ID=VpdTest;Password=Vpd@123"; SQL_34970A.Update_DMM_Status(myuutdata.Options, "No", conStr1); string SN = myuutdata.SerNum; string Model = myuutdata.Model; MyForm myPreheatForm = new MyForm(myLD); //myPreheatForm.comPort = comPort; myPreheatForm.ShowDialog(); string disValue = myPreheatForm.Pvvalue; if (disValue == "Abort") { MessageBox.Show("Aborted by user", "ABORTED", MessageBoxButtons.OK); myCommonData.Mode = "Abort"; } disValue = disValue.Trim(new Char[] { ' ', '?', 'P', 'V' }); disValue = disValue.TrimEnd(new Char[] { ' ', 'o', 'k', '\r', '\n' }); myTestInfo.ResultsParams[1].Result = disValue; myTestInfo.ResultsParams[2].Result = Convert.ToString(myPreheatForm.checkvolt); string conStr = "Data Source=wpsqldb21;Initial Catalog=VpdOF;Persist Security Info=True;User ID=VpdTest;Password=Vpd@123"; using (SqlConnection my_sql = new SqlConnection(conStr)) { my_sql.Open(); SqlCommand command = new SqlCommand("insert into PV(LOT,MODEL,PREHEAT,RESULT,DAC,FIRMWARE,ION_SOURCE)" + "VALUES('" + SN + "','" + Model + "','" + myPreheatForm.checkvolt + "','PASS','" + disValue + "','1.04'" + ",'" + myPreheatForm.ISsn + "')", my_sql); command.ExecuteNonQuery(); my_sql.Close(); } break; } case "5.2.5 Measure_DCVoltage": { step = 1; //Lock DMM string conStr = myTestInfo.TestParams[1].Value; int checking = 1; //while (checking > 0) //{ // string DMMstatus = SQL_34970A.Read_DMM_Status(conStr); // if (DMMstatus == "No") // { // SQL_34970A.Update_DMM_Status(myuutdata.Options, "Yes", conStr); //Yes = Lock No = Unlock // break; // } // Thread.Sleep(5000); //} //@@ Measure the voltage between the black and red wire of the chasis fan connector. The acceptable range is 22.8V ~ 25.2V @@// Trace.WriteLine("Measuring the voltage of the chasis fan connector..."); FormDcPowerSupply dcvForm = new FormDcPowerSupply(); dcvForm.StartPosition = FormStartPosition.Manual; dcvForm.Location = new System.Drawing.Point(locX, locY); dcvForm.ShowDialog(); double dcvReading = 0; if (dcvForm.DialogResult == DialogResult.OK) { dcvReading = dcvForm.DcVolt; } else { dcvReading = dcvForm.DcVolt; //throw new Exception("24V measurement canceled by user!"); } myTestInfo.ResultsParams[1].Result = dcvReading.ToString(); //reading = InstrumentIO.Measure_DCV(""); //if (Convert.ToDouble(reading) >= 22.8 && Convert.ToDouble(reading) <= 25.2) //{ // Trace.WriteLine("Test point complete."); // myTestInfo.ResultsParams[step].Result = reading; //} //else //{ // myTestInfo.ResultsParams[step].Result = reading; // //throw new Exception("Measured value out of acceptable range."); //} //Unlock DMM //Trace.WriteLine("Unlocking the DMM..."); //SQL_34970A.Update_DMM_Status(myuutdata.Options, "No", conStr); break; } case "5.2.6 Check_Fan": { step = 1; //@@ To verify the condition of both fans @@// Trace.WriteLine("Verify the condition of both fans..."); Display = "Seq 5.2.6:\nPlease verify the condition of BOTH fans. Are they running as expected? \n\nEnter 'ok' if pass. Else 'no'"; reading = Helper.LabelDisplay(Display); if (reading == "ok") { Trace.WriteLine("Test point complete."); myTestInfo.ResultsParams[step].Result = reading; } else if (reading == "no") { myTestInfo.ResultsParams[step].Result = reading; //throw new Exception("One or both fans are not functioning properly."); } break; } } } catch (Exception ex) { Trace.WriteLine(ex.Message); Helper.Fail_Test(ref myTestInfo, ex.Message, step); throw; } return(myTestInfo); }
public static TestInfo DoSeq5_9(VSLeakDetector myLD, ref TestInfo myTestInfo, ref UUTData myuutdata) { Boolean status = false; string retval = ""; int step = 1; //VSLeakDetector myLD = new VSLeakDetector(comPort); //myLD.iteSlot = iteSlot; Helper.comPort = comPort; try { switch (myTestInfo.TestLabel) { case "5.9.1 Calibration": { step = 1; //Access to full command Trace.WriteLine(iteSlot + "Access to full command..."); Helper.SendCommand(myLD, ref status, "XYZZY", "ok"); //Obtain stdleak reading Trace.WriteLine(iteSlot + "Obtain the stdleak reading..."); retval = Helper.SendCommand(myLD, ref status, "?STDLEAK", "ok"); if (status == true) { string[] response = retval.Split(new string[] { "?STDLEAK ", "ok" }, StringSplitOptions.RemoveEmptyEntries); Stdleak = Convert.ToDouble(response[0]); } /*@@ Initiates a Full or Fast calibration depending on system settings. The CPU software tunes, * then adjusts the gain so that the current helium signal causes the current leak rate measurement * to be the same as the most recently input using INIT-STDLEAK. If the gain is 2.9 or higher, a normal * calibration is performed. Success is indicated by the normal ok response. @@*/ Trace.WriteLine(iteSlot + "Rough process will be triggered if UUT is not in FINE TEST mode."); //myLD.Open(); myLD.Write("?VALVESTATE"); retval = myLD.Read(); //myLD.Close(); if (!retval.Contains("MIDSTAGE")) { Trace.WriteLine(iteSlot + "Roughing the UUT..."); Helper.SendCommand(myLD, ref status, "ROUGH", "ok"); } status = Helper.Wait_FineTest(myLD); //Wait for stabilization Trace.WriteLine(iteSlot + "Wait for stabilization..."); Thread.Sleep(60000); if (status == true) { Trace.WriteLine(iteSlot + "Initiates a FULL or FAST calibration based on system configurations..."); status = Helper.DoThis(myLD, ref myTestInfo, "CALIBRATE", "ok", step, "ok"); } step++; Thread.Sleep(3000); //@@ Wait for 979 Calibration VI @@// status = Helper.Wait_FineTest(myLD); if (status == true) { myTestInfo.ResultsParams[step].Result = "ok"; } else { myTestInfo.ResultsParams[step].Result = "FAILED"; } break; } case "5.9.2 Verify_Calibration": { step = 1; //@@ Report and verify the status of the last calibration. @@// Trace.WriteLine(iteSlot + "Report and verify the status of the last calibration..."); status = Helper.DoThis(myLD, ref myTestInfo, "?CALOK", "Yesok", step, "ok"); break; } case "5.9.3 Verify_LeakReading": { step = 1; while (step <= myTestInfo.ResultsParams.NumResultParams) { //@@ Turn ON internal calibrated leak @@// Thread.Sleep(2000); Trace.WriteLine(iteSlot + "Open the stdleak..."); Helper.SendCommand(myLD, ref status, "STDLEAK", "ok"); if (status == false) { break; } //Helper.DoThis(myLD, ref myTestInfo, "STDLEAK", "ok", step, "ok"); //Thread.Sleep(13000); stdleakcheck: status = Helper.DoThis(myLD, ref myTestInfo, "?VALVESTATE", "STDLEAK", step, "ok"); if (status == false) { //ys wong Thread.Sleep(1000); goto stdleakcheck; } step++; Trace.WriteLine(iteSlot + "Provide time for the UUT to read the Stdleak..."); // Hairus added to dynamically wait until the stdleak reading is stabilized. //myLD = new VSLeakDetector(comPort); // myLD.iteSlot = iteSlot; // myLD.Open(); //bool isStdLeakState = myLD.WaitForStdLeakState(ref retval); // Thread.Sleep(5000); //bool isLeakStabilized = myLD.WaitForStabilizedReading(ref retval, 120, 0.97, 10); Thread.Sleep(6000); //myLD.Close(); //@@ Obtain the leakrate reading @@// readleakagain: Trace.WriteLine(iteSlot + "Obtain the leakrate..."); retval = Helper.SendCommand(myLD, ref status, "?LEAK", "ok"); if (status == true) { string[] response = retval.Split(new string[] { "?LEAK ", "ok" }, StringSplitOptions.RemoveEmptyEntries); Leakrate = Convert.ToDouble(response[0]); Trace.WriteLine(iteSlot + "Measured leak rate = " + Leakrate + "Std .cc/s"); myTestInfo.ResultsParams[step].Result = "ok"; Trace.WriteLine(iteSlot + "Test point complete."); } else { myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } step++; //@@ Compare the leak rate with stdleak rate @@// Trace.WriteLine(iteSlot + "Compare the obtained leak rate with the stdleak installed..."); retval = Helper.SendCommand(myLD, ref status, "?STDLEAKt", "ok"); double stdleakt = 0; double exp_stdleakt = 0; if (status == true) { string[] response = retval.Split(new string[] { "?STDLEAKt ", "ok" }, StringSplitOptions.RemoveEmptyEntries); string[] response2 = response[0].Split(new string[] { "E-" }, StringSplitOptions.RemoveEmptyEntries); stdleakt = Convert.ToDouble(response[0]); exp_stdleakt = Convert.ToDouble(response2[1]); } // set max and minimum limit reading for the leak rate verification compared to stdleakt // The displayed leak rate value shall be no more than +-0.2 from the ?STDLEAKt (temperature compensated cal leak) value. double maxLeakDiff = stdleakt + 0.2E-7; double minLeakDiff = stdleakt - 0.2E-7; myTestInfo.ResultsParams[step].SpecMax = maxLeakDiff.ToString(); myTestInfo.ResultsParams[step].SpecMin = minLeakDiff.ToString(); myTestInfo.ResultsParams[step].Nominal = stdleakt.ToString(); // set the result int cycle = 1; recheckintcal: if (!((minLeakDiff <= Leakrate) & (Leakrate <= maxLeakDiff))) { status = false; retval = Helper.SendCommand(myLD, ref status, "?LEAK", "ok"); if (status == true) { string[] response = retval.Split(new string[] { "?LEAK ", "ok" }, StringSplitOptions.RemoveEmptyEntries); Leakrate = Convert.ToDouble(response[0]); Trace.WriteLine(iteSlot + "Measured leak rate = " + Leakrate + "Std .cc/s"); if (cycle >= 4) { myTestInfo.ResultsParams[step].Result = "FAILED"; break; } goto recheckintcal; } else { myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } } myTestInfo.ResultsParams[step].Result = Leakrate.ToString(); //if (Leakrate >= (stdleak - 0.2 * Math.Pow(10, exp_stdleakt)) && Leakrate <= (stdleak + 0.2 * Math.Pow(10, exp_stdleakt))) //{ // myTestInfo.ResultsParams[step].Result = "ok"; // Trace.WriteLine(iteSlot + "Test point complete."); //} //else //{ // myTestInfo.ResultsParams[step].Result = "FAILED"; // //throw new Exception("Test point failed."); //} step++; } break; } case "5.9.4": { step = 1; //@@ Close the internal calibrate leak @@// Trace.WriteLine(iteSlot + "Close the stdleak..."); status = Helper.DoThis(myLD, ref myTestInfo, "STDLEAK", "ok", step, "ok"); step++; int counter = 1; //YS WONG recheck: string checker = Helper.SendCommand(myLD, ref status, "?VALVESTATE", "MIDSTAGE"); if (!checker.Contains("MIDSTAGE")) { Thread.Sleep(2000); counter++; if (counter > 5) { Trace.WriteLine("MIDSTAGE FAIL"); } //break; } else { goto recheck; } } // YS WONG // wait until the LD fully closed STDLEAK before vent to atmospheric //Thread.Sleep(5000); ////////////@@ Vent the UUT @@// Thread.Sleep(1000); Trace.WriteLine(iteSlot + "Venting the UUT..."); status = Helper.DoThis(myLD, ref myTestInfo, "VENT", "ok", step, "ok"); checkagain: retval = Helper.SendCommand(myLD, ref status, "?PRESSURES", "ok"); string[] resp = retval.Split(new string[] { "(mTorr): ", "\r\nSpectrometer" }, StringSplitOptions.RemoveEmptyEntries); int Pressure = Convert.ToInt32(resp[1]); Trace.WriteLine(iteSlot + "Pressure: " + Pressure + "mTorr System Pressure: "); // commented out below manual limit checking, use test executive to do the limit checking and display the result correctly if (!(Pressure >= 700000 && Pressure <= 760000)) { Thread.Sleep(2000); goto checkagain; } Thread.Sleep(1000); break; } case "5.9.5 Init_Extleak": { step = 1; //while (step <= myTestInfo.ResultsParams.NumResultParams)// again why need to do while loop here.. //{ //@@ Initiate external calibrated leak @@// Trace.WriteLine(iteSlot + "Roughing the UUT..."); status = Helper.DoThis(myLD, ref myTestInfo, "ROUGH", "ok", step, "ok"); Thread.Sleep(5000); status = Helper.DoThis(myLD, ref myTestInfo, "KEEP", "ok", step, "ok"); Thread.Sleep(3000); Trace.WriteLine(iteSlot + "Initiate external leak rate..."); if (myLD.iteSlot.Contains("P1")) { Helper.DoThis(myLD, ref myTestInfo, External_leak_Parameters.Ext_leakrate1 + " INIT-EXTLEAK", "ok", step, "ok"); } else { Helper.DoThis(myLD, ref myTestInfo, External_leak_Parameters.Ext_leakrate2 + " INIT-EXTLEAK", "ok", step, "ok"); } step++; Trace.WriteLine(iteSlot + "Open the external calibrated leak..."); InstrumentIO.Open_Extleak(slotNum); //Open external calibrated leak valve Thread.Sleep(2000); // give some time to valve to fully open before roughing. //@@ Rough the UUT @@// Trace.WriteLine(iteSlot + "Roughing the UUT..."); status = Helper.DoThis(myLD, ref myTestInfo, "ROUGH", "ok", step, "ok"); step++; //@@ Wait for fine test @@// int repeat = 1; again: Thread.Sleep(7000); //status = Helper.Wait_FineTest(myLD, 120); string check = Helper.SendCommand(myLD, ref status, "?VALVESTATE", "MIDSTAGE"); if (check.Contains("MIDSTAGE")) { myTestInfo.ResultsParams[step].Result = "ok"; } else { //InstrumentIO.Close_Extleak(slotNum); //Thread.Sleep(2000); //InstrumentIO.Open_Extleak(slotNum); if (repeat >= 4) { myTestInfo.ResultsParams[step].Result = "FAILED"; break; } repeat++; goto again; } step++; Trace.WriteLine(iteSlot + "Gives UUT time to read the leak rate..."); //myLD = new VSLeakDetector(comPort); //myLD.iteSlot = iteSlot; //myLD.Open(); // bool isLeakrateStabilized = myLD.WaitForStabilizedReading(ref retval, 120, 0.97, 10); //myLD.Close(); //Thread.Sleep(20000); //@@ Midstage leak rate? @@// // recheck: Trace.WriteLine(iteSlot + "Obtain midstage leak rate..."); Thread.Sleep(10000); //retval = Helper.SendCommand(myLD, ref status, "?LEAK", "ok"); if (status == true) { int i = 1; recheck: Thread.Sleep(4000); retval = Helper.SendCommand(myLD, ref status, "?LEAK", "ok"); string[] response = retval.Split(new string[] { "?LEAK ", "ok" }, StringSplitOptions.RemoveEmptyEntries); Midstage_leak = Convert.ToDouble(response[0]); Trace.WriteLine(iteSlot + "Measured leak rate = " + Midstage_leak + "Std .cc/s"); //myTestInfo.ResultsParams[step].Result = "ok"; // display midstage leak value instead of 'ok' text. double extStdLeakRate = 0; if (myLD.iteSlot.Contains("P1")) { extStdLeakRate = Convert.ToDouble(External_leak_Parameters.Ext_leakrate1); } else { extStdLeakRate = Convert.ToDouble(External_leak_Parameters.Ext_leakrate2); } double maxLeakRate = extStdLeakRate + 0.00000002; double minLeakRate = extStdLeakRate - 0.00000002; myTestInfo.ResultsParams[step].Result = Midstage_leak.ToString(); myTestInfo.ResultsParams[step].SpecMax = maxLeakRate.ToString(); myTestInfo.ResultsParams[step].SpecMin = minLeakRate.ToString(); myTestInfo.ResultsParams[step].Nominal = extStdLeakRate.ToString(); if ((minLeakRate < Midstage_leak) && (Midstage_leak < maxLeakRate)) { myTestInfo.ResultsParams[step].Result = Midstage_leak.ToString(); } else { i++; if (i < 120) { Helper.DoThis(myLD, ref myTestInfo, "ROUGH", "ok", step, "ok"); Thread.Sleep(4000); goto recheck; } } } else { myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } step++; } break; //} case "5.9.6 Fastvgain": { step = 1; /*@@ An integer that scales the leak rate to account for deviations in helium compression ratios between contraflow and midstage modes * in fast turbo speed. @@*/ Trace.WriteLine(iteSlot + "Scales the leak rate to account for deviations in helium compression ratios between contraflow and midstage modes..."); status = Helper.DoThis(myLD, ref myTestInfo, "1 INIT-FAST-VGAIN", "ok", step, "ok"); break; } case "5.9.7 Sniff": { step = 1; //@@ Turns the HIGH PRESSURE TEST mode ON. @@// Trace.WriteLine(iteSlot + "Turns the HIGH PRESSURE TEST mode ON...."); status = Helper.DoThis(myLD, ref myTestInfo, "SNIFF", "ok", step, "ok"); // 6 Nov 17: With London FW rev L01.01, the SNIFF command will not change LD from Fine-Test to Test mode. // If we send ROUGH command it will change it to Test mode. This is some kind of bug in this LD01.01 revision. // below code only for temporary. string val = Helper.SendCommand(myLD, ref status, "ROUGH", "ok"); Thread.Sleep(2000); // end temporary break; } case "5.9.8 Measure_Contra": { step = 1; //@@ Wait for Contraflow mode @@// Thread.Sleep(20000); status = Helper.Wait_Test(myLD); if (status == true) { myTestInfo.ResultsParams[step].Result = "ok"; } else { myTestInfo.ResultsParams[step].Result = "FAILED"; } step++; // experiment, for VGain enhancement. #1 var listOfVGainLimits = new List <string>(); listOfVGainLimits.Add(myTestInfo.TestParams[1].Value); // portable LD 110 listOfVGainLimits.Add(myTestInfo.TestParams[2].Value); // portable LD 220 listOfVGainLimits.Add(myTestInfo.TestParams[3].Value); // mobile/bench RVP LD 110 listOfVGainLimits.Add(myTestInfo.TestParams[4].Value); // mobile/bench RVP LD 220 listOfVGainLimits.Add(myTestInfo.TestParams[5].Value); // mobile/bench Scroll Pump LD 110 listOfVGainLimits.Add(myTestInfo.TestParams[6].Value); // mobile/bench Scroll Pump LD 220 string[] limitsArray = listOfVGainLimits.ToArray(); string csvVGainLimit = Helper.GetVgainLimit(myuutdata.Model, limitsArray); // Get VGain limits for specific LD model double vGainLsl = Convert.ToDouble(csvVGainLimit.Split(',').FirstOrDefault()); double vGainUsl = Convert.ToDouble(csvVGainLimit.Split(',').LastOrDefault()); double vGainNominal = vGainLsl + ((vGainUsl - vGainLsl) / 2); // expected contra-leak for vgain at nominal double expContraSniffLeak = vGainNominal * Midstage_leak; Trace.WriteLine(iteSlot + "Provide time for the UUT to read the leak rate..."); //myLD = new VSLeakDetector(comPort); //myLD.iteSlot = iteSlot; //myLD.Open(); //bool isReadingMet = myLD.WaitForSpecificReading(ref retval, 120, expContraSniffLeak, 1); //ys wong //myLD.Close(); //// EXPERIMENT #2 WAIT FOR STABILIZED LEAK RATE AT E-6 //Trace.WriteLine(iteSlot + "Provide time for the UUT to read the leak rate..."); //myLD = new VSLeakDetector(comPort); //myLD.iteSlot = iteSlot; //myLD.Open(); //isReadingMet = myLD.WaitForStabilizedReading(ref retval, 120, 0.9, 5); //myLD.Close(); // Original from ATP //Trace.WriteLine(iteSlot + "Provide time for the UUT to read the leak rate..."); Thread.Sleep(20000); //@@ Contraflow leak value @@// again: Trace.WriteLine(iteSlot + "Obtain contraflow leak rate..."); retval = Helper.SendCommand(myLD, ref status, "?LEAK", "ok"); if (status == true) { string[] response = retval.Split(new string[] { "?LEAK ", "ok" }, StringSplitOptions.RemoveEmptyEntries); Contra_leak = Convert.ToDouble(response[0]); Trace.WriteLine(iteSlot + "Measured leak rate = " + Contra_leak + "Std .cc/s"); if (Contra_leak == 0.00E-00) { goto again; } myTestInfo.ResultsParams[step].Result = myTestInfo.ResultsParams[step].SpecMax = myTestInfo.ResultsParams[step].SpecMin = myTestInfo.ResultsParams[step].Nominal = Contra_leak.ToString(); //myTestInfo.ResultsParams[step].Result = "ok"; } else { myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } break; } case "5.9.11 Fastvgain": { step = 1; /*@@ An integer that scales the leak rate to account for deviations in helium compression ratios between contraflow and midstage modes * in fast turbo speed. @@*/ Vgain = Math.Round(Contra_leak / Midstage_leak, 0, MidpointRounding.AwayFromZero); Trace.WriteLine(iteSlot + "Scales the leak rate to account for deviations in helium compression ratios between contraflow and midstage modes..."); Trace.WriteLine(iteSlot + "Vgain = " + Vgain); status = Helper.DoThis(myLD, ref myTestInfo, Vgain + " INIT-FAST-VGAIN", "ok", step, "ok"); Thread.Sleep(2000); break; } case "5.9.12 Measure_Contra": { step = 1; while (step <= myTestInfo.ResultsParams.NumResultParams) { //@@ Vent the UUT @@// Trace.WriteLine(iteSlot + "Venting the UUT..."); status = Helper.DoThis(myLD, ref myTestInfo, "VENT", "ok", step, "ok"); step++; //add in pressures //YS Wong checkagain: retval = Helper.SendCommand(myLD, ref status, "?PRESSURES", "ok"); string[] resp = retval.Split(new string[] { "(mTorr): ", "\r\nSpectrometer" }, StringSplitOptions.RemoveEmptyEntries); int Pressure = Convert.ToInt32(resp[1]); Trace.WriteLine(iteSlot + "Pressure: " + Pressure + "mTorr System Pressure: "); // commented out below manual limit checking, use test executive to do the limit checking and display the result correctly if (!(Pressure >= 700000 && Pressure <= 760000)) { Thread.Sleep(2000); goto checkagain; } Thread.Sleep(1000); //@@ Rough the UUT @@// Trace.WriteLine(iteSlot + "Roughing the UUT..."); status = Helper.DoThis(myLD, ref myTestInfo, "ROUGH", "ok", step, "ok"); step++; //@@ Wait for Contraflow mode @@// status = Helper.Wait_Test(myLD); if (status == true) { myTestInfo.ResultsParams[step].Result = "ok"; } else { myTestInfo.ResultsParams[step].Result = "FAILED"; } step++; Trace.WriteLine(iteSlot + "Provide time for the UUT to read the leak rate..."); //myLD = new VSLeakDetector(comPort); //myLD.iteSlot = iteSlot; //myLD.Open(); // bool isreadingStabilized = myLD.WaitForStabilizedReading(ref retval, 120, 0.97, 10); YS Wong //myLD.Close(); Thread.Sleep(25000); //@@ Contraflow leak value @@// Trace.WriteLine(iteSlot + "Obtain contraflow leak rate..."); retval = Helper.SendCommand(myLD, ref status, "?LEAK", "ok"); if (status == true) { string[] response = retval.Split(new string[] { "?LEAK ", "ok" }, StringSplitOptions.RemoveEmptyEntries); Contra_leak = Convert.ToDouble(response[0]); Trace.WriteLine(iteSlot + "Measured leak rate = " + Contra_leak + "Std .cc/s"); myTestInfo.ResultsParams[step].Result = myTestInfo.ResultsParams[step].SpecMax = myTestInfo.ResultsParams[step].SpecMin = myTestInfo.ResultsParams[step].Nominal = Contra_leak.ToString(); } else { myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } step++; } break; } case "5.9.13 Measure_Midstage": { step = 1; while (step <= myTestInfo.ResultsParams.NumResultParams) { //@@ Turns the HIGH PRESSURE TEST function OFF @@// Trace.WriteLine(iteSlot + "Turns the HIGH PRESSURE TEST function OFF..."); status = Helper.DoThis(myLD, ref myTestInfo, "NOSNIFF", "ok", step, "ok"); step++; //@@ Wait for FINETEST MODE @@// status = Helper.Wait_FineTest(myLD); if (status == true) { myTestInfo.ResultsParams[step].Result = "ok"; } else { myTestInfo.ResultsParams[step].Result = "FAILED"; } step++; Trace.WriteLine(iteSlot + "Gives UUT time to read the leak rate..."); //myLD = new VSLeakDetector(comPort); //myLD.iteSlot = iteSlot; //myLD.Open(); // ys wong //bool isreadingStabilized = myLD.WaitForStabilizedReading(ref retval, 120, 0.97, 10); //myLD.Close(); Thread.Sleep(20000); //midstage check not exist?? //@@ Midstage leak? @@// Trace.WriteLine(iteSlot + "Obtain midstage leak rate...");; retval = Helper.SendCommand(myLD, ref status, "?LEAK", "ok"); if (status == true) { string[] response = retval.Split(new string[] { "?LEAK ", "ok" }, StringSplitOptions.RemoveEmptyEntries); Midstage_leak = Convert.ToDouble(response[0]); Trace.WriteLine(iteSlot + "Measured leak rate = " + Midstage_leak + "Std .cc/s"); myTestInfo.ResultsParams[step].Result = myTestInfo.ResultsParams[step].SpecMax = myTestInfo.ResultsParams[step].SpecMin = myTestInfo.ResultsParams[step].Nominal = Midstage_leak.ToString(); } else { myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } step++; } break; } case "5.9.14 Verify_Contra_Midstage": { step = 1; //@@ Compare the contraflow leak rate and the midstage leak rate @@// Trace.WriteLine(iteSlot + "Compare the contraflow leak rate and the midstage leak rate..."); if (Midstage_leak < 1E-07) { double diff = Math.Abs(Midstage_leak - Contra_leak); myTestInfo.ResultsParams[step].Result = diff.ToString(); // good result, difference must be <=0.2E-08 myTestInfo.ResultsParams[step].SpecMax = "0.000000002"; myTestInfo.ResultsParams[step].SpecMin = "0"; myTestInfo.ResultsParams[step].Nominal = "0"; } else if (Midstage_leak >= 1E-07) { double diff = Math.Abs(Midstage_leak - Contra_leak); myTestInfo.ResultsParams[step].Result = diff.ToString(); // good result, difference must be <=0.2E-07 myTestInfo.ResultsParams[step].SpecMax = "0.00000002"; myTestInfo.ResultsParams[step].SpecMin = "0"; myTestInfo.ResultsParams[step].Nominal = "0"; } //if((Midstage_leak < 1E-07 && Math.Abs(Midstage_leak - Contra_leak) <= 0.2E-8) || (Midstage_leak >= 1E-07 && Math.Abs(Midstage_leak - Contra_leak) <= 0.2E-7)) //{ // Trace.WriteLine(iteSlot + "Test point complete."); // myTestInfo.ResultsParams[step].Result = "ok"; //} else { // only magic will reach here myTestInfo.ResultsParams[step].Result = "FAILED"; //throw new Exception("Test point failed."); } break; } case "5.9.15 Verify_Vgain": { step = 1; // Hairus added to get VGain from PluginSequence test params instead of hardcoded var listOfVGainLimits = new List <string>(); listOfVGainLimits.Add(myTestInfo.TestParams[1].Value); // portable LD 110 listOfVGainLimits.Add(myTestInfo.TestParams[2].Value); // portable LD 220 listOfVGainLimits.Add(myTestInfo.TestParams[3].Value); // mobile/bench RVP LD 110 listOfVGainLimits.Add(myTestInfo.TestParams[4].Value); // mobile/bench RVP LD 220 listOfVGainLimits.Add(myTestInfo.TestParams[5].Value); // mobile/bench Scroll Pump LD 110 listOfVGainLimits.Add(myTestInfo.TestParams[6].Value); // mobile/bench Scroll Pump LD 220 string[] limitsArray = listOfVGainLimits.ToArray(); //@@ Based on model number, verify the vgain value @@// Trace.WriteLine(iteSlot + "Verify the vgain value based on the model number of the UUT..."); //status = Helper.GetModel_Vgain(myuutdata.Model, Vgain); // remove hardcoded value string csvVGainLimit = Helper.GetVgainLimit(myuutdata.Model, limitsArray); double vGainLsl = Convert.ToDouble(csvVGainLimit.Split(',').FirstOrDefault()); double vGainUsl = Convert.ToDouble(csvVGainLimit.Split(',').LastOrDefault()); double vGainNominal = vGainLsl + ((vGainUsl - vGainLsl) / 2); // set result spec limits dynamically myTestInfo.ResultsParams[step].SpecMin = vGainLsl.ToString(); myTestInfo.ResultsParams[step].Nominal = vGainNominal.ToString(); myTestInfo.ResultsParams[step].SpecMax = vGainUsl.ToString(); // retreive the calculated vgain and set as result myTestInfo.ResultsParams[step].Result = Vgain.ToString(); //if (status == true) //{ // Trace.WriteLine(iteSlot + "Test point complete."); // myTestInfo.ResultsParams[step].Result = "ok"; //} //else //{ // myTestInfo.ResultsParams[step].Result = "FAILED"; // //throw new Exception("Test point failed."); //} break; } case "5.9.16 Vent": { step = 1; //@@ Vent the UUT @@// Trace.WriteLine(iteSlot + "Venting the UUT..."); status = Helper.DoThis(myLD, ref myTestInfo, "VENT", "ok", step, "ok"); checkagain: retval = Helper.SendCommand(myLD, ref status, "?PRESSURES", "ok"); string[] resp = retval.Split(new string[] { "(mTorr): ", "\r\nSpectrometer" }, StringSplitOptions.RemoveEmptyEntries); int Pressure = Convert.ToInt32(resp[1]); Trace.WriteLine(iteSlot + "Pressure: " + Pressure + "mTorr System Pressure: "); // commented out below manual limit checking, use test executive to do the limit checking and display the result correctly if (!(Pressure >= 700000 && Pressure <= 760000)) { Thread.Sleep(2000); goto checkagain; } Thread.Sleep(800); break; } case "5.9.17 Remove_Extleak": { step = 1; //@@ Close the external calibrated leak on the test port @@// Trace.WriteLine(iteSlot + "Closing the external calibrated leak on the test port..."); InstrumentIO.Close_Extleak(slotNum); Trace.WriteLine(iteSlot + "Test point complete."); myTestInfo.ResultsParams[step].Result = "ok"; break; } } } catch (Exception ex) { Trace.WriteLine(ex.Message); Helper.Fail_Test(ref myTestInfo, ex.Message, step); throw; } return(myTestInfo); }