297 lines
12 KiB
C#
297 lines
12 KiB
C#
///
|
|
/// Copyright (c) 2017-2019 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using log4net;
|
|
using Config.Entities;
|
|
using TBF.BenchControl.GenericDevices;
|
|
using TBF.Resources;
|
|
using TBF.UiBridge;
|
|
using System.IO;
|
|
|
|
namespace TBF.BenchControl.TestMethods.RoiDetection
|
|
{
|
|
public class RoiDetectionSeq : Sequences.SequenceBase
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(RoiDetectionSeq));
|
|
|
|
|
|
public IList<Event> Execute(Test test, GenericDevices.ICameraDisplay display, int repetitionNr, bool isLastRepetition)
|
|
{
|
|
IList<Event> e; /// Events from currently running operations
|
|
Event retVal = Event.Done;
|
|
TBF.BenchControl.ControlBoard.IControlBoard cBrd = StateMachine.ControlBoard;
|
|
checkUiOp = new Operations.CheckUIOp(true);
|
|
processDataLoggingOp = null;
|
|
|
|
|
|
if (cBrd is ControlBoard.Legacy.CBoard)
|
|
{
|
|
int[] filters = new int[] { 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
if (sensPath != null && sensPath.RegisterReaders != null)
|
|
{
|
|
foreach (var rr in sensPath.RegisterReaders)
|
|
{
|
|
IRegReaderPulses eldeRR = rr as IRegReaderPulses;
|
|
if ((eldeRR != null) && (eldeRR.Position >= 1) && (eldeRR.Position <= 8))
|
|
{
|
|
filters[eldeRR.Position - 1] = eldeRR.Filter;
|
|
}
|
|
}
|
|
}
|
|
|
|
(cBrd as ControlBoard.Legacy.CBoard).SetFiltersPidShortPulses(filters, outPath.PidCoef, test.ShortPulses);
|
|
}
|
|
|
|
IList<IOperation> readTempPressOps = new List<IOperation>();
|
|
if (benchPath.TempMtrUp != null) readTempPressOps.Add(benchPath.TempMtrUp.ReadTempOp(ref TempUp));
|
|
if (benchPath.TempMtrDown != null) readTempPressOps.Add(benchPath.TempMtrDown.ReadTempOp(ref TempDown));
|
|
if (outPath.TempDiv != null) readTempPressOps.Add(outPath.TempDiv.ReadTempOp(ref TempDiv));
|
|
if (benchPath.PressMtrUp != null) readTempPressOps.Add(benchPath.PressMtrUp.ReadPressureOp(ref PressUp));
|
|
if (benchPath.PressMtrDown != null) readTempPressOps.Add(benchPath.PressMtrDown.ReadPressureOp(ref PressDown));
|
|
if (benchPath.PressMtrDelta != null) readTempPressOps.Add(benchPath.PressMtrDelta.ReadPressureOp(ref PressDelta));
|
|
if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefWarm1.ReadTempOp(ref TempRefHi1));
|
|
if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefWarm2.ReadTempOp(ref TempRefHi2));
|
|
if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefCold1.ReadTempOp(ref TempRefLo1));
|
|
if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefCold2.ReadTempOp(ref TempRefLo2));
|
|
|
|
|
|
/// LtrPerRefPulse and totalPulses are only to make time estimates
|
|
LtrPerRefPulse = outPath.FlowMeter.LtrPerPulse; /// [ltr/pulse], nominal flow in [m3/h]
|
|
int totalPulses = (int)(test.Volume / LtrPerRefPulse + 0.5f);
|
|
|
|
//====================
|
|
// Start the test
|
|
//====================
|
|
Bridge.OnTestSelected(this, new TestSelectedEventArgs(test, repetitionNr, inPath, benchPath, outPath, sensPath, heatMetersPath));
|
|
string testName = Results.Utils.GetTestName(test.Name, test.Repeats, repetitionNr);
|
|
TestStartTime = DateTime.Now;
|
|
|
|
//-------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Starting_the_pump);
|
|
//-------------------------------------------------
|
|
///
|
|
if (inPath.Pump is GenericDevices.IPumpFM) (inPath.Pump as GenericDevices.IPumpFM).TurnOn(test.PumpPower);
|
|
State.Create(string.Format("{0}({1}) : Starting the pump", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(readTempPressOps)
|
|
.AddOperation(inPath.Pump != null ? cBrd.SetValvesOp(inPath.Pump, null) : null)
|
|
.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Config.Entities.Progress.FlowSetting));
|
|
|
|
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
}
|
|
while (e.Contains(Event.ValvesBusy));
|
|
|
|
|
|
if (test.TimePump2StartV > 0)
|
|
{
|
|
State.Create(string.Format("{0}({1}) : Waiting after the pump started", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(readTempPressOps)
|
|
.AddOperation(new Operations.TimerOp(test.TimePump2StartV))
|
|
.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
Bridge.OnProcessData(this, new ProcessDataEventArgs(test, repetitionNr, Config.Entities.Progress.FlowSetting));
|
|
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Config.Entities.Progress.FlowSetting));
|
|
|
|
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.TimerExpired));
|
|
}
|
|
|
|
|
|
if (benchPath.StopBFValve != null)
|
|
{
|
|
State.Create(string.Format("{0}({1}) : Opening the stop backflow valve", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(readTempPressOps)
|
|
.AddOperation(StateMachine.ControlBoard.SetValvesOp(benchPath.StopBFValve, null))
|
|
.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.ValvesSet));
|
|
}
|
|
|
|
|
|
if (test.TimeBeforeFlow > 0)
|
|
{
|
|
State.Create(string.Format("{0}({1}) : Waiting before flow setting process starts", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(readTempPressOps)
|
|
.AddOperation(new Operations.TimerOp(test.TimeBeforeFlow))
|
|
.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
Bridge.OnProcessData(this, new ProcessDataEventArgs(test, repetitionNr, Config.Entities.Progress.FlowSetting));
|
|
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Config.Entities.Progress.FlowSetting));
|
|
|
|
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (!e.Contains(Event.TimerExpired));
|
|
}
|
|
|
|
|
|
setting_flow:
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Setting_the_flow);
|
|
//------------------------------------------------
|
|
State.Create(string.Format("{0}({1}) : Setting the flow", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(readTempPressOps)
|
|
.AddOperation(cBrd.SetFlowOp(test.Qfrom, test.Qto, RefFlow, FlowSettingTimeoutSec))
|
|
.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Config.Entities.Progress.FlowSetting));
|
|
|
|
if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
|
|
if (TestAndLogUiCmdStop(test,e)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
if (e.Contains(Event.RegulValveTimeOut))
|
|
{
|
|
Bridge.OnError(this, Strings.Flow_adjustment_failed);
|
|
retVal = Event.RecoverableError;
|
|
goto stopTest;
|
|
}
|
|
if (e.Contains(Event.Next)) goto flow_set;
|
|
}
|
|
while (!e.Contains(Event.FlowReached));
|
|
|
|
flow_set:
|
|
|
|
int time = StateMachine.Time;
|
|
double currentFlow = RefFlow.Val;
|
|
|
|
string[] imageNames = new string[sensPath.RegisterReaders.Length];
|
|
|
|
for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
|
|
{
|
|
GenericDevices.IRegReaderLiveCamera roi = sensPath.RegisterReaders[i] as GenericDevices.IRegReaderLiveCamera;
|
|
if (roi != null)
|
|
{
|
|
roi.ClearRoi();
|
|
}
|
|
else
|
|
{
|
|
imageNames[i] = null;
|
|
}
|
|
}
|
|
|
|
detection_loop:
|
|
|
|
//---------------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.ROI_Detection_in_Progress);
|
|
//---------------------------------------------------------
|
|
|
|
State detection = State.Create(string.Format("{0}({1}) : Detection of ROI-s", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(readTempPressOps);
|
|
|
|
for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
|
|
{
|
|
GenericDevices.IRegReaderLiveCamera roi = sensPath.RegisterReaders[i] as GenericDevices.IRegReaderLiveCamera;
|
|
if (roi != null && !roi.Detected)
|
|
{
|
|
detection.AddOperation(roi.RoiDetectionOp());
|
|
imageNames[i] = roi.ImageFileNamePrefix + "detected.jpg";
|
|
}
|
|
}
|
|
|
|
detection.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
|
|
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Config.Entities.Progress.Test));
|
|
|
|
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
|
|
if (TestAndLogUiCmdStop(test,e)) { retVal = Event.UiCmdStop; goto stopTest; }
|
|
}
|
|
while (e.Contains(Event.CameraBusy));
|
|
|
|
//-----------------------------------------------------------------------------------------------------
|
|
if (e.Contains(Event.RoiDetectionPreviousFailed)) Bridge.OnActivity(this, Strings.Camera_error);
|
|
else if (e.Contains(Event.RoiDetectionFailed)) Bridge.OnActivity(this, Strings.Detection_failed);
|
|
else Bridge.OnActivity(this, Strings.Detection_completed);
|
|
//-----------------------------------------------------------------------------------------------------
|
|
|
|
log.WarnFormat("display: {0}", (display != null) ? display.Name : "-none-");
|
|
log.Warn("imageNames:");
|
|
for (int i = 0; i < imageNames.Length; i++)
|
|
{
|
|
if (!string.IsNullOrEmpty(imageNames[i])) log.WarnFormat(" " + imageNames[i]);
|
|
}
|
|
|
|
string title = Strings.Select_images_and_press_Retry_to_retry_RoI_detection;
|
|
State.Create(string.Format("{0}({1}) : Select images and press Retry to retry RoI detection", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(readTempPressOps)
|
|
.AddOperation((display == null) ? null : display.ShowStaticImageOp(imageNames, title))
|
|
.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
|
|
if (TestAndLogUiCmdStop(test, e))
|
|
{
|
|
retVal = Event.UiCmdStop;
|
|
goto stopTest;
|
|
}
|
|
}
|
|
while (e.Contains(Event.ModelessFormIsOpen));
|
|
|
|
if (e.Contains(Event.Retry))
|
|
{
|
|
for (int i = 0; i < display.SelectedImages.Length; i++)
|
|
{
|
|
GenericDevices.IRegReaderLiveCamera roi = sensPath.RegisterReaders[i] as GenericDevices.IRegReaderLiveCamera;
|
|
if (roi != null && display.SelectedImages[i])
|
|
{
|
|
roi.ClearRoi();
|
|
}
|
|
}
|
|
|
|
goto detection_loop;
|
|
}
|
|
else if (e.Contains(Event.Abort))
|
|
{
|
|
retVal = Event.UiCmdStop;
|
|
goto stopTest;
|
|
}
|
|
|
|
//---------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Detection_completed);
|
|
//---------------------------------------------------
|
|
|
|
stopTest:
|
|
|
|
///
|
|
/// Quit this sequence
|
|
///
|
|
if (isLastRepetition || retVal == Event.UiCmdStop || retVal == Event.OpArgumentError
|
|
|| retVal == Event.Error || retVal == Event.ConfigurationError)
|
|
{
|
|
State.Create(string.Format("{0}({1}) : Stopping diverter, gate, etc.", test.Method, test.Name))
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(cBrd.StopPreviousOp())
|
|
.EnterState();
|
|
do {
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (TestAndLogUiCmdStop(test, e)) break;
|
|
}
|
|
while (!e.Contains(Event.PreviousStopped));
|
|
}
|
|
|
|
return new List<Event> { retVal };
|
|
}
|
|
}
|
|
}
|