2f6f24e281
- new component with VZ15 and modified position of VZ13 - fixed start method evaluation OK - handling of entry forms cleaned-up
736 lines
32 KiB
C#
736 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using log4net;
|
|
using TBF.UiBridge;
|
|
using TBF.BenchControl.Operations;
|
|
using TBF.BenchControl.GenericDevices;
|
|
using TBF.Boxes;
|
|
using TBF.Resources;
|
|
|
|
namespace TBF.BenchControl.Sequences
|
|
{
|
|
public class MainSeq : SequenceBase, ISequence
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(MainSeq));
|
|
private static readonly ILog allResults = LogManager.GetLogger("AllResults");
|
|
private static readonly ILog summaryResults = LogManager.GetLogger("SummaryResults");
|
|
|
|
public override string ToString() { return "Sequences.MainSeq"; }
|
|
|
|
|
|
/// <summary> Constructor </summary>
|
|
public MainSeq()
|
|
{
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Main sequence
|
|
/// </summary>
|
|
/// <param name="dummyArg"></param>
|
|
/// <returns></returns>
|
|
public IList<Event> Execute(Entities.Test dummyArg)
|
|
{
|
|
/// Operations running in more then one state
|
|
checkUiOp = new CheckUIOp(true);
|
|
|
|
IList<Event> e;
|
|
Selection selection;
|
|
bool benchFilled = false;
|
|
|
|
StateMachine.LoadProcedure(true); // TODO: Implement as an operation so that the worker thread is not blocked
|
|
|
|
Bridge.Bench2UI(ButtonsEtc.StopBtnEn);
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Measuring_the_weight);
|
|
//------------------------------------------------
|
|
State.Create("MainSeq : Setting valves to the default state")
|
|
.AddOperation(new MettlerToledo.ReadMassesOp())
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(StateMachine.DefaultValvesOpen,
|
|
StateMachine.DefaultValvesClose))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
while (!(e.Contains(Event.ValvesSet) && e.Contains(Event.BalanceDone)));
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Starting_the_cameras);
|
|
//------------------------------------------------
|
|
State startNew = State.Create("MainSeq : Starting the cameras")
|
|
.AddOperation(checkUiOp);
|
|
foreach (var cmpnt in StateMachine.Components)
|
|
{
|
|
Cameras.IdcCamera.IdcCamera camera = cmpnt as Cameras.IdcCamera.IdcCamera;
|
|
if ((camera != null) && (camera.Cfg.DebugLevel != Entities.DebugMode.DetectedOff))
|
|
{
|
|
startNew.AddOperation(camera.StartNewOp());
|
|
}
|
|
}
|
|
startNew.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
while (e.Contains(Event.CameraBusy));
|
|
|
|
if (e.Contains(Event.CameraOpFailed)) goto error; /// TODO: resolve in some other way
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
select_procedure:
|
|
selection = MakeSelection(MKSelContext.ProcedureNotSelected);
|
|
|
|
//--------------------------------
|
|
Bridge.Bench2UI(ButtonsEtc.StopBtnEn);
|
|
StateMachine.LoadProcedure(false);
|
|
if (StateMachine.Procedure == null) goto select_procedure;
|
|
|
|
StateMachine.LoadProcedureParams(StateMachine.Procedure);
|
|
ResetResults();
|
|
Bridge.OnProcedureSelected(this, new ProcedureSelectedEventArgs(StateMachine.Procedure));
|
|
|
|
|
|
/// Find purge suquences
|
|
Entities.TransitionSequence purgeBegin = null;
|
|
Entities.TransitionSequence purgeEnd = null;
|
|
foreach (var transition in StateMachine.TransitionSequences)
|
|
{
|
|
if (transition.Name == StateMachine.Procedure.TransitionStart) purgeBegin = transition;
|
|
if (transition.Name == StateMachine.Procedure.TransitionEnd) purgeEnd = transition;
|
|
}
|
|
|
|
|
|
if (selection == Selection.Q1 || selection == Selection.Q2 ||
|
|
selection == Selection.Q3 || selection == Selection.Test)
|
|
{
|
|
goto assume_bench_filled;
|
|
}
|
|
else if (selection == Selection.Cycle && benchFilled)
|
|
{
|
|
//--------------------------------
|
|
State.Create("MainSeq : Answer a question")
|
|
.AddOperation(new Operations.AskYesNoOp(Strings.Fill_with_water))
|
|
.AddOperation(checkUiOp)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.No)) goto assume_bench_filled;
|
|
if (e.Contains(Event.UiCmdStop)) goto select_procedure;
|
|
}
|
|
while (!e.Contains(Event.Yes));
|
|
}
|
|
|
|
fill_the_bench:
|
|
|
|
/// Purge - Begin
|
|
switch (Transition(purgeBegin, TransitionContext.PurgeBegin))
|
|
{
|
|
case Event.Error: goto error;
|
|
case Event.UiCmdStop: goto stop;
|
|
}
|
|
|
|
//--------------------------------
|
|
GenericDevices.IDataEntry dataEntryCmpnt =
|
|
TbfComponents.FindComponent(StateMachine.Procedure.DataEntry) as GenericDevices.IDataEntry;
|
|
if (dataEntryCmpnt is IHasCycleBeginForm)
|
|
{
|
|
Bridge.OnActivity(this, "Enter the water meter data");
|
|
State.Create("MainSeq : Enter begin data")
|
|
.AddPermanentOperation((dataEntryCmpnt as IHasCycleBeginForm).ShowCycleBeginFormOp(WaterMeters))
|
|
.AddOperation(checkUiOp)
|
|
.EnterState();
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
|
|
assume_bench_filled:
|
|
|
|
benchFilled = true;
|
|
Bridge.Bench2UI(ButtonsEtc.ShowBenchFilled);
|
|
|
|
if (selection != Selection.PurgeBegin)
|
|
{
|
|
goto cycle_or_test_selected;
|
|
}
|
|
|
|
select_cycle_or_test:
|
|
//----------------------------------------------------------
|
|
selection = MakeSelection(MKSelContext.InsideProcedure);
|
|
///
|
|
if (selection == Selection.PurgeBegin) goto fill_the_bench;
|
|
if (selection == Selection.PurgeEnd) goto purge_end;
|
|
if (selection == Selection.SaveResults) goto save_results;
|
|
|
|
cycle_or_test_selected:
|
|
|
|
Bridge.Bench2UI(ButtonsEtc.StopBtnEn); /// Hide buttons
|
|
|
|
if (selection == Selection.Cycle)
|
|
{
|
|
TimeEstimateTotal = 0;
|
|
foreach (var test in StateMachine.Tests)
|
|
{
|
|
TimeEstimateTotal += (test.Repeats * (test.TstTime + 10.0f));
|
|
|
|
/// Try to fetch all test paths and transitions
|
|
/// to detect configuration errors as early as possible.
|
|
if (!StateMachine.GetPaths(test, out inPath, out benchPath,
|
|
out outPath, out sensPath,
|
|
out transitionStart, out transitionStop))
|
|
{
|
|
goto config_error;
|
|
}
|
|
}
|
|
|
|
TimeEstimateBeginRpts = 0;
|
|
foreach (var test in StateMachine.Tests)
|
|
{
|
|
/// Fetch the test paths and transitions
|
|
if (!StateMachine.GetPaths(test, out inPath, out benchPath,
|
|
out outPath, out sensPath,
|
|
out transitionStart, out transitionStop))
|
|
{
|
|
goto config_error;
|
|
}
|
|
|
|
TimeEstimateOneTest = test.TstTime + 10.0f;
|
|
//--------------------------------------------------------------
|
|
ISequence testMethodSequence = TbfComponents.FindComponent(test.Method) as ISequence;
|
|
if (testMethodSequence != null)
|
|
{
|
|
StateMachine.LoadTestParams(test);
|
|
|
|
//--------------------------------------------------------------
|
|
e = testMethodSequence.Execute(test);
|
|
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.OpArgumentError)) goto config_error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
|
|
TimeEstimateBeginRpts += (test.Repeats * TimeEstimateOneTest);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Entities.Test test = StateMachine.GetTest(selection);
|
|
|
|
/// Fetch the test paths and transitions
|
|
if (!StateMachine.GetPaths(test, out inPath, out benchPath,
|
|
out outPath, out sensPath,
|
|
out transitionStart, out transitionStop))
|
|
{
|
|
goto config_error;
|
|
}
|
|
|
|
|
|
TimeEstimateTotal = test.Repeats * (test.TstTime + 10.0f);
|
|
TimeEstimateOneTest = test.TstTime + 10.0f;
|
|
TimeEstimateBeginRpts = 0;
|
|
|
|
ISequence testMethodSequence = TbfComponents.FindComponent(test.Method) as ISequence;
|
|
if (testMethodSequence != null)
|
|
{
|
|
StateMachine.LoadTestParams(test);
|
|
|
|
//--------------------------------------------------------------
|
|
e = testMethodSequence.Execute(test);
|
|
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.OpArgumentError)) goto config_error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
}
|
|
|
|
if (ResultsAreComplete(StateMachine.Tests))
|
|
{
|
|
Bridge.Bench2UI(ButtonsEtc.AcceptResultsBtnEn | ButtonsEtc.ResetResultsBtnEn);
|
|
}
|
|
else
|
|
{
|
|
Bridge.Bench2UI(ButtonsEtc.ResetResultsBtnEn);
|
|
}
|
|
|
|
goto select_cycle_or_test;
|
|
|
|
purge_end:
|
|
save_results:
|
|
|
|
Bridge.Bench2UI(ButtonsEtc.StopBtnEn); // Hide the most of buttons
|
|
|
|
//--------------------------------
|
|
string protocolTitle = string.Empty;
|
|
dataEntryCmpnt = TbfComponents.FindComponent(StateMachine.Procedure.DataEntry) as GenericDevices.IDataEntry;
|
|
if (dataEntryCmpnt != null)
|
|
{
|
|
Bridge.OnActivity(this, "Enter the protocol data");
|
|
|
|
if (dataEntryCmpnt is IHasCycleBeginForm)
|
|
{
|
|
if (!State.LastEvents.Contains(Event.ModelessFormClosed))
|
|
{
|
|
/// Wait until modeless dialg is closed
|
|
State.Create("MainSeq : Check whether the entry form is closed")
|
|
.AddOperation(checkUiOp)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
while (!e.Contains(Event.ModelessFormClosed));
|
|
}
|
|
|
|
/// A state without any dataEntryCmpnt operation so that Stop() when entering
|
|
/// this state and Start() when entering the following state are executed.
|
|
State.Create("MainSeq : Nothing")
|
|
.AddOperation(checkUiOp)
|
|
.RemovePermanentOperation(dataEntryCmpnt as IOperation)
|
|
.EnterState();
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
|
|
if (dataEntryCmpnt is IHasCycleEndForm)
|
|
{
|
|
/// Open the modeless form for the end of the cycle
|
|
State.Create("MainSeq : Enter end data")
|
|
.AddOperation((dataEntryCmpnt as GenericDevices.IHasCycleEndForm).ShowCycleEndFormOp(WaterMeters))
|
|
.AddOperation(checkUiOp)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
while (!e.Contains(Event.ModelessFormClosed));
|
|
}
|
|
|
|
if (dataEntryCmpnt is IHasProtocolTitle)
|
|
{
|
|
protocolTitle = (dataEntryCmpnt as IHasProtocolTitle).ProtocolTitle;
|
|
}
|
|
|
|
dataEntryCmpnt.UpdateTestResults(WaterMeters, results);
|
|
}
|
|
|
|
//--------------------------------
|
|
IResultsWriter writer = TbfComponents.FindComponent(StateMachine.Procedure.ResultsWriter) as IResultsWriter;
|
|
if (writer != null)
|
|
{
|
|
State.Create("MainSeq : Saving results")
|
|
.AddOperation(writer.WriteResultsOp(results))
|
|
.AddOperation(checkUiOp)
|
|
.EnterState();
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
}
|
|
|
|
//--------------------------------
|
|
IResultsPrinter printer = TbfComponents.FindComponent(StateMachine.Procedure.ResultsPrinter) as IResultsPrinter;
|
|
if (printer != null)
|
|
{
|
|
State.Create("MainSeq : Printing results")
|
|
.AddOperation(printer.PrintResultsOp(BenchId, WaterMeters, results, protocolTitle))
|
|
.AddOperation(checkUiOp)
|
|
.EnterState();
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stop;
|
|
}
|
|
}
|
|
|
|
/// Purge - End
|
|
switch (Transition(purgeEnd, TransitionContext.PurgeEnd))
|
|
{
|
|
case Event.Error: goto error;
|
|
case Event.UiCmdStop: goto stop;
|
|
}
|
|
|
|
benchFilled = false;
|
|
Bridge.Bench2UI(ButtonsEtc.ShowBenchEmpty);
|
|
|
|
goto select_procedure;
|
|
|
|
stop:
|
|
//--------------------------------
|
|
State.Create("MainSeq : Turning IDLE -> Closing the valves")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(StateMachine.DefaultValvesOpen,
|
|
StateMachine.DefaultValvesClose))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
}
|
|
while (!e.Contains(Event.ValvesSet));
|
|
|
|
goto select_procedure;
|
|
|
|
config_error:
|
|
//--------------------------------
|
|
State.Create("MainSeq : Procedure configuration error")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(new Operations.MessageBoxOp("Test configration error"))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
}
|
|
while (!e.Contains(Event.OK));
|
|
|
|
goto select_cycle_or_test;
|
|
|
|
error:
|
|
//--------------------------------
|
|
State.Create("MainSeq : ERROR -> Closing the valves")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(StateMachine.DefaultValvesOpen,
|
|
StateMachine.DefaultValvesClose))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
}
|
|
while (!e.Contains(Event.ValvesSet) && !e.Contains(Event.Error));
|
|
|
|
//--------------------------------
|
|
State.Create("MainSeq : ERROR state")
|
|
.EnterState();
|
|
while (true) StateMachine.WaitRunDevsRunOps();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// MakeSelection() call context
|
|
/// </summary>
|
|
enum MKSelContext
|
|
{
|
|
ProcedureNotSelected,
|
|
InsideProcedure,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selection done in MakeSelection()
|
|
/// </summary>
|
|
public enum Selection
|
|
{
|
|
/// Handled inside MakeSelection()
|
|
None,
|
|
EmptyTank1,
|
|
EmptyTank2,
|
|
EmptyTank3,
|
|
CloseTank1,
|
|
CloseTank2,
|
|
CloseTank3,
|
|
CameraTest,
|
|
|
|
/// Used as return values
|
|
Cycle,
|
|
Test,
|
|
Q1,
|
|
Q2,
|
|
Q3,
|
|
Stop,
|
|
PurgeBegin,
|
|
PurgeEnd,
|
|
SaveResults,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Idle loop to make a procedure or test selection.
|
|
/// Handles tank emptying, camera test.
|
|
/// </summary>
|
|
/// <param name="context">Context where MakeSelection() is called</param>
|
|
/// <returns>
|
|
/// Selection.Cycle
|
|
/// Selection.Test
|
|
/// Selection.Q1
|
|
/// Selection.Q2
|
|
/// Selection.Q3
|
|
/// Selection.Stop
|
|
/// Selection.PurgeBegin
|
|
/// Selection.PurgeEnd
|
|
/// </returns>
|
|
private Selection MakeSelection(MKSelContext context)
|
|
{
|
|
/// Tank emptying valves states
|
|
bool emptying1 = false;
|
|
bool emptying2 = false;
|
|
bool emptying3 = false;
|
|
|
|
/// Measured masses to control emptying
|
|
FloatBox mass1 = new FloatBox();
|
|
FloatBox mass2 = new FloatBox();
|
|
FloatBox mass3 = new FloatBox();
|
|
|
|
IList<Event> e;
|
|
Selection selection;
|
|
|
|
while (true)
|
|
{
|
|
/// Display an appropriate activity message
|
|
if (emptying1 || emptying2 || emptying3)
|
|
{
|
|
Bridge.OnActivity(this, Strings.Emptying_tank);
|
|
}
|
|
else if (context == MKSelContext.ProcedureNotSelected)
|
|
{
|
|
Bridge.OnActivity(this, Strings.Please_select_a_procedure);
|
|
}
|
|
else if (context == MKSelContext.InsideProcedure)
|
|
{
|
|
Bridge.OnActivity(this, Strings.Please_select_a_cycle_a_test_or_empty);
|
|
}
|
|
|
|
/// Enable appropriate UI controls and buttons
|
|
Bridge.Bench2UI(((context == MKSelContext.ProcedureNotSelected) ? ButtonsEtc.ProcedureCmbBoxEn : 0) |
|
|
ButtonsEtc.TestCmbBoxEn |
|
|
ButtonsEtc.StopBtnEn |
|
|
((emptying1 || emptying2 || emptying3) ? 0 :
|
|
(ButtonsEtc.StartCycleBtnEn |
|
|
ButtonsEtc.StartTestBtnsEn |
|
|
ButtonsEtc.PurgeBeginBtnEn |
|
|
((context == MKSelContext.InsideProcedure) ? ButtonsEtc.PurgeEndBtnEn : 0) |
|
|
ButtonsEtc.SensitivityTestBtnEn |
|
|
((Cameras.Count > 0) ? ButtonsEtc.CalibrationBtnEn : 0) |
|
|
ButtonsEtc.TryOpticalHeadsBtnEn)) |
|
|
(((StateMachine.Balance1 != null) && (StateMachine.EmptyTankValve1 != null) && !emptying1) ? ButtonsEtc.EmptyTankBtn1En : 0) |
|
|
(((StateMachine.Balance2 != null) && (StateMachine.EmptyTankValve2 != null) && !emptying2) ? ButtonsEtc.EmptyTankBtn2En : 0) |
|
|
(((StateMachine.Balance3 != null) && (StateMachine.EmptyTankValve3 != null) && !emptying3) ? ButtonsEtc.EmptyTankBtn3En : 0));
|
|
|
|
selection = Selection.None;
|
|
State.Create("MainSeq : Select an activity")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation((StateMachine.Balance1 != null) ? StateMachine.Balance1.ReadMassOp(ref mass1) : null)
|
|
.AddOperation((StateMachine.Balance2 != null) ? StateMachine.Balance2.ReadMassOp(ref mass2) : null)
|
|
.AddOperation((StateMachine.Balance3 != null) ? StateMachine.Balance3.ReadMassOp(ref mass3) : null)
|
|
.AddOperation(StateMachine.ControlBoard.UpdateTankWeightOp())
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
else if (e.Contains(Event.UiCmdStop)) selection = Selection.Stop;
|
|
else if (e.Contains(Event.UiCmdCameraTest)) selection = Selection.CameraTest;
|
|
else if (e.Contains(Event.UiCmdEmptyTank1)) selection = Selection.EmptyTank1;
|
|
else if (e.Contains(Event.UiCmdEmptyTank2)) selection = Selection.EmptyTank2;
|
|
else if (e.Contains(Event.UiCmdEmptyTank3)) selection = Selection.EmptyTank3;
|
|
else if (emptying1 && StateMachine.Balance1.IsEmpty(mass1.Val)) selection = Selection.CloseTank1;
|
|
else if (emptying2 && StateMachine.Balance2.IsEmpty(mass2.Val)) selection = Selection.CloseTank2;
|
|
else if (emptying3 && StateMachine.Balance3.IsEmpty(mass3.Val)) selection = Selection.CloseTank3;
|
|
else if (e.Contains(Event.UiCmdPurgeBegin)) return Selection.PurgeBegin; /// Value used to branch the code later on
|
|
else if (e.Contains(Event.UiCmdPurgeEnd)) return Selection.PurgeEnd;
|
|
else if (e.Contains(Event.UiCmdStartTest)) return Selection.Test;
|
|
else if (e.Contains(Event.UiCmdStartQ1)) return Selection.Q1;
|
|
else if (e.Contains(Event.UiCmdStartQ2)) return Selection.Q2;
|
|
else if (e.Contains(Event.UiCmdStartQ3)) return Selection.Q3;
|
|
else if (e.Contains(Event.UiCmdStartCycle)) return Selection.Cycle;
|
|
else if (e.Contains(Event.UiCmdAcceptResults)) return Selection.SaveResults;
|
|
}
|
|
while (selection == Selection.None);
|
|
|
|
if (selection == Selection.CameraTest)
|
|
{
|
|
CameraTest();
|
|
}
|
|
else if (selection == Selection.Stop)
|
|
{
|
|
if (emptying1 || emptying2 || emptying3)
|
|
{
|
|
IList<IValve> valvesClose = new List<IValve>();
|
|
if (emptying1) valvesClose.Add(StateMachine.EmptyTankValve1);
|
|
if (emptying2) valvesClose.Add(StateMachine.EmptyTankValve2);
|
|
if (emptying3) valvesClose.Add(StateMachine.EmptyTankValve3);
|
|
|
|
State.Create("MainSeq : Close emptying valve(s)")
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(null, valvesClose))
|
|
.EnterState();
|
|
do { e = StateMachine.WaitRunDevsRunOps(); }
|
|
while (!e.Contains(Event.ValvesSet));
|
|
emptying1 = emptying2 = emptying3 = false;
|
|
}
|
|
selection = Selection.None;
|
|
}
|
|
else if ((selection == Selection.EmptyTank1) && !emptying1)
|
|
{
|
|
emptying1 = true;
|
|
Bridge.OnActivity(this, Strings.Emptying_tank);
|
|
Bridge.Bench2UI(((context == MKSelContext.ProcedureNotSelected) ? ButtonsEtc.ProcedureCmbBoxEn : 0) |
|
|
ButtonsEtc.TestCmbBoxEn | ButtonsEtc.StopBtnEn |
|
|
(emptying2 ? 0 : ButtonsEtc.EmptyTankBtn2En) |
|
|
(emptying3 ? 0 : ButtonsEtc.EmptyTankBtn3En));
|
|
State.Create("MainSeq : Open tank 1")
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(StateMachine.EmptyTankValve1, null))
|
|
.EnterState();
|
|
do { e = StateMachine.WaitRunDevsRunOps(); }
|
|
while (!e.Contains(Event.ValvesSet));
|
|
}
|
|
else if ((selection == Selection.EmptyTank2) && !emptying2)
|
|
{
|
|
emptying2 = true;
|
|
Bridge.OnActivity(this, Strings.Emptying_tank);
|
|
Bridge.Bench2UI(((context == MKSelContext.ProcedureNotSelected) ? ButtonsEtc.ProcedureCmbBoxEn : 0) |
|
|
ButtonsEtc.TestCmbBoxEn | ButtonsEtc.StopBtnEn |
|
|
(emptying1 ? 0 : ButtonsEtc.EmptyTankBtn1En) |
|
|
(emptying3 ? 0 : ButtonsEtc.EmptyTankBtn3En));
|
|
State.Create("MainSeq : Open tank 2")
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(StateMachine.EmptyTankValve2, null))
|
|
.EnterState();
|
|
do { e = StateMachine.WaitRunDevsRunOps(); }
|
|
while (!e.Contains(Event.ValvesSet));
|
|
}
|
|
else if ((selection == Selection.EmptyTank3) && !emptying3)
|
|
{
|
|
emptying3 = true;
|
|
Bridge.OnActivity(this, Strings.Emptying_tank);
|
|
Bridge.Bench2UI(((context == MKSelContext.ProcedureNotSelected) ? ButtonsEtc.ProcedureCmbBoxEn : 0) |
|
|
ButtonsEtc.TestCmbBoxEn | ButtonsEtc.StopBtnEn |
|
|
(emptying1 ? 0 : ButtonsEtc.EmptyTankBtn1En) |
|
|
(emptying2 ? 0 : ButtonsEtc.EmptyTankBtn2En));
|
|
State.Create("MainSeq : Open tank 3")
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(StateMachine.EmptyTankValve3, null))
|
|
.EnterState();
|
|
do { e = StateMachine.WaitRunDevsRunOps(); }
|
|
while (!e.Contains(Event.ValvesSet));
|
|
}
|
|
else if (selection == Selection.CloseTank1)
|
|
{
|
|
State.Create("MainSeq : Close tank 1")
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(null, StateMachine.EmptyTankValve1))
|
|
.EnterState();
|
|
do { e = StateMachine.WaitRunDevsRunOps(); }
|
|
while (!e.Contains(Event.ValvesSet));
|
|
emptying1 = false;
|
|
}
|
|
else if (selection == Selection.CloseTank2)
|
|
{
|
|
State.Create("MainSeq : Close tank 2")
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(null, StateMachine.EmptyTankValve2))
|
|
.EnterState();
|
|
do { e = StateMachine.WaitRunDevsRunOps(); }
|
|
while (!e.Contains(Event.ValvesSet));
|
|
emptying2 = false;
|
|
}
|
|
else if (selection == Selection.CloseTank3)
|
|
{
|
|
State.Create("MainSeq : Close tank 3")
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(null, StateMachine.EmptyTankValve3))
|
|
.EnterState();
|
|
do { e = StateMachine.WaitRunDevsRunOps(); }
|
|
while (!e.Contains(Event.ValvesSet));
|
|
emptying3 = false;
|
|
}
|
|
}
|
|
|
|
error:
|
|
Bridge.OnActivity(this, Strings.Error);
|
|
State.Create("MainSeq : ERROR state")
|
|
.EnterState();
|
|
while (true) StateMachine.WaitRunDevsRunOps();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Perform a camera test
|
|
/// </summary>
|
|
void CameraTest()
|
|
{
|
|
IList<Event> e;
|
|
|
|
camera_test:
|
|
Bridge.OnActivity(this, "Camera test");
|
|
//---------------------------------------------------------
|
|
Bridge.Bench2UI(ButtonsEtc.StartTestBtnsEn | ButtonsEtc.StopBtnEn);
|
|
State.Create("MainSeq : 1 = Grab, 2 = Live, 3 = Focus, Stop = Quit camera test")
|
|
.AddOperation(checkUiOp)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) return;
|
|
if (e.Contains(Event.UiCmdStartQ1)) goto grab;
|
|
if (e.Contains(Event.UiCmdStartQ2)) goto live;
|
|
if (e.Contains(Event.UiCmdStartQ3)) goto focus;
|
|
}
|
|
while (true);
|
|
|
|
grab:
|
|
Bridge.Bench2UI(ButtonsEtc.StopBtnEn);
|
|
State.Create("MainSeq : Press 'Stop' to continue")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation((Cameras.Count > 0 && Cameras[0] != null && (Cameras[0].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[0].GrabOp() : null)
|
|
.AddOperation((Cameras.Count > 1 && Cameras[1] != null && (Cameras[1].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[1].GrabOp() : null)
|
|
.AddOperation((Cameras.Count > 2 && Cameras[2] != null && (Cameras[2].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[2].GrabOp() : null)
|
|
.AddOperation((Cameras.Count > 3 && Cameras[3] != null && (Cameras[3].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[3].GrabOp() : null)
|
|
.AddOperation((Cameras.Count > 4 && Cameras[4] != null && (Cameras[4].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[4].GrabOp() : null)
|
|
.AddOperation((Cameras.Count > 5 && Cameras[5] != null && (Cameras[5].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[5].GrabOp() : null)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto camera_test;
|
|
}
|
|
while (true);
|
|
|
|
live:
|
|
Bridge.Bench2UI(ButtonsEtc.StopBtnEn);
|
|
State.Create("MainSeq : Press 'Stop' to stop.")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation((Cameras.Count > 0 && Cameras[0] != null && (Cameras[0].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[0].LiveOp() : null)
|
|
.AddOperation((Cameras.Count > 1 && Cameras[1] != null && (Cameras[1].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[1].LiveOp() : null)
|
|
.AddOperation((Cameras.Count > 2 && Cameras[2] != null && (Cameras[2].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[2].LiveOp() : null)
|
|
.AddOperation((Cameras.Count > 3 && Cameras[3] != null && (Cameras[3].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[3].LiveOp() : null)
|
|
.AddOperation((Cameras.Count > 4 && Cameras[4] != null && (Cameras[4].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[4].LiveOp() : null)
|
|
.AddOperation((Cameras.Count > 5 && Cameras[5] != null && (Cameras[5].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[5].LiveOp() : null)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto camera_test;
|
|
}
|
|
while (true);
|
|
|
|
focus:
|
|
Bridge.Bench2UI(ButtonsEtc.StopBtnEn);
|
|
State.Create("MainSeq : Press 'Stop' to stop.")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation((Cameras.Count > 0 && Cameras[0] != null && (Cameras[0].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[0].FocusOp() : null)
|
|
.AddOperation((Cameras.Count > 1 && Cameras[1] != null && (Cameras[1].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[1].FocusOp() : null)
|
|
.AddOperation((Cameras.Count > 2 && Cameras[2] != null && (Cameras[2].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[2].FocusOp() : null)
|
|
.AddOperation((Cameras.Count > 3 && Cameras[3] != null && (Cameras[3].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[3].FocusOp() : null)
|
|
.AddOperation((Cameras.Count > 4 && Cameras[4] != null && (Cameras[4].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[4].FocusOp() : null)
|
|
.AddOperation((Cameras.Count > 5 && Cameras[5] != null && (Cameras[5].Cfg.DebugLevel != Entities.DebugMode.DetectedOff)) ? Cameras[5].FocusOp() : null)
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto camera_test;
|
|
}
|
|
while (true);
|
|
|
|
error:
|
|
Bridge.OnActivity(this, Strings.Error);
|
|
State.Create("MainSeq : ERROR state")
|
|
.EnterState();
|
|
while (true) StateMachine.WaitRunDevsRunOps();
|
|
}
|
|
}
|
|
}
|