395 lines
16 KiB
C#
395 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using log4net;
|
|
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));
|
|
private static readonly ILog allResults = LogManager.GetLogger("AllResults");
|
|
private static readonly ILog summaryResults = LogManager.GetLogger("SummaryResults");
|
|
|
|
|
|
public IList<Event> Execute(Entities.Test test)
|
|
{
|
|
Elde.ControlBoardDev cBrd = StateMachine.ControlBoard;
|
|
|
|
/// Operations running in more then one state
|
|
checkUiOp = new Operations.CheckUIOp(true);
|
|
|
|
IList<Event> e; /// Events from currently running operations
|
|
|
|
/// 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)(7200.0f * test.Volume / outPath.FlowMeter.NominalFlow); /// Nominal flow in [m3/h]
|
|
|
|
float ltrPerRefPulse = outPath.FlowMeter.NominalFlow / 7200.0f; /// [ltr/pulse]
|
|
|
|
int repetitionNr = 1; /// First test: repetitionNr=1
|
|
|
|
//====================================
|
|
// Transition or SetRoute - Start
|
|
//====================================
|
|
switch (Transition(transitionStart, TransitionContext.TestStart))
|
|
{
|
|
case Event.Error: goto error;
|
|
case Event.UiCmdStop: goto stopTestAndRunningWater;
|
|
default: break;
|
|
}
|
|
|
|
//====================================
|
|
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);
|
|
|
|
|
|
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)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stopTestAndRunningWater;
|
|
}
|
|
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: goto error;
|
|
case Event.UiCmdStop: goto stopTestAndRunningWater;
|
|
}
|
|
|
|
set_flow:
|
|
|
|
int flowSetTime0 = StateMachine.Time;
|
|
float estFlowSetTime = 10.0f;
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Setting_the_flow);
|
|
//------------------------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Starting the pump")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation((inPath != null && inPath.Pump is GenericDevices.IPumpFM) ? (inPath.Pump as GenericDevices.IPumpFM).TurnOn() : null)
|
|
.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, cBrd, flowSetTime, progress));
|
|
|
|
if (e.Contains(Event.UiCmdStop)) goto stopTestAndRunningWater;
|
|
}
|
|
while (!e.Contains(Event.ValvesSet));
|
|
|
|
//--------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Setting the flow")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(outPath.RegulValve.SetFlowOp(outPath.FlowMeter, test.Qfrom, test.Qto, 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, cBrd, flowSetTime, progress));
|
|
|
|
if (e.Contains(Event.UiCmdStop)) goto stopTestAndRunningWater;
|
|
if (e.Contains(Event.OpArgumentError))
|
|
if (e.Contains(Event.RegulValveTimeOut)) goto error;
|
|
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());
|
|
}
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Measuring_the_weight);
|
|
//------------------------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Measuring the start mass")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperations(measureOperations)
|
|
.AddOperation(outPath.Balance.ReadStableMassOp(ref startMass, 5))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stopTestAndRunningWater;
|
|
}
|
|
while (!e.Contains(Event.BalanceDone));
|
|
|
|
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)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stopTestAndRunningWater;
|
|
}
|
|
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;
|
|
ResetAveragedData();
|
|
|
|
/// Measurement loop - begin
|
|
while (true)
|
|
{
|
|
//--------------------------------
|
|
switch (ReadRegistersTempPressAmbient(measureOperations, true))
|
|
{
|
|
case Event.Error: goto error;
|
|
case Event.UiCmdStop: goto stopTestAndRunningWater;
|
|
case Event.MeasurementCompleted: goto test_completed;
|
|
}
|
|
|
|
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();
|
|
|
|
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.Info(logstr);
|
|
|
|
|
|
float progress = Formulas.TestProgress(cBrd.EtPulses(0), totalPulses, estFlowSetTime, test.TstTime);
|
|
Bridge.OnTestProgress(this, GetTestProgressData(test, tstRslt, cBrd, cBrd.TTime, progress));
|
|
}
|
|
/// Measurement loop - end
|
|
|
|
test_completed:
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Measuring_the_weight);
|
|
//------------------------------------------------
|
|
State.Create("FlyingStartCollectionMethod : Measuring the end mass")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation(outPath.Balance.ReadStableMassOp(ref endMass, 5))
|
|
.AddOperation(cBrd.UpdateTankWeightOp())
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
if (e.Contains(Event.UiCmdStop)) goto stopTestAndRunningWater;
|
|
}
|
|
while (!e.Contains(Event.BalanceDone));
|
|
///
|
|
tstRslt.MassEndRaw = endMass.Val;
|
|
tstRslt.TimeEnd = DateTime.Now;
|
|
|
|
//------------------------------------------------
|
|
Bridge.OnActivity(this, Strings.Test_completed);
|
|
//------------------------------------------------
|
|
|
|
///
|
|
/// Populate TestResult data entity with data
|
|
///
|
|
tstRslt.TimeEnd = DateTime.Now;
|
|
UpdateTestRsltWithAveragedData(tstRslt);
|
|
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.1f;
|
|
}
|
|
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 = "wm" + (i + 1).ToString();
|
|
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, cBrd.EtPulses(0)));
|
|
|
|
FluentCommon.SaveToDb(StateMachine.WtSession, tstRslt);
|
|
|
|
|
|
if (++repetitionNr <= test.Repeats)
|
|
{
|
|
goto loop;
|
|
}
|
|
|
|
///----------------------///
|
|
/// 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)) goto stopTestAndRunningWater;
|
|
}
|
|
while (!e.Contains(Event.PreviousStopped));
|
|
|
|
stopTestAndRunningWater:
|
|
|
|
/// Transition sequence at the end of test
|
|
switch (Transition(transitionStop, TransitionContext.TestEnd))
|
|
{
|
|
case Event.Error: goto error;
|
|
case Event.UiCmdStop: goto stopTestAndRunningWater;
|
|
}
|
|
|
|
/// Create the return value - a list with one event Event.Done - and return
|
|
IList<Event> retval = new List<Event>();
|
|
retval.Add(Event.Done);
|
|
return retval;
|
|
|
|
//====================================
|
|
error:
|
|
cBrd.SetFMFreq(0, 0); /// Stop FM controlled pumps
|
|
State.Create("FlyingStartCollectionMethod : ERROR -> Closing the valves")
|
|
.AddOperation(checkUiOp)
|
|
.AddOperation((inPath != null && inPath.Pump is GenericDevices.IPumpFM) ? (inPath.Pump as GenericDevices.IPumpFM).TurnOff() : null)
|
|
.AddOperation(cBrd.SetValvesOp(StateMachine.DefaultValvesOpen, StateMachine.DefaultValvesClose))
|
|
.EnterState();
|
|
do
|
|
{
|
|
e = StateMachine.WaitRunDevsRunOps();
|
|
if (e.Contains(Event.Error)) goto error;
|
|
}
|
|
while (!e.Contains(Event.ValvesSet));
|
|
|
|
IList<Event> retval3 = new List<Event>();
|
|
retval3.Add(Event.Error);
|
|
return retval3;
|
|
}
|
|
}
|
|
}
|