public override MTKTestError RunTest()
{
MTKTestError return_value = MTKTestError.NoError;
programCompleted = true;
//ProgramAllAtEnd == false : Begin
if ((ProgramAllAtEnd == false) && (CurrentDUT == CyBLE_MTK.IndexConfiguredSerialPortfor1stRow))
{
InitializeTestResult();
programCompleted = false;
ProgramAll();
TestResult.Result = "DONE";
TestResultUpdate(TestResult);
TestStatusUpdate(MTKTestMessageType.Complete, "DONE");
}
//ProgramAllAtEnd == true : End
if ((ProgramAllAtEnd == true) && (CurrentDUT == CyBLE_MTK.IndexConfiguredSerialPortforfinalRow))
{
InitializeTestResult();
programCompleted = false;
ProgramAll();
TestResult.Result = "DONE";
TestResultUpdate(TestResult);
TestStatusUpdate(MTKTestMessageType.Complete, "DONE");
}
return(return_value);
}
public override MTKTestError RunTest()
{
MTKTestError return_value = MTKTestError.NoError;
this.InitializeTestResult();
if (CurrentDUT == 0)
{
programCompleted = false;
}
if (((CurrentDUT == 0) && (ProgramAllAtEnd == false)) ||
((CurrentDUT == (NumberOfDUTs - 1)) && (ProgramAllAtEnd == true)))
{
if (!ProgramAll())
{
return_value = MTKTestError.NotAllDevicesProgrammed;
}
}
TestResult.Result = "DONE";
TestResultUpdate(TestResult);
TestStatusUpdate(MTKTestMessageType.Complete, "DONE");
return(return_value);
}
private MTKTestError RunTestUART()
{
//TO DO something...
MTKTestError RetVal = MTKTestError.Pending;
try
{
MTKInstruments.DUTCurrent = MTKInstruments.MeasureChannelCurrent(CurrentDUT);
return(RetVal);
}
catch
{
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
TestResultUpdate(TestResult);
return(RetVal);
}
finally
{
//Recover all duts' power on after testing.
if (!MTKInstruments.SwitchAllDutOn())
{
this.Log.PrintLog(this, "Fail to recover power after current test.", LogDetailLevel.LogRelevant);
}
}
}
public override MTKTestError RunTest()
{
MTKTestError return_value = MTKTestError.NoError;
programCompleted = true;
//ProgramAllAtEnd == false : Begin
if ((ProgramAllAtEnd == false) && (CurrentDUT == CyBLE_MTK.IndexConfiguredSerialPortfor1stRow))
{
InitializeTestResult();
programCompleted = false;
}
//ProgramAllAtEnd == true : End
if ((ProgramAllAtEnd == true) && (CurrentDUT == CyBLE_MTK.IndexConfiguredSerialPortforfinalRow))
{
InitializeTestResult();
programCompleted = false;
}
if (programCompleted == false)
{
ProgramAll();
TestResult.Result = "DONE";
TestResultUpdate(TestResult);
TestStatusUpdate(MTKTestMessageType.Complete, "DONE");
//if (!ProgramAll())
//{
// //return_value = MTKTestError.NotAllDevicesProgrammed;
// //TestResult.Result = "FAIL";
// //TestResultUpdate(TestResult);
// //TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
//}
//else
//{
// TestResult.Result = "DONE";
// TestResultUpdate(TestResult);
// TestStatusUpdate(MTKTestMessageType.Complete, "DONE");
//}
}
else
{
TestResult.Result = "DONE";
TestResultUpdate(TestResult);
TestStatusUpdate(MTKTestMessageType.Complete, "DONE");
}
return(return_value);
}
private MTKTestError NotProgrammingThread()
{
MTKTestError temp = new MTKTestError();
temp = MTKTestError.ProgrammerNotConfigured;
return(temp);
}
public void RunTestProgram(int NumIteration)
{
bool _Ignore;
MTKTestError ReturnValue = MTKTestError.NoError;
CurrentTestStatus = TestProgramState.Running;
NumberOfDUTs = NumIteration;
TestRunViability();
TestStart = false;
for (int j = 0; j < NumIteration; j++)
{
devTestComplete = false;
_Ignore = false;
_CurrentDUT = j;
Log.PrintLog(this, "Selecting DUT " + (j + 1).ToString() + "/" +
NumIteration.ToString() + " for tests", LogDetailLevel.LogRelevant);
OnNextIteration(j);
ReturnValue = RunAllTests();
devTestComplete = true;
if ((CurrentTestStatus == TestProgramState.Stop) ||
(CurrentTestStatus == TestProgramState.Stopped) ||
(CurrentTestStatus == TestProgramState.Stopping))
{
break;
}
if (ReturnValue == MTKTestError.NoError)
{
if (TestStart)
{
OnOverallPass();
Log.PrintLog(this, "Overall test result: PASS", LogDetailLevel.LogRelevant);
}
}
else if (ReturnValue == MTKTestError.TestFailed)
{
OnOverallFail();
Log.PrintLog(this, "Overall test result: FAIL", LogDetailLevel.LogRelevant);
}
else if (ReturnValue == MTKTestError.IgnoringDUT)
{
OnIgnoreDUT();
Log.PrintLog(this, "Ignoring DUT# " + _CurrentDUT.ToString(), LogDetailLevel.LogRelevant);
_Ignore = true;
}
OnCurrentIterationComplete(j, _Ignore);
}
StopTestProgram();
OnTestStopped();
_CurrentDUT = 0;
_CurrentTestIndex = 0;
CurrentTestStatus = TestProgramState.Stopped;
}
public bool SwitchToAnritsu()
{
MTKTestError CommandRetVal = SendCommand(DUTSerialPort, "ARU", 100);
if (CommandRetVal == MTKTestError.NoError)
{
return(true);
}
return(false);
}
public override MTKTestError RunTest()
{
MTKTestError RetVal = MTKTestError.NoError;
this.InitializeTestResult();
if (!ConnectProgrammer())
{
TestStatusUpdate(MTKTestMessageType.Information, "Error!!!");
Log.PrintLog(this, "Unable to connect to the programmer.", LogDetailLevel.LogRelevant);
RetVal = MTKTestError.TestFailed;
}
if (SelectedAction == PSoCProgrammerAction.Program)
{
if (!ProgramAll())
{
TestStatusUpdate(MTKTestMessageType.Information, "Error!!!");
//Log.PrintLog(this, "Unable to flash the hex file.", LogDetailLevel.LogRelevant);
RetVal = MTKTestError.TestFailed;
}
}
else if (SelectedAction == PSoCProgrammerAction.Erase)
{
if (!EraseAll())
{
TestStatusUpdate(MTKTestMessageType.Information, "Error!!!");
//Log.PrintLog(this, "Unable to erase flash.", LogDetailLevel.LogRelevant);
RetVal = MTKTestError.TestFailed;
}
}
if (!DisconnectProgrammer())
{
TestStatusUpdate(MTKTestMessageType.Information, "Error!!!");
Log.PrintLog(this, "Unable to disconnect from the programmer.", LogDetailLevel.LogRelevant);
RetVal = MTKTestError.TestFailed;
}
if (RetVal == MTKTestError.NoError)
{
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
TestResult.Result = "PASS";
}
else
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
TestResult.Result = "FAIL";
}
TestResultUpdate(TestResult);
return(RetVal);
}
public override MTKTestError RunTest()
{
MTKTestError return_value = MTKTestError.NoError;
if (((CurrentDUT == 0) && (ProgramAllAtEnd == false)) ||
((CurrentDUT == (NumberOfDUTs - 1)) && (ProgramAllAtEnd == true)))
{
if (!ProgramAll())
{
return_value = MTKTestError.NotAllDevicesProgrammed;
}
}
TestStatusUpdate(MTKTestMessageType.Complete, "DONE");
return(return_value);
}
public override MTKTestError RunTest()
{
MTKTestError RetVal = MTKTestError.NoError;
this.InitializeTestResult();
if (this.DUTConnectionMode == DUTConnMode.BLE)
{
RetVal = RunTestBLE();
}
else if (this.DUTConnectionMode == DUTConnMode.UART)
{
RefreshMTKHostSerialPort(MTKSerialPort);
RetVal = RunTestUART();
}
else
{
MTKTestTmplSFCSErrCode = ECCS.ERROR_CODE_CAUSED_BY_MTK_TESTER;
return(MTKTestError.NoConnectionModeSet);
}
TestResultUpdate(TestResult);
if (RetVal == MTKTestError.NoError)
{
if (MTKSerialPort.IsOpen)
{
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_ALL_PASS;
}
else
{
MTKTestTmplSFCSErrCode = ECCS.ERROR_CODE_CAUSED_BY_MTK_TESTER;
}
}
else if (RetVal == MTKTestError.IgnoringDUT)
{
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_DUT_NOT_TEST;
}
else
{
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_STC_DATA_TRANSFER_TEST_FAIL;
}
return(RetVal);
}
public UInt16 ReturnFinalDUTOverallSFCSErrCodeforDUT(MTKTestError mTKTestError, UInt16 _DUTOverallSFCSErrCode, bool shopfloorpermission)
{
try
{
if (!shopfloorpermission && _DUTOverallSFCSErrCode != ECCS.ERRORCODE_DUT_NOT_TEST && mTKTestError != MTKTestError.IgnoringDUT)
{
return(ECCS.ERRORCODE_SHOPFLOOR_PROCESS_ERROR);
}
else
{
//for DUTOverallSFCSErrCode
return(_DUTOverallSFCSErrCode);
}
}
catch (Exception ex)
{
MessageBox.Show("Reason: \n" + ex.ToString(), "ReturnFinalDUTOverallSFCSErrCodeforDUT Error");
}
return(ECCS.TMPL_ERROR_CODE);
}
public UInt16 ReturnFinalDUTOverallSFCSErrCodeforDUT(MTKTestError mTKTestError, UInt16 _DUTOverallSFCSErrCode, bool shopfloorpermission, int CurrentDUT)
{
try
{
if (!shopfloorpermission && _DUTOverallSFCSErrCode != ECCS.ERRORCODE_DUT_NOT_TEST && mTKTestError != MTKTestError.IgnoringDUT)
{
return(TestProgramManager.DUTProcessCheckErrCode[CurrentDUT]);
}
else
{
//for DUTOverallSFCSErrCode
return(_DUTOverallSFCSErrCode);
}
}
catch (Exception ex)
{
MessageBox.Show("Reason: \n" + ex.ToString(), "ReturnFinalDUTOverallSFCSErrCodeforDUT Error");
}
return(ECCS.TMPL_ERROR_CODE);
}
private bool ExecuteSTCCommand(string Command, MTKTestError CommandRetVal, SerialPort DUTSerialPort, int DelayPerCommand, int TimeSlice, int TimeIncSteps, int PercentageComplete, int PercentIncSteps)
{
// Command #3
Command = "STC " + (this.PacketCount * 2).ToString();
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(false);
}
for (int i = 0; i < TimeSlice; i++)
{
PercentageComplete += PercentIncSteps;
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
Thread.Sleep(TimeIncSteps);
}
return(true);
}
public override MTKTestError RunTest()
{
MTKTestError RetVal = MTKTestError.NoError;
this.InitializeTestResult();
if (this.DUTConnectionMode == DUTConnMode.BLE)
{
RetVal = RunTestBLE();
}
else if (this.DUTConnectionMode == DUTConnMode.UART)
{
RetVal = RunTestUART();
}
else
{
return(MTKTestError.NoConnectionModeSet);
}
TestResultUpdate(TestResult);
return(RetVal);
}
private bool ExecuteRRSCommand(string command, MTKTestError commandRetVal, SerialPort dUTSerialPort, int delayPerCommand)
{
throw new NotImplementedException();
}
public void _RunTestProgram(int NumIteration)
{
bool _Ignore;
MTKTestError ReturnValue = MTKTestError.NoError;
CurrentTestStatus = TestProgramState.Running;
NumberOfDUTs = NumIteration;
TestRunViability();
TestStart = false;
try
{
stopwatch.Restart();
Log.PrintLog(this, $"RunTestProgram StopWatch is started.", LogDetailLevel.LogRelevant);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "StopWatch of TestProgramManager");
}
if (CheckAllDutsPermissionFailure())
{
for (int i = 0; i < NumIteration; i++)
{
OnOverallFail();
Log.PrintLog(this, "Overall test result: FAIL", LogDetailLevel.LogRelevant);
}
}
else
{
for (int j = 0; j < NumIteration; j++)
{
devTestComplete = false;
_Ignore = false;
_CurrentDUT = j;
Log.PrintLog(this, "Selecting DUT " + (j + 1).ToString() + "/" +
NumIteration.ToString() + " for tests", LogDetailLevel.LogRelevant);
OnNextIteration(j);
if (CyBLE_MTK.DUTsTestFlag[j])
{
ReturnValue = RunAllTests();
}
else
{
ReturnValue = MTKTestError.IgnoringDUT;
}
devTestComplete = true;
if ((CurrentTestStatus == TestProgramState.Stop) ||
(CurrentTestStatus == TestProgramState.Stopped) ||
(CurrentTestStatus == TestProgramState.Stopping))
{
break;
}
if (ReturnValue == MTKTestError.NoError && CyBLE_MTK.DUTsTestFlag[_CurrentDUT])
{
if (TestStart)
{
OnOverallPass();
Log.PrintLog(this, "Overall test result: PASS", LogDetailLevel.LogRelevant);
}
}
//else if (ReturnValue == MTKTestError.ProcessCheckFailure)
//{
// DUTOverallSFCSErrCode[_CurrentDUT] = ECCS.ERRORCODE_SHOPFLOOR_PROCESS_ERROR;
// OnOverallFail();
//}
else if (ReturnValue == MTKTestError.IgnoringDUT || ReturnValue == MTKTestError.ProgrammerNotConfigured || (!CyBLE_MTK.DUTsTestFlag[_CurrentDUT] && CyBLE_MTK.shopfloor_permission[_CurrentDUT]))
{
OnIgnoreDUT();
Log.PrintLog(this, "Ignoring DUT# " + _CurrentDUT.ToString(), LogDetailLevel.LogRelevant);
DUTOverallSFCSErrCode[_CurrentDUT] = ECCS.ERRORCODE_DUT_NOT_TEST;
_Ignore = true;
}
else
{
OnOverallFail();
Log.PrintLog(this, "Overall test result: FAIL", LogDetailLevel.LogRelevant);
}
CurrentDUTTestError = ReturnValue;
OnCurrentIterationComplete(j, _Ignore);
}
}
try
{
stopwatch.Stop();
Log.PrintLog(this, $"The last cycle run test program with {NumberOfDUTs} DUT(s) totally elasped: " + stopwatch.Elapsed.TotalSeconds + " secs.", LogDetailLevel.LogRelevant);
CyBLE_MTK.TestProgramRunCycleTimeForBatch = stopwatch.Elapsed.TotalSeconds.ToString();
}
catch
{
MessageBox.Show("Fail to stopwatch");
}
SetDUTOverallSFCSErrCode();
StopTestProgram();
OnTestStopped();
_CurrentDUT = 0;
_CurrentTestIndex = 0;
CurrentTestStatus = TestProgramState.Stopped;
}
private MTKTestError RunAllTests()
{
bool FailedOnce = false;
testRunning = true;
for (int i = 0; i < TestProgram.Count; i++)
{
_CurrentTestIndex = i;
if (CurrentTestStatus == TestProgramState.Stop)
{
CurrentTestStatus = TestProgramState.Stopping;
StopTestProgram();
CurrentTestStatus = TestProgramState.Stopped;
OnTestStopped();
break;
}
TestStart = true;
MTKTestError TestResult = MTKTestError.Pending;
TestResult = RunTest(i);
if (TestResult != MTKTestError.NoError)
{
if (TestResult == MTKTestError.IgnoringDUT || TestResult == MTKTestError.ProgrammerNotConfigured && CyBLE_MTK.DUTsTestFlag[_CurrentDUT])
{
OnIgnoreDUT();
return(MTKTestError.IgnoringDUT);
}
else if (TestResult == MTKTestError.NotAllDevicesProgrammed)
{
return(MTKTestError.NotAllDevicesProgrammed);
}
else
{
if ((CurrentTestStatus != TestProgramState.Pausing) &&
(CurrentTestStatus != TestProgramState.Paused) &&
(CurrentTestStatus != TestProgramState.Pause) &&
(PauseTestsOnFailure == true))
{
CurrentTestStatus = TestProgramState.Pause;
}
OnOverallFail();
FailedOnce = true;
OnTestError(TestResult, TestResult.ToString());
}
}
if (CurrentTestStatus == TestProgramState.Pause)
{
CurrentTestStatus = TestProgramState.Paused;
Log.PrintLog(this, "Test program paused.", LogDetailLevel.LogRelevant);
OnTestPaused();
while (!PauseTestEvent.WaitOne(100))
{
;
}
if (CurrentTestStatus == TestProgramState.Stop)
{
StopTestProgram();
testRunning = false;
if (FailedOnce)
{
return(MTKTestError.TestFailed);
}
else
{
return(MTKTestError.NoError);
}
}
CurrentTestStatus = TestProgramState.Running;
}
///cysp: SetDUTOverallSFCSErrorCodeForUploadTestResult
SetDUTTmplSFCSErrorCode(_CurrentDUT, _CurrentTestIndex);
}
testRunning = false;
if (FailedOnce)
{
return(MTKTestError.TestFailed);
}
else
{
return(MTKTestError.NoError);
}
}
private bool CheckPorts(string TestType, out MTKTestError err)
{
bool ReturnValue = true, CheckDUTPort = false;
err = MTKTestError.NoError;
if ((TestType == "MTKTestTXP") || (TestType == "MTKTestTXPER") || (TestType == "MTKTestRXP") ||
(TestType == "MTKTestRXPER") || (TestType == "MTKTestTXCW") || (TestType == "MTKTestSTC"))
{
if (MTKSerialPort.IsOpen == false)
{
OnMTKPortOpen();
if (MTKSerialPort.IsOpen == false)
{
err = MTKTestError.MissingMTKSerialPort;
return(false);
}
}
CheckDUTPort = true;
}
if ((TestType == "MTKTestCUS") || (TestType == "MTKTestXOCalibration") || (TestType == "MTKTestProgramAll"))
{
CheckDUTPort = true;
}
if (TestType == "MTKTestAnritsu")
{
if (AnritsuSerialPort.IsOpen == false)
{
OnAnritsuPortOpen();
if (AnritsuSerialPort.IsOpen == false)
{
err = MTKTestError.MissingAnritsuSerialPort;
return(false);
}
}
CheckDUTPort = true;
}
if (CheckDUTPort)
{
if ((DUTSerialPort.IsOpen == false) && (DUTConnectionType == "UART"))
{
if (!_IgnoreDUT)
{
OnDUTPortOpen();
}
if ((DUTSerialPort.IsOpen == false) && (DUTConnectionType == "UART"))
{
if (_IgnoreDUT)
{
err = MTKTestError.IgnoringDUT;
}
else
{
err = MTKTestError.MissingDUTSerialPort;
}
return(false);
}
}
}
return(ReturnValue);
}
public override MTKTestError RunTest()
{
char[] DelimiterChars = { ',', '\n' };
string OuputACKNAC;
bool FailedOnce = false;
this.InitializeTestResult();
TestStatusUpdate(MTKTestMessageType.Information, "Applying offsets...");
this.Log.PrintLog(this, "Applying offsets.", LogDetailLevel.LogRelevant);
AnritsuPort.WriteLine("LEOPCFG " + TestScriptID.ToString() + ",AVGMNLIM," + OutputPowerOffset.ToString());
this.Log.PrintLog(this, "Setting offset: LEOPCFG " + TestScriptID.ToString() + ",AVGMNLIM," + OutputPowerOffset.ToString() + ": Done", LogDetailLevel.LogEverything);
Thread.Sleep(20);
AnritsuPort.DiscardInBuffer();
AnritsuPort.DiscardOutBuffer();
AnritsuPort.WriteLine("LEOPCFG? 4,AVGMNLIM");
Thread.Sleep(200);
string OffsetOutput = AnritsuPort.ReadExisting();
string[] OffsetOutputBroke = OffsetOutput.Split(DelimiterChars);
if (decimal.Parse(OffsetOutputBroke[2]) != OutputPowerOffset)
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
this.Log.PrintLog(this, "Cannot apply output power offset.", LogDetailLevel.LogRelevant);
return(MTKTestError.TestFailed);
}
AnritsuPort.WriteLine("LESSCFG " + TestScriptID.ToString() + ",TXPWR," + TXPowerOffset.ToString());
this.Log.PrintLog(this, "Setting offset: LESSCFG " + TestScriptID.ToString() + ",TXPWR," + TXPowerOffset.ToString() + ": Done", LogDetailLevel.LogEverything);
Thread.Sleep(20);
AnritsuPort.DiscardInBuffer();
AnritsuPort.DiscardOutBuffer();
AnritsuPort.WriteLine("LESSCFG? 4,TXPWR");
Thread.Sleep(200);
OffsetOutput = AnritsuPort.ReadExisting();
OffsetOutputBroke = OffsetOutput.Split(DelimiterChars);
if (decimal.Parse(OffsetOutputBroke[2]) != TXPowerOffset)
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
this.Log.PrintLog(this, "Cannot apply TX power offset.", LogDetailLevel.LogRelevant);
return(MTKTestError.TestFailed);
}
TestStatusUpdate(MTKTestMessageType.Information, "Running...");
this.Log.PrintLog(this, "Running Anritus test script.", LogDetailLevel.LogRelevant);
AnritsuPort.WriteLine("RUN");
int LoopCount = 0;
do
{
AnritsuPort.WriteLine("*INS?");
Thread.Sleep(100);
OuputACKNAC = AnritsuPort.ReadExisting();
LoopCount++;
} while ((OuputACKNAC != "R46\n") && (LoopCount < 150));
//Thread.Sleep(2000);
if (OuputACKNAC == "R46\n")
{
Log.PrintLog(this, "Getting result for: LEOP", LogDetailLevel.LogRelevant);
string TestOutput = GetResults("ORESULT TEST,0,LEOP");
string[] Output = TestOutput.Split(DelimiterChars);
if (Output[0] == "R46")
{
List <string> temp = Output.Cast <string>().ToList();
temp.Remove("R46");
Output = temp.ToArray();
}
if ((Output[0] == "RLEOP0") && (Output[1] == "TRUE"))
{
MTKTestResult TestResult1 = new MTKTestResult();
TestResult1.TestName = this.ToString() + " - LEOP0";
TestResult1.PassCriterion = "N/A";
TestResult1.Measured = "N/A";
TestResult1.Parameters = new string[] { "Packet Average Power", "Test Average Maximum",
"Test Average Minimum", "Overall Peak Power",
"Number of Failed Packets", "Number of Tested Packets" };
TestResult1.Value = new string[] { Output[2], Output[3], Output[4], Output[5], Output[6], Output[7] };
TestResult1.Result = Output[8];
TestResultUpdate(TestResult1);
Log.PrintLog(this, "Packet Average Power: " + Output[2] + "dBm", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Test Average Maximum: " + Output[3] + "dBm", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Test Average Minimum: " + Output[4] + "dBm", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Overall Peak Power: " + Output[5] + "dBm", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Number of Failed Packets: " + Output[6], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Number of Tested Packets: " + Output[7], LogDetailLevel.LogRelevant);
Log.PrintLog(this, "Result: " + Output[8], LogDetailLevel.LogRelevant);
if (Output[8] == "FAIL")
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
FailedOnce = true;
}
}
else
{
Log.PrintLog(this, "Invalid Test Result: " + TestOutput, LogDetailLevel.LogRelevant);
//TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
//this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
FailedOnce = true;
}
Log.PrintLog(this, "Getting result for: LEICD", LogDetailLevel.LogRelevant);
TestOutput = GetResults("ORESULT TEST,0,LEICD");
Output = TestOutput.Split(DelimiterChars);
if ((Output[0] == "RLEICD0") && (Output[1] == "TRUE"))
{
MTKTestResult TestResult1 = new MTKTestResult();
TestResult1.TestName = this.ToString() + " - LEICD0";
TestResult1.PassCriterion = "N/A";
TestResult1.Measured = "N/A";
TestResult1.Parameters = new string[] { "Average Fn", "Maximum Positive Fn", "Minimum Negative Fn",
"Drift Rate", "Average Drift", "Maximum Drift", "Packets Failed",
"Packets Tested" };
TestResult1.Value = new string[] { Output[2], Output[3], Output[4], Output[5],
Output[6], Output[7], Output[8], Output[9] };
TestResult1.Result = Output[10];
TestResultUpdate(TestResult1);
Log.PrintLog(this, "Average Fn: " + Output[2], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Maximum Positive Fn: " + Output[3], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Minimum Negative Fn: " + Output[4], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Drift Rate: " + Output[5], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Average Drift: " + Output[6], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Maximum Drift: " + Output[7], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Packets Failed: " + Output[8], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Packets Tested: " + Output[9], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Result: " + Output[10], LogDetailLevel.LogRelevant);
if (Output[10] == "FAIL")
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
FailedOnce = true;
}
}
else
{
Log.PrintLog(this, "Invalid Test Result: " + TestOutput, LogDetailLevel.LogRelevant);
//TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
//this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
FailedOnce = true;
}
Log.PrintLog(this, "Getting result for: LEMI", LogDetailLevel.LogRelevant);
TestOutput = GetResults("ORESULT TEST,0,LEMI");
Output = TestOutput.Split(DelimiterChars);
if ((Output[0] == "RLEMI0") && (Output[1] == "TRUE"))
{
MTKTestResult TestResult1 = new MTKTestResult();
TestResult1.TestName = this.ToString() + " - LEMI0";
TestResult1.PassCriterion = "N/A";
TestResult1.Measured = "N/A";
TestResult1.Parameters = new string[] { "Delta f1 max in Hz", "Delta f1 average in Hz", "Delta f2 max in Hz",
"Delta f2 average in Hz", "Delta f2avg/ delta f1avg", "F2 max Failed limit",
"F2 max count", "Packets failed", "Packets tested", "F2max % pass rate" };
TestResult1.Value = new string[] { Output[2], Output[3], Output[4], Output[5],
Output[6], Output[7], Output[8], Output[9], Output[10], Output[12] };
TestResult1.Result = Output[11];
TestResultUpdate(TestResult1);
Log.PrintLog(this, "Delta f1 max: " + Output[2] + "Hz", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Delta f1 average: " + Output[3] + "Hz", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Delta f2 max: " + Output[4] + "Hz", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Delta f2 average: " + Output[5] + "Hz", LogDetailLevel.LogEverything);
Log.PrintLog(this, "Delta f2 avg / delta f1 avg : " + Output[6], LogDetailLevel.LogEverything);
Log.PrintLog(this, "F2 max Failed limit: " + Output[7], LogDetailLevel.LogEverything);
Log.PrintLog(this, "F2 max count: " + Output[8], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Packets failed: " + Output[9], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Packets tested: " + Output[10], LogDetailLevel.LogEverything);
Log.PrintLog(this, "F2max % pass rate: " + Output[12], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Result: " + Output[11], LogDetailLevel.LogRelevant);
if (Output[11] == "FAIL")
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
FailedOnce = true;
}
}
else
{
Log.PrintLog(this, "Invalid Test Result: " + TestOutput, LogDetailLevel.LogRelevant);
//TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
//this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
FailedOnce = true;
}
Log.PrintLog(this, "Getting result for: LESS", LogDetailLevel.LogRelevant);
TestOutput = GetResults("ORESULT TEST,0,LESS");
Output = TestOutput.Split(DelimiterChars);
if ((Output[0] == "RLESS0") && (Output[1] == "TRUE"))
{
MTKTestResult TestResult1 = new MTKTestResult();
TestResult1.TestName = this.ToString() + " - LESS0";
TestResult1.PassCriterion = "N/A";
TestResult1.Measured = "N/A";
TestResult1.Parameters = new string[] { "Overall FER", "Total Frames Counted by DUT",
"Total Frames Sent by Tester" };
TestResult1.Value = new string[] { Output[2], Output[3], Output[4] };
TestResult1.Result = Output[5];
TestResultUpdate(TestResult1);
Log.PrintLog(this, "Overall FER: " + Output[2], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Total Frames Counted by DUT: " + Output[3], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Total Frames Sent by Tester: " + Output[4], LogDetailLevel.LogEverything);
Log.PrintLog(this, "Result: " + Output[5], LogDetailLevel.LogRelevant);
if (Output[5] == "FAIL")
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
FailedOnce = true;
}
}
else
{
Log.PrintLog(this, "Invalid Test Result: " + TestOutput, LogDetailLevel.LogRelevant);
//TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
//this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
FailedOnce = true;
}
}
else
{
Log.PrintLog(this, "Test Error: " + OuputACKNAC, LogDetailLevel.LogRelevant);
//TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
//this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
FailedOnce = true;
}
MTKTestError RetVal = MTKTestError.NoError;
if (FailedOnce)
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
RetVal = MTKTestError.TestFailed;
}
else
{
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
}
TestResult.Result = "N/A";
//TestResultUpdate(TestResult);
return(RetVal);
}
public override MTKTestError RunTest()
{
MTKTestError RetVal = MTKTestError.NoError;
bool FailedOnce = false;
this.InitializeTestResult();
if (!Programmer.RunI2CTest(I2CTests))
{
RetVal = MTKTestError.TestFailed;
FailedOnce = true;
}
else
{
RetVal = MTKTestError.NoError;
List <string> ResultParams = new List <string>();
List <string> ResultVal = new List <string>();
TestResult.Result = "PASS";
for (int i = 0; i < I2CTests.Count(); i++)
{
ResultParams.Add("Address#" + i.ToString());
ResultVal.Add(I2CTests[i].Address.ToString());
ResultParams.Add("Action#" + i.ToString());
string Temp1 = "NONE";
if (I2CTests[i].Action == MTKI2CTestType.Read)
{
Temp1 = "Read";
}
else if (I2CTests[i].Action == MTKI2CTestType.Write)
{
Temp1 = "Write";
}
ResultVal.Add(Temp1);
ResultParams.Add("Data#" + i.ToString());
StringBuilder hex = new StringBuilder(I2CTests[i].DataBuffer.Length * 2);
foreach (byte b in I2CTests[i].DataBuffer)
{
hex.AppendFormat("{0:x2}", b);
}
ResultVal.Add(hex.ToString().ToUpper());
if (I2CTests[i].ValidateRxData)
{
ResultParams.Add("Result#" + i.ToString());
if (I2CTests[i].DataBuffer.SequenceEqual(I2CTests[i].RxDataBuffer))
{
Log.PrintLog(this, "PASS", LogDetailLevel.LogEverything);
ResultVal.Add("PASS");
}
else
{
Log.PrintLog(this, "FAIL", LogDetailLevel.LogEverything);
FailedOnce = true;
RetVal = MTKTestError.TestFailed;
ResultVal.Add("FAIL");
TestResult.Result = "FAIL";
}
}
}
TestResult.Parameters = ResultParams.ToArray();
TestResult.Value = ResultVal.ToArray();
TestResultUpdate(TestResult);
}
if (FailedOnce)
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
}
else
{
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
}
return(RetVal);
}
private MTKTestError RunAllTests()
{
bool FailedOnce = false;
for (int i = 0; i < TestProgram.Count; i++)
{
_CurrentTestIndex = i;
if (CurrentTestStatus == TestProgramState.Stop)
{
CurrentTestStatus = TestProgramState.Stopping;
StopTestProgram();
CurrentTestStatus = TestProgramState.Stopped;
OnTestStopped();
break;
}
TestStart = true;
MTKTestError TestResult = RunTest(i);
if (TestResult != MTKTestError.NoError)
{
if (TestResult == MTKTestError.IgnoringDUT)
{
return(MTKTestError.IgnoringDUT);
}
else
{
if ((CurrentTestStatus != TestProgramState.Pausing) &&
(CurrentTestStatus != TestProgramState.Paused) &&
(CurrentTestStatus != TestProgramState.Pause) &&
(PauseTestsOnFailure == true))
{
CurrentTestStatus = TestProgramState.Pause;
}
OnOverallFail();
FailedOnce = true;
OnTestError(TestResult, TestResult.ToString());
}
}
if (CurrentTestStatus == TestProgramState.Pause)
{
CurrentTestStatus = TestProgramState.Paused;
Log.PrintLog(this, "Test program paused.", LogDetailLevel.LogRelevant);
OnTestPaused();
while (!PauseTestEvent.WaitOne(100))
{
;
}
if (CurrentTestStatus == TestProgramState.Stop)
{
StopTestProgram();
if (FailedOnce)
{
return(MTKTestError.TestFailed);
}
else
{
return(MTKTestError.NoError);
}
}
CurrentTestStatus = TestProgramState.Running;
}
}
if (FailedOnce)
{
return(MTKTestError.TestFailed);
}
else
{
return(MTKTestError.NoError);
}
}
public override MTKTestError RunTest()
{
MTKTestError RetVal = MTKTestError.NoError;
List <MTKTestError> mTKTestErrors = new List <MTKTestError>();
mTKTestErrors.Clear();
TempParameters.Clear();
TempValues.Clear();
stopwatch.Restart();
if (this.DUTConnectionMode == DUTConnMode.BLE)
{
RetVal = RunTestBLE();
}
else if (this.DUTConnectionMode == DUTConnMode.UART)
{
if (ChannelsNumber.Count > 1)
{
foreach (var Channel in ChannelsNumber)
{
ChannelNumber = Channel;
RetVal = RunTestUART();
mTKTestErrors.Add(RetVal);
}
}
else
{
RetVal = RunTestUART();
mTKTestErrors.Add(RetVal);
}
TestResult.Value = TempValues.ToArray();
TestResult.Parameters = TempParameters.ToArray();
}
else
{
stopwatch.Stop();
return(MTKTestError.NoConnectionModeSet);
}
foreach (var item in mTKTestErrors)
{
switch (item)
{
case MTKTestError.NoError:
if (MTKSerialPort.IsOpen)
{
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_ALL_PASS;
}
else
{
MTKTestTmplSFCSErrCode = ECCS.ERROR_CODE_CAUSED_BY_MTK_TESTER;
}
break;
case MTKTestError.ReceivedNAC:
break;
case MTKTestError.MissingDUT:
break;
case MTKTestError.TestFailed:
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_CyBLE_GetRSSI_TEST_FAIL;
TestStatusUpdate(MTKTestMessageType.Failure, "Fail");
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
TestResultUpdate(TestResult);
return(RetVal);
case MTKTestError.NoConnectionModeSet:
break;
case MTKTestError.MissingDUTSerialPort:
break;
case MTKTestError.MissingMTKSerialPort:
break;
case MTKTestError.UnknownError:
break;
case MTKTestError.MissingAnritsuSerialPort:
break;
case MTKTestError.IgnoringDUT:
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_DUT_NOT_TEST;
RetVal = MTKTestError.IgnoringDUT;
TestResult.Result = "IGNORE";
TestResultUpdate(TestResult);
return(RetVal);
case MTKTestError.NotAllDevicesProgrammed:
break;
case MTKTestError.ProgrammerNotConfigured:
break;
case MTKTestError.Pending:
break;
case MTKTestError.ProcessCheckFailure:
break;
default:
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_CUS_TEST_FAILURE_BUT_UNKNOWN;
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
TestResultUpdate(TestResult);
return(RetVal);
}
}
stopwatch.Stop();
this.Log.PrintLog(this, string.Format("Perform {0}: {1} secs", DisplayText, stopwatch.Elapsed.TotalMilliseconds / 1000), LogDetailLevel.LogRelevant);
TestResultUpdate(TestResult);
return(RetVal);
}
private MTKTestError RunTestUART()
{
int PercentageComplete = 0;
int TimeSlice = 100;
int TimeIncSteps = ((int)((double)PacketCount * 7.5) + 50) / TimeSlice;
int PercentIncSteps = 1;
MTKTestError CommandRetVal;
this.Log.PrintLog(this, GetDisplayText(), LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
//// Command #1
//string Command = "RRS";
//CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
//if (CommandRetVal != MTKTestError.NoError)
//{
// return CommandRetVal;
//}
//// Command #2
//Command = "RRS";
//CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
//if (CommandRetVal != MTKTestError.NoError)
//{
// return CommandRetVal;
//}
// Command #1
string Command = "RRS";
//Read Response
//no return if failure
//by cysp
int loops = CyBLE_MTK_Application.Properties.Settings.Default.STCTestRRSRetryInTheBeginning;
if (loops < 0)
{
loops = 0;
}
for (int i = 0; i < loops; i++)
{
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal == MTKTestError.NoError)
{
break; //break if SendCommand NoError by cysp
}
TestStatusUpdate(MTKTestMessageType.Information, "RRS Retry: " + (i + 1).ToString());
this.Log.PrintLog(this, "RRS Retry: " + (i + 1).ToString() + " | DelayPerCommand: " + DelayPerCommand.ToString(), LogDetailLevel.LogRelevant);
Thread.Sleep(200);
}
// end by cysp
// Command #3
Command = "STC " + this.PacketCount.ToString();
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
for (int i = 0; i < TimeSlice; i++)
{
PercentageComplete += PercentIncSteps;
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
Thread.Sleep(TimeIncSteps);
}
Thread.Sleep(500);
// Command #4
Command = "RRS";
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
if (CommandResult == "")
{
this.Log.PrintLog(this, Command + ": unable to find DUT.", LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Failure, "Error!!!");
return(MTKTestError.MissingDUT);
}
//TestResult.Result = CommandResult;
Thread.Sleep(500);
MTKTestError RetVal = MTKTestError.NoError;
TestResult.PassCriterion = PacketCount.ToString();
this.Log.PrintLog(this, "Expected Packet Count: " + PacketCount.ToString(), LogDetailLevel.LogEverything);
TestResult.Measured = CommandResult;
this.Log.PrintLog(this, "Packets transmitted: " + this.CommandResult, LogDetailLevel.LogEverything);
if (Int32.Parse(CommandResult) < PacketCount)
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
}
else
{
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
this.Log.PrintLog(this, "Result: PASS", LogDetailLevel.LogRelevant);
TestResult.Result = "PASS";
}
//// Command #5
//Command = "RRS";
//CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
//if (CommandRetVal != MTKTestError.NoError)
//{
// return CommandRetVal;
//}
return(RetVal);
}
private MTKTestError RunTestUART()
{
int PercentageComplete = 0;
int TimeSlice = 100;
//int TimeIncSteps = ((int)((double)PacketCount * 7.5) + 50) / TimeSlice;
int TimeIncSteps = ((int)((double)PacketCount * 0.2) + 0) / TimeSlice;
int PercentIncSteps = 1;
MTKTestError CommandRetVal = MTKTestError.UnknownError;
MTKTestError RetVal = MTKTestError.UnknownError;
this.Log.PrintLog(this, GetDisplayText(), LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
//// Command #1
//string Command = "RRS";
//CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
//if (CommandRetVal != MTKTestError.NoError)
//{
// return CommandRetVal;
//}
//// Command #2
//Command = "RRS";
//CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
//if (CommandRetVal != MTKTestError.NoError)
//{
// return CommandRetVal;
//}
// Command #1
string Command = "RRS";
//Read Response
//no return if failure
//by cysp
int loops = CyBLE_MTK_Application.Properties.Settings.Default.STCTestRRSRetryInTheBeginning;
if (loops < 0)
{
loops = 0;
}
for (int i = 0; i < loops; i++)
{
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal == MTKTestError.NoError)
{
break; //break if SendCommand NoError by cysp
}
TestStatusUpdate(MTKTestMessageType.Information, "RRS Retry: " + (i + 1).ToString());
this.Log.PrintLog(this, "RRS Retry: " + (i + 1).ToString() + " | DelayPerCommand: " + DelayPerCommand.ToString(), LogDetailLevel.LogRelevant);
Thread.Sleep(100);
}
// end by cysp
//ExecuteSTCCommand(Command, CommandRetVal, DUTSerialPort, DelayPerCommand, TimeSlice, TimeIncSteps, PercentageComplete, PercentIncSteps);
//ExecuteRRSCommand(Command, CommandRetVal, DUTSerialPort, DelayPerCommand);
// Command #3
Command = "STC " + (this.PacketCount).ToString();
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
Log.PrintLog(this, $"STC command sending on DUT ({DUTSerialPort}) failure due to {CommandRetVal}.", LogDetailLevel.LogRelevant);
return(CommandRetVal);
}
for (int i = 0; i < TimeSlice; i++)
{
PercentageComplete += PercentIncSteps;
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
Thread.Sleep(TimeIncSteps);
}
Thread.Sleep(400);
// Command #4
Command = "RRS";
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
else if (CommandResult == "")
{
this.Log.PrintLog(this, Command + ": unable to find DUT.", LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Failure, "Error!!!");
return(MTKTestError.MissingDUT);
}
else if (int.Parse(CommandResult) >= PacketCount)
{
RetVal = MTKTestError.NoError;
Log.PrintLog(this, $"STC Successful on DUT ({DUTSerialPort}): Actual received: {CommandResult} || Expected received: {PacketCount}", LogDetailLevel.LogRelevant);
}
else
{
for (int j = 1; j < 5; j++)
{
TimeIncSteps = ((int)((double)PacketCount * 0.5) + 0) / TimeSlice;
// Command #3
Command = "STC " + (this.PacketCount).ToString();
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
Log.PrintLog(this, $"STC command sending on DUT ({DUTSerialPort}) failure due to {CommandRetVal}.", LogDetailLevel.LogRelevant);
return(CommandRetVal);
}
TestStatusUpdate(MTKTestMessageType.Information, $"Retry#{j}");
Thread.Sleep(300);
for (int i = 0; i < TimeSlice; i++)
{
PercentageComplete = 0;
PercentageComplete += PercentIncSteps;
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
Thread.Sleep(TimeIncSteps * j + j);
}
// Command #4 2nd Retry
Command = "RRS";
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandResult == "")
{
RetVal = MTKTestError.TestFailed;
Log.PrintLog(this, $"STC Failure on DUT ({DUTSerialPort}): No Response from DUT", LogDetailLevel.LogRelevant);
}
else if (int.Parse(CommandResult) >= PacketCount)
{
break;
}
else
{
Log.PrintLog(this, $"STC Failure on DUT ({DUTSerialPort}): Actual received: {CommandResult} || Expected received: {PacketCount}", LogDetailLevel.LogRelevant);
}
}
if (CommandResult == "")
{
RetVal = MTKTestError.TestFailed;
Log.PrintLog(this, $"STC Failure on DUT ({DUTSerialPort}): No Response from DUT", LogDetailLevel.LogRelevant);
return(RetVal);
}
else if (int.Parse(CommandResult) >= PacketCount)
{
RetVal = MTKTestError.NoError;
Log.PrintLog(this, $"STC Successful on DUT ({DUTSerialPort}): Actual received: {CommandResult} || Expected received: {PacketCount}", LogDetailLevel.LogRelevant);
}
else
{
RetVal = MTKTestError.TestFailed;
Log.PrintLog(this, $"STC Failure on DUT ({DUTSerialPort}): Actual received: {CommandResult} || Expected received: {PacketCount}", LogDetailLevel.LogRelevant);
}
}
TestResult.PassCriterion = PacketCount.ToString();
this.Log.PrintLog(this, "Expected Packet Count: " + PacketCount.ToString(), LogDetailLevel.LogEverything);
TestResult.Measured = CommandResult;
this.Log.PrintLog(this, "Packets transmitted: " + this.CommandResult, LogDetailLevel.LogEverything);
if (!MTKSerialPort.IsOpen)
{
TestStatusUpdate(MTKTestMessageType.Information, "ERROR");
this.Log.PrintLog(this, "Result: ERROR due to Host Serial COM port is not open", LogDetailLevel.LogRelevant);
RetVal = MTKTestError.MissingMTKSerialPort;
TestResult.Result = "ERROR";
}
else if (Regex.IsMatch(CommandResult, @"^[+-]?\d*[.]?\d*$"))
{
if (Int32.Parse(CommandResult) >= PacketCount)
{
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
this.Log.PrintLog(this, "Result: PASS", LogDetailLevel.LogRelevant);
RetVal = MTKTestError.NoError;
TestResult.Result = "PASS";
}
else
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
this.Log.PrintLog(this, $"Result: FAIL (Actual: {CommandResult} Expect: {PacketCount})", LogDetailLevel.LogRelevant);
}
}
else
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
this.Log.PrintLog(this, $"Result: FAIL ({CommandResult})", LogDetailLevel.LogRelevant);
}
//// Command #5
//Command = "RRS";
//CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
//if (CommandRetVal != MTKTestError.NoError)
//{
// return CommandRetVal;
//}
return(RetVal);
}
private MTKTestError RunTestUART()
{
int PercentageComplete = 0;
int TimeSlice = 100, DelayPerCommand = 20;
int TimeIncSteps = ((int)((double)PacketCount * 7.5) + 50) / TimeSlice;
int PercentIncSteps = 1;
MTKTestError CommandRetVal;
this.Log.PrintLog(this, GetDisplayText(), LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
// Command #1
string Command = "RRS";
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
//Thread.Sleep(1000);
// Command #2
Command = "STC " + this.PacketCount.ToString();
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
for (int i = 0; i < TimeSlice; i++)
{
PercentageComplete += PercentIncSteps;
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
Thread.Sleep(TimeIncSteps);
}
// Command #2
Command = "RRS";
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
if (CommandResult == "")
{
this.Log.PrintLog(this, Command + ": unable to find DUT.", LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Failure, "Error!!!");
return(MTKTestError.MissingDUT);
}
//TestResult.Result = CommandResult;
Thread.Sleep(500);
MTKTestError RetVal = MTKTestError.NoError;
TestResult.PassCriterion = PacketCount.ToString();
this.Log.PrintLog(this, "Expected Packet Count: " + PacketCount.ToString(), LogDetailLevel.LogEverything);
TestResult.Measured = CommandResult;
this.Log.PrintLog(this, "Packets transmitted: " + this.CommandResult, LogDetailLevel.LogEverything);
if (Int32.Parse(CommandResult) < PacketCount)
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
}
else
{
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
this.Log.PrintLog(this, "Result: PASS", LogDetailLevel.LogRelevant);
TestResult.Result = "PASS";
}
return(RetVal);
}
public MTKTestError WriteBDA()
{
bool IsSuccess = false;
int hr;
string strError = "";
MTKTestError RetVal = MTKTestError.NoError;
this.InitializeTestResult();
if (UseProgrammer)
{
try
{
Log.PrintLog(this, "Programming BD Adress...", LogDetailLevel.LogRelevant);
//-1-. Connect to PP instance first
TestStatusUpdate(MTKTestMessageType.Information, "Connecting...");
//hr = ConnectToMiniProg3(out strError);
if (!BDAProgrammer.ConnectProgrammer())
{
//MessageBox.Show(strError, "MiniProg3 Initialization Failed!", MessageBoxButtons.OK, MessageBoxIcon.Error);
throw new SFlashException("MiniProg3 Initialization Failed!", "MiniProg3 Initialization Failed!");
}
//-2-. Acquire Part
TestStatusUpdate(MTKTestMessageType.Information, "Erasing...");
if (!BDAProgrammer.AcquireAndEraseSFlash())
{
throw new SFlashException("Acquire and erase failed!", "Acquire and erase failed!");
}
//-3-. Update all SFLASH Rows
TestStatusUpdate(MTKTestMessageType.Information, "Programming...");
hr = ProgramRow(0, out strError);
if (!SUCCEEDED(hr))
{
throw new SFlashException("SFlash update failed!", strError);
}
//-5-. Just in case try to release part (if it was acquired)
TestStatusUpdate(MTKTestMessageType.Information, "Disconnecting...");
BDAProgrammer.ReleaseChip(out strError);
//-6-. Disconnect from MiniProg3, so other apps can use it while it is IDLE
//DisconnectFromMiniProg3(out strError);
BDAProgrammer.DisconnectProgrammer();
Log.PrintLog(this, "PASS", LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
IsSuccess = true;
}
catch (SFlashException e)
{
BDAProgrammer.DisconnectProgrammer();
Log.PrintLog(this, e.errorMsg, LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
RetVal = MTKTestError.TestFailed;
}
}
else
{
int PercentageComplete = 0;
int DelayPerCommand = 20;//, msPerSecond = 1000;
MTKTestError CommandRetVal;
this.Log.PrintLog(this, GetDisplayText(), LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
// Command #1
string Command = "RRS";
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
// Command #2
//byte[] temp = { BDAddress[5], BDAddress[4], BDAddress[3], BDAddress[2], BDAddress[1], BDAddress[0] };
//Int32 temp1 = BitConverter.ToInt32(temp, 0);
//Int16 temp2 = BitConverter.ToInt16(temp, 4);
Command = "WBA " + BitConverter.ToString(BDAddress).Replace("-", " ");
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
Thread.Sleep(100);
// Command #3
Command = "RRS";
CommandRetVal = SendCommand(DUTSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
if (CommandResult == "")
{
this.Log.PrintLog(this, Command + ": unable to find DUT.", LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Failure, "Error!!!");
return(MTKTestError.MissingDUT);
}
if (CommandResult == "ERROR")
{
TestStatusUpdate(MTKTestMessageType.Failure, "FAIL");
RetVal = MTKTestError.TestFailed;
TestResult.Result = "FAIL";
this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
}
else if (CommandResult == "SUCCESS")
{
TestStatusUpdate(MTKTestMessageType.Success, "PASS");
this.Log.PrintLog(this, "Result: PASS", LogDetailLevel.LogRelevant);
TestResult.Result = "PASS";
IsSuccess = true;
}
}
if (AutoIncrementBDA && IsSuccess)
{
IncrementBDA();
}
return(RetVal);
}
private MTKTestError RunTestBLE()
{
int PercentageComplete = 0;
int DelayPerCommand = 20;
int TimeSlice = 100;
int TimeIncSteps = ((int)((double)PacketCount * 7.5) + 50) / TimeSlice;
int PercentIncSteps = 1;
MTKTestError CommandRetVal;
this.Log.PrintLog(this, GetDisplayText(), LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
// Command #1
CommandRetVal = SearchForDUT();
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
// Command #2
string Command = "DUT 1";
CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
// Command #3
Command = "STC " + this.PacketCount.ToString();
CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
// Command #4
Command = "DUT 0";
CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
// Command #5
Command = "DCW " + ((int)((double)PacketCount * 7.5) + 50).ToString();
CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
for (int i = 0; i < TimeSlice; i++)
{
PercentageComplete += PercentIncSteps;
TestStatusUpdate(MTKTestMessageType.Information, PercentageComplete.ToString() + "%");
Thread.Sleep(TimeIncSteps);
}
// Command #6
CommandRetVal = SearchForDUT();
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
// Command #7
Command = "DUT 1";
CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
// Command #8
Command = "PST";
CommandRetVal = SendCommand(MTKSerialPort, Command, 200);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
if (CommandResult == "")
{
this.Log.PrintLog(this, Command + ": unable to find DUT.", LogDetailLevel.LogRelevant);
TestStatusUpdate(MTKTestMessageType.Failure, "Error!!!");
return(MTKTestError.MissingDUT);
}
TestResult.Result = CommandResult;
this.Log.PrintLog(this, "Time elapsed (ms): " + this.CommandResult, LogDetailLevel.LogRelevant);
// Command #9
Command = "DUT 0";
CommandRetVal = SendCommand(MTKSerialPort, Command, DelayPerCommand);
if (CommandRetVal != MTKTestError.NoError)
{
return(CommandRetVal);
}
MTKTestError RetVal = MTKTestError.NoError;
if (Int32.Parse(CommandResult) < PacketCount)
{
TestStatusUpdate(MTKTestMessageType.Complete, "FAIL");
RetVal = MTKTestError.TestFailed;
this.Log.PrintLog(this, "Result: FAIL", LogDetailLevel.LogRelevant);
}
else
{
TestStatusUpdate(MTKTestMessageType.Complete, "PASS");
this.Log.PrintLog(this, "Result: PASS", LogDetailLevel.LogRelevant);
}
return(RetVal);
}
public override MTKTestError RunTest()
{
MTKTestError RetVal = MTKTestError.NoError;
this.InitializeTestResult();
TestResult.Measured = " Result: ";
if (this.DUTConnectionMode == DUTConnMode.BLE)
{
RetVal = RunTestBLE();
}
else if (this.DUTConnectionMode == DUTConnMode.UART)
{
int loop = SamplesCount;
if (overallpass_condition.ToUpper() == EnumPassConOverall.ONE_SAMPLE.ToString())
{
while (loop > 0)
{
RetVal = RunTestUART();
loop--;
if (DoesSamplePass(MTKInstruments.DUTCurrent) && RetVal == MTKTestError.Pending)
{
RetVal = MTKTestError.NoError;
break;
}
}
}
else
{
while (loop > 0)
{
RetVal = RunTestUART();
if (RetVal != MTKTestError.Pending)
{
RetVal = MTKTestError.TestFailed;
break;
}
loop--;
if (!DoesSamplePass(MTKInstruments.DUTCurrent))
{
RetVal = MTKTestError.TestFailed;
break;
}
else
{
TestStatusUpdate(MTKTestMessageType.Success, "Pass: "******"/" + SamplesCount.ToString());
RetVal = MTKTestError.NoError;
continue;
}
}
}
//Overall TestResult
if (RetVal == MTKTestError.NoError)
{
ERRORCODE_DUTCurrentMeasureFailure = ECCS.ERRORCODE_ALL_PASS;
TestStatusUpdate(MTKTestMessageType.Success, "Pass");
TestResult.Result = "Pass";
}
else
{
TestStatusUpdate(MTKTestMessageType.Failure, "Fail");
TestResult.Result = "FAIL";
}
Log.PrintLog(this, TestResult.Result + " : " + TestResult.Measured, LogDetailLevel.LogRelevant);
MTKTestTmplSFCSErrCode = ERRORCODE_DUTCurrentMeasureFailure;
}
else
{
TestStatusUpdate(MTKTestMessageType.Failure, "NoConnectionModeSet");
return(MTKTestError.NoConnectionModeSet);
}
TestResultUpdate(TestResult);
return(RetVal);
}
private bool ProgramAll()
{
int i;
bool return_value = true;
List <Thread> ProgDUT = new List <Thread>();
List <MTKTestError> ErrDUT = new List <MTKTestError>();
for (i = 0; i < NumberOfDUTs; i++)
{
DUTProgrammers[i].SelectedHEXFilePath = this.SelectedHEXFilePath;
if ((DUTProgrammers[i].SelectedProgrammer != "") &&
(DUTProgrammers[i].SelectedHEXFilePath != ""))
{
try
{
ErrDUT.Add(new MTKTestError());
ProgDUT.Add(new Thread(() => { ErrDUT[i] = ProgrammingThread(i); }));
DUTProgrammers[i].ProgrammerNumber = i;
DUTProgrammers[i].OnNumTestStatusUpdate -= new MTKPSoCProgrammer.NumTestStatusUpdateEventHandler(Ind_Prog_OnNumTestStatusUpdate);
DUTProgrammers[i].OnNumTestStatusUpdate += new MTKPSoCProgrammer.NumTestStatusUpdateEventHandler(Ind_Prog_OnNumTestStatusUpdate);
ProgDUT[i].Start();
Thread.Sleep(200);
}
catch
{
Log.PrintLog(this, "Cannot create programming thread.", LogDetailLevel.LogRelevant);
}
}
else
{
MTKTestError temp = new MTKTestError();
temp = MTKTestError.ProgrammerNotConfigured;
ErrDUT.Add(temp);
}
//ProgDUT[i].Join();
}
for (i = 0; i < ProgDUT.Count(); i++)
{
ProgDUT[i].Join();
}
TestResult.Measured = "";
for (i = 0; i < ErrDUT.Count(); i++)
{
if (i > 0)
{
TestResult.Measured += " | ";
}
if (ErrDUT[i] == MTKTestError.TestFailed)
{
TestResult.Measured += "DUT#" + (i + 1).ToString() + ": FAIL";
return_value = false;
//break;
}
else if (ErrDUT[i] == MTKTestError.NoError)
{
TestResult.Measured += "DUT#" + (i + 1).ToString() + ": PASS";
}
else
{
TestResult.Measured += "DUT#" + (i + 1).ToString() + ": " + ErrDUT[i].ToString();
}
}
OnProgramAllComplete(ErrDUT);
programCompleted = true;
return(return_value);
}
public override MTKTestError RunTest()
{
MTKTestError RetVal = MTKTestError.NoError;
this.InitializeTestResult();
//TmplSFCSErrCode = 0;
if (this.DUTConnectionMode == DUTConnMode.BLE)
{
RetVal = RunTestBLE();
}
else if (this.DUTConnectionMode == DUTConnMode.UART)
{
RetVal = RunTestUART();
}
else
{
return(MTKTestError.NoConnectionModeSet);
}
//if (TestResult.Result != "PASS" && TmplSFCSErrCode == 0)
if (TestResult.Result != "PASS")
{
switch (CustomCommand)
{
case CUSTOM_CMD_READ_GPIO:
TmplSFCSErrCode = (ECCS.ERRORCODE_GPIO_CONTINUITY_TEST_FAIL);
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_GPIO_CONTINUITY_TEST_FAIL;
break;
case CUSTOM_CMD_READ_OPEN_GPIO:
TmplSFCSErrCode = (ECCS.ERRORCODE_GPIO_OPENSHORTS_TEST_FAIL);
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_GPIO_OPENSHORTS_TEST_FAIL;
break;
case CUSTOM_CMD_READ_UNIQUE_ID:
TmplSFCSErrCode = (ECCS.ERRORCODE_SILICON_UNIQUENUMBER_TEST_FAIL);
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_SILICON_UNIQUENUMBER_TEST_FAIL;
break;
//case CUSTOM_CMD_READ_MFIID:
// TmplSFCSErrCode = ECCS.ERROR_CODE_READ_MFIID;
// break;
//case CUSTOM_CMD_READ_FW_VERSION:
// TmplSFCSErrCode = SFCS.ERROR_CODE_FW_VERSION;
// break;
//case CUSTOM_CMD_READ_HOMEKIT_SELFTEST_RESULT:
// TmplSFCSErrCode = SFCS.ERROR_CODE_APPLE_AUTO_CHIP;
// break;
}
}
else
{
MTKTestTmplSFCSErrCode = ECCS.ERRORCODE_ALL_PASS;
}
TestResultUpdate(TestResult);
return(RetVal);
}
