466 lines
20 KiB
C#
466 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using log4net;
|
|
using TBF.BenchControl;
|
|
using TBF.Boxes;
|
|
using TBF.Resources;
|
|
using TBF.UiBridge;
|
|
|
|
namespace TBF.BenchControl.TestMethods.FlyingStartCollectionMethod
|
|
{
|
|
public class FlyingStartCollectionMethodSeq : Sequences.SequenceBase
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(FlyingStartCollectionMethodSeq));
|
|
|
|
/// <summary>
|
|
/// Flying start mass collection method sequence
|
|
/// </summary>
|
|
/// <param name="test">Test entity</param>
|
|
/// <returns>
|
|
/// Event.Done . . . . . . . OK
|
|
/// Event.UiCmdStop . . . . Stopped by the user using the on-screen button STOP
|
|
/// Event.OpArgumentError . Target flow is out of range
|
|
/// Event.Error . . . . . . Unspecified error
|
|
/// </returns>
|
|
public IList<Event> Execute(Entities.Test test)
|
|
{
|
|
Elde.ControlBoardDev cBrd = StateMachine.ControlBoard;
|
|
|
|
IList<Event> e = new List<Event>(); /// Events from currently running operations
|
|
Event retVal = Event.Done;
|
|
checkUiOp = new Operations.CheckUIOp(true); /// Runs in more then one state
|
|
|
|
ltrPerRefPulse = outPath.FlowMeter.LtrPerPulse; /// [ltr/pulse], nominal flow in [m3/h]
|
|
|
|
/// Notes:
|
|
/// float timeHr = volumeLtr / (1000.0f * targetFlow);
|
|
/// float timeSec = 3600.0f * timeHr;
|
|
/// int refPulses = (int)(timeSec * (2000.0f * targetFlow / pOut.FlowMeter.NominalFlow));
|
|
int totalPulses = (int)(test.Volume / ltrPerRefPulse + 0.5f);
|
|
|
|
processDataLoggingOp = new TBF.BenchControl.Operations.ProcessDataLoggingOp(processDataLogger, this);
|
|
|
|
int repetitionNr = 1; /// First test: repetitionNr=1
|
|
|
|
//====================================
|
|
// Transition or SetRoute - Start
|
|
//====================================
|
|
switch (Transition(transitionStart, TransitionContext.TestStart))
|
|
{
|
|
case Event.Error: { retVal = Event.Error; goto stopTest; }
|
|
case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
|
|
//====================================
|
|
loop:
|
|
/// Start the test, initialize test results
|
|
Bridge.OnTestSelected(this, new TestSelectedEventArgs(test, repetitionNr, inPath, benchPath, outPath, sensPath, totalPulses));
|
|
Entities.TestResult tstRslt = new Entities.TestResult(test, repetitionNr, Entities.MetersKind.Single);
|
|
|
|
|
|
int flowSetTime0 = StateMachine.Time;
|
|
float estFlowSetTime = 10.0f;
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Setting_the_flow);
|
|
//------------------------------------------------
|
|
if (inPath.Pump is GenericDevices.IPumpFM) (inPath.Pump as GenericDevices.IPumpFM).TurnOn(test.PumpPower);
|
|
|
|
State.Create("FlyingStartCollectionMethod : Starting the pump")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(new Operations.TimerOp(5))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
|
|
int flowSetTime = StateMachine.Time - flowSetTime0;
|
|
float progress = Formulas.TestProgress(flowSetTime, estFlowSetTime, test.TstTime);
|
|
Bridge.OnTestProgress(this, GetTestProgressData(test, tstRslt, false, cBrd, flowSetTime, progress));
|
|
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.TimerExpired));
|
|
|
|
|
|
State.Create("FlyingStartCollectionMethod : Starting the pump")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(cBrd.SetValvesOp(inPath.Pump, null))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
|
|
int flowSetTime = StateMachine.Time - flowSetTime0;
|
|
float progress = Formulas.TestProgress(flowSetTime, estFlowSetTime, test.TstTime);
|
|
Bridge.OnTestProgress(this, GetTestProgressData(test, tstRslt, false, cBrd, flowSetTime, progress));
|
|
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.ValvesSet));
|
|
|
|
|
|
if (!test.Emptying) /// If condition met => skip measuring and force emptying
|
|
{
|
|
///
|
|
/// Measure the weight and skip emptying if there is enough room in the tank
|
|
///
|
|
State.Create("FlyingStartCollectionMethod : Measuring the mass of water in the tank")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(outPath.Balance.ReadMassOp(ref mass))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.BalanceDone));
|
|
|
|
float estimatedEndMass = mass.Val + test.Volume;
|
|
if (estimatedEndMass < outPath.Balance.Capacity * Constants.TankFullFactor)
|
|
{
|
|
goto set_flow; /// Enough room in the tank -> skip emptying
|
|
}
|
|
}
|
|
|
|
///
|
|
/// Empty the water tank
|
|
///
|
|
switch (EmptyTheTank(outPath.EmptyTankValve, outPath.Balance))
|
|
{
|
|
case Event.Error: { retVal = Event.Error; goto stopTest; }
|
|
case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
|
|
set_flow:
|
|
|
|
//--------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Setting the flow")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(outPath.RegulValve.SetFlowOp(outPath.FlowMeter, test.Qfrom, test.Qto, outPath.PidCoef, refFlow, 600)) /// timeout = 10 min.
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
|
|
int flowSetTime = StateMachine.Time - flowSetTime0;
|
|
float progress = Formulas.TestProgress(flowSetTime, estFlowSetTime, test.TstTime);
|
|
Bridge.OnTestProgress(this, GetTestProgressData(test, tstRslt, false, cBrd, flowSetTime, progress));
|
|
|
|
if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
if (e.Contains(Event.RegulValveTimeOut))
|
|
{
|
|
Bridge.OnError(this, Strings.Timeout);
|
|
retVal = Event.Done;
|
|
goto stopTest;
|
|
}
|
|
if (e.Contains(Event.Next)) goto flow_set;
|
|
}
|
|
while (!e.Contains(Event.FlowReached));
|
|
|
|
flow_set:
|
|
int time = StateMachine.Time;
|
|
float currentFlow = refFlow.Val;
|
|
|
|
/// Extract cameras from the current sensors path, add operations to the detection state
|
|
IList<IOperation> measureOperations = new List<IOperation>();
|
|
for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
|
|
{
|
|
GenericDevices.ICameraRoi cameraRoi = sensPath.RegisterReaders[i] as GenericDevices.ICameraRoi;
|
|
if (cameraRoi != null) measureOperations.Add(cameraRoi.MeasureOp());
|
|
}
|
|
|
|
LogProcessHeader(processDataLogger, "Start mass");
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Measuring_the_weight);
|
|
//------------------------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Measuring the start mass")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(benchPath.TempIn.ReadTempOp(ref tempIn))
|
|
.AddOperation(benchPath.TempOut.ReadTempOp(ref tempOut))
|
|
.AddOperation(outPath.TempDiv.ReadTempOp(ref tempDiv))
|
|
.AddOperation(benchPath.PressIn.ReadPressureOp(ref pressIn))
|
|
.AddOperation(benchPath.PressOut.ReadPressureOp(ref pressOut))
|
|
.AddOperation((StateMachine.Ambient != null)
|
|
? StateMachine.Ambient.ReadAmbientOp(airTemperature, airPressure, airHumidity) : null)
|
|
.AddOperations(measureOperations)
|
|
.AddOperation(outPath.Balance.ReadStableMassOp(ref startMass, 5))
|
|
.AddOperation(cBrd.UpdateTankWeightOp())
|
|
.AddOperation(processDataLoggingOp)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.BalanceDone));
|
|
|
|
LogProcessHeader(processDataLogger, "Measurement");
|
|
|
|
tstRslt.TimeStart = DateTime.Now;
|
|
tstRslt.MassStartRaw = startMass.Val;
|
|
mass.Val = startMass.Val;
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Test_in_progress);
|
|
//------------------------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Starting the test")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(measureOperations)
|
|
.AddOperation(cBrd.StartMeasurementOp(outPath.FlowMeter, totalPulses, Elde.TestMethods.Diverter | Elde.TestMethods.Synchro, (float)test.TolerRed))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.MeasurementStarted));
|
|
|
|
/// Measurement loop - preparation
|
|
readRegisters1 = new Operations.ReadMoreRegistersOp(sensPath.RegisterReaders, ref WMPulses, ref WMRefPulses);
|
|
readRegisters2 = new Operations.ReadMoreRegistersOp(sensPath.RegisterReaders, ref WMPulses, ref WMRefPulses);
|
|
queryEnd1 = cBrd.QueryMeasurementEndOp();
|
|
queryEnd2 = cBrd.QueryMeasurementEndOp();
|
|
|
|
bool firstTime = true; /// To reset sums for averaging
|
|
ResetAveragedData();
|
|
int estimtdEndTime = StateMachine.Time + (int)tstRslt.TstTime;
|
|
|
|
/// Measurement loop - begin
|
|
while (true)
|
|
{
|
|
//--------------------------------
|
|
switch (ReadRegistersTempPressAmbient(measureOperations, true))
|
|
{
|
|
case Event.Error: { retVal = Event.Error; goto stopTest; }
|
|
case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
|
|
case Event.MeasurementCompleted: goto test_completed;
|
|
}
|
|
|
|
int remainingTime = Math.Max(estimtdEndTime - StateMachine.Time, 0);
|
|
Bridge.OnActivity(this, string.Format("{0} ... {1} s", Strings.Test_in_progress, remainingTime));
|
|
|
|
if (firstTime)
|
|
{
|
|
firstTime = false; /// Do the following only once
|
|
tstRslt.TempInStart = tempIn.Val;
|
|
tstRslt.TempOutStart = tempOut.Val;
|
|
tstRslt.TempDivStart = tempDiv.Val;
|
|
tstRslt.PressInStart = pressIn.Val;
|
|
tstRslt.PressOutStart = pressOut.Val;
|
|
}
|
|
|
|
tstRslt.TempInEnd = tempIn.Val;
|
|
tstRslt.TempOutEnd = tempOut.Val;
|
|
tstRslt.TempDivEnd = tempDiv.Val;
|
|
tstRslt.PressInEnd = pressIn.Val;
|
|
tstRslt.PressOutEnd = pressOut.Val;
|
|
tstRslt.MassEndRaw = mass.Val;
|
|
|
|
AccumulateAveragedData();
|
|
|
|
refFreq.Val = cBrd.ReferenceFreq;
|
|
refFlow.Val = cBrd.ReferenceFlow;
|
|
tstRslt.AmbientTempAve = airTemperature.Val;
|
|
tstRslt.AmbientPressAve = airPressure.Val;
|
|
tstRslt.AmbientHumiAve = airHumidity.Val;
|
|
|
|
string logstr = string.Format("E={0} f={1} q={2}", cBrd.EtPulses(0), cBrd.ReferenceFreq,
|
|
cBrd.ReferenceFlow * outPath.FlowMeter.NominalFlow);
|
|
for (int i = 0; i < Program.WMsCount; i++)
|
|
{
|
|
logstr += string.Format(" M{0}=({1},{2})", i + 1, WMRefPulses[i], WMPulses[i]);
|
|
}
|
|
log.Debug(logstr);
|
|
|
|
|
|
float progress = Formulas.TestProgress(cBrd.EtPulses(0), totalPulses, estFlowSetTime, test.TstTime);
|
|
Bridge.OnTestProgress(this, GetTestProgressData(test, tstRslt, true, cBrd, cBrd.TTime, progress));
|
|
}
|
|
/// Measurement loop - end
|
|
|
|
test_completed:
|
|
State.Create("FlyingStartCollectionMethod : Waiting before mass measurement")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(benchPath.TempIn.ReadTempOp(ref tempIn))
|
|
.AddOperation(benchPath.TempOut.ReadTempOp(ref tempOut))
|
|
.AddOperation(outPath.TempDiv.ReadTempOp(ref tempDiv))
|
|
.AddOperation(benchPath.PressIn.ReadPressureOp(ref pressIn))
|
|
.AddOperation(benchPath.PressOut.ReadPressureOp(ref pressOut))
|
|
.AddOperation(readRegisters1)
|
|
.AddOperation((StateMachine.Ambient != null)
|
|
? StateMachine.Ambient.ReadAmbientOp(airTemperature, airPressure, airHumidity) : null)
|
|
.AddOperation(outPath.Balance.ReadMassOp(ref mass))
|
|
.AddOperation(cBrd.UpdateTankWeightOp())
|
|
.AddOperation(processDataLoggingOp)
|
|
.AddOperation(new Operations.TimerOp(test.Time2MassMsrmt))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.TimerExpired));
|
|
|
|
LogProcessHeader(processDataLogger, "End mass");
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Measuring_the_weight);
|
|
//------------------------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Measuring the end mass")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(benchPath.TempIn.ReadTempOp(ref tempIn))
|
|
.AddOperation(benchPath.TempOut.ReadTempOp(ref tempOut))
|
|
.AddOperation(outPath.TempDiv.ReadTempOp(ref tempDiv))
|
|
.AddOperation(benchPath.PressIn.ReadPressureOp(ref pressIn))
|
|
.AddOperation(benchPath.PressOut.ReadPressureOp(ref pressOut))
|
|
.AddOperation(readRegisters1)
|
|
.AddOperation((StateMachine.Ambient != null)
|
|
? StateMachine.Ambient.ReadAmbientOp(airTemperature, airPressure, airHumidity) : null)
|
|
.AddOperation(outPath.Balance.ReadStableMassOp(ref endMass, 5))
|
|
.AddOperation(cBrd.UpdateTankWeightOp())
|
|
.AddOperation(processDataLoggingOp)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.BalanceDone));
|
|
///
|
|
tstRslt.MassEndRaw = endMass.Val;
|
|
tstRslt.TimeEnd = DateTime.Now;
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Test_completed);
|
|
//------------------------------------------------
|
|
|
|
/// Make sure the CycleBeginForm is closed so that water meter data (s/n) can be copied into results
|
|
if (cycleBeginFormOpened)
|
|
{
|
|
cycleBeginFormOpened = false;
|
|
if (CloseCycleBeginForm()) goto stopTest;
|
|
}
|
|
|
|
///
|
|
/// Populate TestResult data entity with data
|
|
///
|
|
UpdateTestRsltWithAveragedData(tstRslt);
|
|
|
|
tstRslt.BatchNr = Program.LocalSettings.BatchNr;
|
|
tstRslt.MassStart = Formulas.CorrectedValue(tstRslt.MassStartRaw, outPath.Balance.Corrections);
|
|
tstRslt.MassEnd = Formulas.CorrectedValue(tstRslt.MassEndRaw, outPath.Balance.Corrections);
|
|
tstRslt.MassDiff = tstRslt.MassEnd - tstRslt.MassStart;
|
|
tstRslt.DensityIn = Formulas.WaterDensityFromTemp(tstRslt.TempInAvrg); /// [kg/m3]
|
|
tstRslt.DensityOut = Formulas.WaterDensityFromTemp(tstRslt.TempOutAvrg); /// [kg/m3]
|
|
tstRslt.DensityDiv = Formulas.WaterDensityFromTemp(tstRslt.TempDivAvrg); /// [kg/m3]
|
|
tstRslt.Time = cBrd.TTime; /// [s] measurement time
|
|
tstRslt.FlowMass = 3600.0f * tstRslt.MassDiff / tstRslt.Time; /// [kg/h]
|
|
tstRslt.FlowVolume = 3600.0f * ltrPerRefPulse * cBrd.EtPulses(0) / tstRslt.Time; /// [l/h]
|
|
tstRslt.VolumeCTV = 1.00103f * 1000.0f * tstRslt.MassDiff / tstRslt.DensityOut; /// [l] 1000.0f is because density is in [kg/m3]
|
|
tstRslt.VolumeMaster = ltrPerRefPulse * cBrd.EtPulses(0); /// [l] volume from the master flow meter
|
|
tstRslt.PulsesMaster = cBrd.EtPulses(0); /// Pulses of the master flow meter (test total)
|
|
tstRslt.ConstMaster = ltrPerRefPulse * tstRslt.VolumeCTV / tstRslt.VolumeMaster; /// Corrected master pulses per liter
|
|
|
|
if (tstRslt.VolumeCTV <= float.Epsilon)
|
|
{
|
|
tstRslt.ErrorMaster = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
tstRslt.ErrorMaster = 100 * (tstRslt.VolumeMaster - tstRslt.VolumeCTV) / tstRslt.VolumeCTV;
|
|
}
|
|
tstRslt.TimeDivStart0 = 0;
|
|
tstRslt.TimeDivStart1 = 0;
|
|
tstRslt.TimeDivStart2 = 0;
|
|
tstRslt.TimeDivStart3 = 0;
|
|
tstRslt.TimeDivStart4 = 0;
|
|
tstRslt.TimeDivStart5 = 0;
|
|
tstRslt.TimeDivEnd0 = 0;
|
|
tstRslt.TimeDivEnd1 = 0;
|
|
tstRslt.TimeDivEnd2 = 0;
|
|
tstRslt.TimeDivEnd3 = 0;
|
|
tstRslt.TimeDivEnd4 = 0;
|
|
tstRslt.TimeDivEnd5 = 0;
|
|
for (int i = 0; i < Program.WMsCount; i++)
|
|
{
|
|
if (sensPath.RegisterReaders[i] != null)
|
|
{
|
|
tstRslt.Meters[i].SerialNr = (WaterMeters.Count > i) ? WaterMeters[i].SerialNr : string.Empty;
|
|
tstRslt.Meters[i].VolumeStart = 0; /// liter
|
|
tstRslt.Meters[i].VolumeEnd = 0; /// liter
|
|
if (sensPath.RegisterReaders[i].PulsesPerLtr <= float.Epsilon) tstRslt.Meters[i].VolumeMeter = 0;
|
|
else tstRslt.Meters[i].VolumeMeter = Convert.ToSingle(WMPulses[i]) / sensPath.RegisterReaders[i].PulsesPerLtr;
|
|
tstRslt.Meters[i].VolumeRef = tstRslt.ConstMaster * WMRefPulses[i]; /// liter
|
|
tstRslt.Meters[i].PulsesMeter = WMPulses[i];
|
|
tstRslt.Meters[i].PulsesMaster = WMRefPulses[i];
|
|
tstRslt.Meters[i].Time = cBrd.TTime;
|
|
if (WMPulses[i] > 0 && tstRslt.Meters[i].VolumeRef > 0)
|
|
{
|
|
tstRslt.Meters[i].VolumeErrorPct =
|
|
100 * (tstRslt.Meters[i].VolumeMeter - tstRslt.Meters[i].VolumeRef) / tstRslt.Meters[i].VolumeRef;
|
|
/// %
|
|
}
|
|
else
|
|
{
|
|
tstRslt.Meters[i].VolumeErrorPct = -100;
|
|
}
|
|
tstRslt.Meters[i].Passed = (tstRslt.ErrLimLo <= tstRslt.Meters[i].VolumeErrorPct) && (tstRslt.Meters[i].VolumeErrorPct <= tstRslt.ErrLimHi);
|
|
}
|
|
}
|
|
/// Add data - end
|
|
|
|
AddOrOverwriteResult(tstRslt);
|
|
|
|
Bridge.OnTestCompleted(this, new TestCompletedEventArgs(tstRslt));
|
|
|
|
/// Append the results to the CSV-file
|
|
allResults.Info(TestResult2CsvLine(tstRslt));
|
|
|
|
|
|
if (++repetitionNr <= test.Repeats)
|
|
{
|
|
goto loop;
|
|
}
|
|
|
|
stopTest:
|
|
|
|
///----------------------///
|
|
/// Quit this sequence ///
|
|
///----------------------///
|
|
|
|
State.Create("FlyingStartCollectionMethod : Stopping diverter, gate, etc.")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(cBrd.StopPreviousOp())
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.PreviousStopped));
|
|
|
|
/// Transition sequence at the end of test
|
|
/// Prevent overwriting 'retVal' in case it was set to non-default value earlier
|
|
switch (Transition(transitionStop, TransitionContext.TestEnd))
|
|
{
|
|
case Event.Error: { if (retVal == Event.Done) retVal = Event.Error; break; }
|
|
case Event.UiCmdStop: { if (retVal == Event.Done) retVal = Event.UiCmdStop; break; }
|
|
}
|
|
|
|
/// Create a list with one item 'retVal' (default is Event.Done) and return it
|
|
IList<Event> retList = new List<Event>(1);
|
|
retList.Add(retVal);
|
|
return retList;
|
|
}
|
|
}
|
|
}
|