michal/tbf
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
develop/SLM-PT50_genesisDirectDecode_changedRange
tbf/end

2521 lines
162 KiB
Plaintext
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

diff --git a/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs b/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs
index c1206bd20..261e8efad 100644
--- a/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs
+++ b/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs
@@ -1,26 +1,28 @@
-///
+using Common;
+using Config.Entities;
+using log4net;
+///
/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
+using System.IO;
using System.Text;
-using log4net;
-using Common;
-using Config.Entities;
-using TBF.Rig;
+using System.Xml.Serialization;
using TBF.Boxes;
using TBF.Resources;
-using TBF.UiBridge;
+using TBF.Rig;
using TBF.Rig.GenericDevices;
using TBF.Rig.RegisterReaders.PoseidonReader;
using TBF.Rig.RegisterReaders.PoseidonReader.implementations;
using TBF.Rig.Uni.SharedDialogs.SmartMetersCommunication.common;
+using TBF.UiBridge;

namespace TBF.Rig.TestMethods.FlyingStartMassCollection
{
- public class FlyingStartMassCollectionSeq : Sequences.SequenceBase
+ public class FlyingStartMassCollectionSeq : Sequences.SequenceBase
{
- private static readonly ILog log = LogManager.GetLogger(typeof(FlyingStartMassCollectionSeq));
+ private static readonly ILog log = LogManager.GetLogger(typeof(FlyingStartMassCollectionSeq));

/// <summary>
/// Check capabilities of devces in the output path required for this test method
@@ -44,11 +46,11 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
}

if (test.Volume > devices.Scale.Capacity * Constants.TankFullFactor)
- {
+ {
/// Scale capacity is not sufficient
message = string.Format("{0}: {1}", test.Name, Strings.Test_volume_exceeds_the_scale_capacity);
return false;
- }
+ }

if (!(devices.Diverter is IDiverter))
{
@@ -75,28 +77,28 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
return true;
}

- /// <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(Test test, int repetitionNr, bool isLastRepetition,
+ /// <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(Test test, int repetitionNr, bool isLastRepetition,
bool isDelayedStart, Compound.CombinedTestParams compoundTestParams,
HeatMeters.TestParams heatMetersTestParams, DebugMode debugLevel)
- {
- if (debugLevel == Common.DebugMode.Simulate)
- {
- return Simulate1(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
- }
- else if (debugLevel == Common.DebugMode.Inherit)
- {
- return Simulate2(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
- }
+ {
+ if (debugLevel == Common.DebugMode.Simulate)
+ {
+ return Simulate1(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
+ }
+ else if (debugLevel == Common.DebugMode.Inherit)
+ {
+ return Simulate2(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
+ }

ControlBoard.Uni.UniCB cBrd = StateMachine.ControlBoardMain as ControlBoard.Uni.UniCB;
IScale scale = cBrd.Devices.Scale as IScale;
@@ -131,30 +133,31 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
cBrd.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.TempMtrDiv != null) readTempPressOps.Add(outPath.TempMtrDiv.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(benchPath.ElectricMtrUp != null) readTempPressOps.Add(benchPath.ElectricMtrUp.ReadPressureOp(ref ElectricUp));
- if(benchPath.ElectricMtrDown != null) readTempPressOps.Add(benchPath.ElectricMtrDown.ReadPressureOp(ref ElectricDown));
- if(benchPath.ElectricMtrDelta != null) readTempPressOps.Add(benchPath.ElectricMtrDelta.ReadPressureOp(ref ElectricDelta));
- 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));
+ if (benchPath.TempMtrUp != null) readTempPressOps.Add(benchPath.TempMtrUp.ReadTempOp(ref TempUp));
+ if (benchPath.TempMtrDown != null) readTempPressOps.Add(benchPath.TempMtrDown.ReadTempOp(ref TempDown));
+ if (outPath.TempMtrDiv != null) readTempPressOps.Add(outPath.TempMtrDiv.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 (benchPath.ElectricMtrUp != null) readTempPressOps.Add(benchPath.ElectricMtrUp.ReadPressureOp(ref ElectricUp));
+ if (benchPath.ElectricMtrDown != null) readTempPressOps.Add(benchPath.ElectricMtrDown.ReadPressureOp(ref ElectricDown));
+ if (benchPath.ElectricMtrDelta != null) readTempPressOps.Add(benchPath.ElectricMtrDelta.ReadPressureOp(ref ElectricDelta));
+ 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));

int totalPulses = Convert.ToInt32(test.Volume / outPath.FlowMeter.LtrPerPulse);

///============================================================================================
- 
+
/// Read pressure and temperature once before calling Bridge.OnTestSelected(...)
State.Create(string.Format("{0}({1}) : Measuring process data", test.Method, test.Name))
.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
@@ -163,8 +166,8 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection

/// Start the test, initialize test results
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;
+ string testName = Results.Utils.GetTestName(test.Name, test.Repeats, repetitionNr);
+ TestStartTime = DateTime.Now;

//------------------------------------------------
Bridge.OnActivity(this, Strings.Checking_tank_capacity);
@@ -189,35 +192,36 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
.AddOperation(cBrd.SetValvesOp(scale.DrainValve, null))
.AddOperations(readTempPressOps)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
}
while (e.Contains(Event.ValvesBusy));
#endif
}


- ///
- /// Optionally display prompt to emerge temperature meters to appropriate baths for heat meters test
- ///
- IOperation heatMetersPromptOp = null;
- if (heatMetersTestParams != null && !string.IsNullOrEmpty(heatMetersTestParams.Prompt))
- {
- /// Make sure the CycleBeginForm is closed
- if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
+ ///
+ /// Optionally display prompt to emerge temperature meters to appropriate baths for heat meters test
+ ///
+ IOperation heatMetersPromptOp = null;
+ if (heatMetersTestParams != null && !string.IsNullOrEmpty(heatMetersTestParams.Prompt))
+ {
+ /// Make sure the CycleBeginForm is closed
+ if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;

- heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
- }
+ heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
+ }


//------------------------------------------------
Bridge.OnActivity(this, Strings.Starting_the_pump);
//------------------------------------------------

- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
- int flowSetTime0 = StateMachine.Time;
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+ int flowSetTime0 = StateMachine.Time;


if (inPath.Pump is GenericDevices.IPumpFM)
@@ -227,12 +231,13 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
///
State.Create(string.Format("{0}({1}) : Starting pump {2}", test.Method, test.Name, (inPath.Pump != null) ? inPath.Pump.Name : "?"))
.AddOperation(checkUiOp)
-// .AddOperation(new Operations.SetAllRegulValvesOp(inPath.RegulValves, inPath.RegulValvesPct, 60))
+ // .AddOperation(new Operations.SetAllRegulValvesOp(inPath.RegulValves, inPath.RegulValvesPct, 60))
.AddOperations(readTempPressOps)
.AddOperation(heatMetersPromptOp)
.AddOperation(inPath.Pump != null ? cBrd.SetValvesOp(inPath.Pump, null) : null)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

@@ -249,8 +254,9 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
.AddOperation(new Operations.TimerOp(test.TimePump2StartV))
.AddOperations(readTempPressOps)
.AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

@@ -267,11 +273,12 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
.AddOperation(cBrd.SetValvesOp(benchPath.StopBFValve, null))
.AddOperations(readTempPressOps)
.AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
}
while (!e.Contains(Event.ValvesSet));
}
@@ -284,8 +291,9 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
.AddOperation(new Operations.TimerOp(test.TimeBeforeFlow))
.AddOperations(readTempPressOps)
.AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

@@ -302,13 +310,14 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
.AddOperation(cBrd.SetFlowOp(test.QfromM3ph(), test.QtoM3ph(), RefFlow, FlowSettingTimeoutSec))
.AddOperations(readTempPressOps)
.AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, 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.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);
@@ -334,12 +343,13 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
double Tw_last = 0;
double Tc_last = 0;

- State.Create(string.Format("{0}({1}) : Check temperature stabilized.", test.Method, test.Name))
+ State.Create(string.Format("{0}({1}) : Check temperature stabilized.", test.Method, test.Name))
.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
if (e.Contains(Event.Next)) goto temperature_set;
@@ -368,63 +378,64 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
}
while (true);
}
- else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
- {
- //---------------------------------------------------
- Bridge.OnActivity(this, Strings.Setting_temperature);
- //---------------------------------------------------
-
- State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
- .AddOperation(checkUiOp)
+ else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
+ {
+ //---------------------------------------------------
+ Bridge.OnActivity(this, Strings.Setting_temperature);
+ //---------------------------------------------------
+
+ State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
+ .AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.EnterState();
- do {
- e = StateMachine.WaitRunDevsRunOps();
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
- if (e.Contains(Event.Next)) goto temperature_set;
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ if (e.Contains(Event.Next)) goto temperature_set;

if ((test.TempLimLo <= TempUp.Val) && (TempUp.Val <= test.TempLimHi) &&
(test.TempLimLo <= TempDown.Val) && (TempDown.Val <= test.TempLimHi))
{
- goto temperature_set;
- }
- }
- while (true);
- }
+ goto temperature_set;
+ }
+ }
+ while (true);
+ }

temperature_set:

///
- /// Prepare cameras, ROI-s and measurementOperations
- ///
+ /// Prepare cameras, ROI-s and measurementOperations
+ ///

- /// Find successfully detected ROI-s
- IList<GenericDevices.IRegReaderLiveCamera> rois = new List<GenericDevices.IRegReaderLiveCamera>();
- foreach (var rr in sensPath.RegisterReaders)
- {
+ /// Find successfully detected ROI-s
+ IList<GenericDevices.IRegReaderLiveCamera> rois = new List<GenericDevices.IRegReaderLiveCamera>();
+ foreach (var rr in sensPath.RegisterReaders)
+ {
GenericDevices.IRegReaderLiveCamera cameraRoI = rr as GenericDevices.IRegReaderLiveCamera;
if ((cameraRoI != null) && cameraRoI.Detected)
{
rois.Add(cameraRoI);
}
- }
+ }

- /// Find cameras
- IList<GenericDevices.ICamera> cameras = new List<GenericDevices.ICamera>();
+ /// Find cameras
+ IList<GenericDevices.ICamera> cameras = new List<GenericDevices.ICamera>();
foreach (var roi in rois)
{
- if (roi.Camera != null && !cameras.Contains(roi.Camera))
- {
- cameras.Add(roi.Camera);
- roi.Camera.ClearRoiParams();
- }
+ if (roi.Camera != null && !cameras.Contains(roi.Camera))
+ {
+ cameras.Add(roi.Camera);
+ roi.Camera.ClearRoiParams();
+ }
}

- /// Register ROI-parameters to cameras
- foreach (var roi in rois) roi.RegisterRoiToCamera();
+ /// Register ROI-parameters to cameras
+ foreach (var roi in rois) roi.RegisterRoiToCamera();

- /// Prepare measurementOperations
- IList<IOperation> cameraMeasurementOps = new List<IOperation>();
+ /// Prepare measurementOperations
+ IList<IOperation> cameraMeasurementOps = new List<IOperation>();
foreach (var camera in cameras)
{
cameraMeasurementOps.Add(camera.MeasurementOp());
@@ -446,60 +457,62 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
}


- if (drainTheTank)
- {
- //------------------------------------------------
- Bridge.OnActivity(this, Strings.Closing_the_tank);
- //------------------------------------------------
+ if (drainTheTank)
+ {
+ //------------------------------------------------
+ Bridge.OnActivity(this, Strings.Closing_the_tank);
+ //------------------------------------------------

- ///
- /// Make sure tank draining completed
- ///
+ ///
+ /// Make sure tank draining completed
+ ///
switch (DrainTheTank(scale, readTempPressOps))
- {
- case Event.Error: { retVal = Event.Error; goto stopTest; }
- case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
- }
+ {
+ case Event.Error: { retVal = Event.Error; goto stopTest; }
+ case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
+ }

- drainTheTank = false;
- }
- else
- {
- /// Close the drain valve anyway
- State.Create(string.Format("{0}({1}) : Close the drain valve", test.Method, test.Name))
- .AddOperation(checkUiOp)
+ drainTheTank = false;
+ }
+ else
+ {
+ /// Close the drain valve anyway
+ State.Create(string.Format("{0}({1}) : Close the drain valve", test.Method, test.Name))
+ .AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperation(cBrd.SetValvesOp(null, scale.DrainValve))
.EnterState();
- do {
- e = StateMachine.WaitRunDevsRunOps();
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
- }
- while (e.Contains(Event.ValvesBusy));
- }
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ }
+ while (e.Contains(Event.ValvesBusy));
+ }


- //----------------------------------------------------
- Bridge.OnActivity(this, Strings.Measuring_the_weight);
- //----------------------------------------------------
+ //----------------------------------------------------
+ Bridge.OnActivity(this, Strings.Measuring_the_weight);
+ //----------------------------------------------------

LogProcessDataTestInfo(processDataLogger, test.Procedure.Name, test.Name);

- if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "Start mass");
- else LogProcessDataHeaderHeatMeters(processDataLogger, "Start mass");
- 
- State.Create(string.Format("{0}({1}) : Measuring the start mass", test.Method, test.Name))
- .AddOperation(checkUiOp)
+ if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "Start mass");
+ else LogProcessDataHeaderHeatMeters(processDataLogger, "Start mass");
+
+ State.Create(string.Format("{0}({1}) : Measuring the start mass", test.Method, test.Name))
+ .AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperations(cameraMeasurementOps)
.AddOperation(scale.ReadStableMassOp(ref StartMass, test.TimeFlow2Mass, test.MassMethod, test.MassRepeats, test.MassSpread))
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
- e = StateMachine.WaitRunDevsRunOps();
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(test,e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
if (e.Contains(Event.ScaleTimeout))
{
Bridge.OnError(this, Strings.Mass_measurement_timeout);
@@ -513,9 +526,9 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
log.WarnFormat("Start mass = {0}kg", StartMass);


- if (heatMetersPath == null)
+ if (heatMetersPath == null)
LogProcessDataHeader(processDataLogger, "Measurement");
- else
+ else
LogProcessDataHeaderHeatMeters(processDataLogger, "Measurement");

//------------------------------------------------
@@ -531,18 +544,19 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection

/// Measurement loop
State.Create(string.Format("{0}({1}) : FlyingStartStopTestWithDivOp is running", test.Method, test.Name))
- .AddOperation(checkUiOp)
+ .AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperations(readDatastreamOps)
.AddOperations(cameraMeasurementOps)
.AddOperation(cBrd.FlyingStartStopTestOp(test, test.QfromM3ph(), test.QtoM3ph(), totalPulses, true, isDelayedStart, false, 0, true, DiverterStart, DiverterEnd))
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }

/// Show remaining time
if ((remainingTime = Math.Max(estimtdEndTime - StateMachine.Time, 0)) > 60)
@@ -602,32 +616,34 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
.AddOperations(readTempPressOps)
.AddOperation(cBrd.SetValvesOp(StateMachine.DefaultValvesOpen, StateMachine.DefaultValvesClose))
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(e)) { retVal = Event.UiCmdStop; goto stopTest; }
}
while (!e.Contains(Event.ValvesSet));
}

- //------------------------------------------------
- Bridge.OnActivity(this, Strings.Measuring_the_weight);
- //------------------------------------------------
+ //------------------------------------------------
+ Bridge.OnActivity(this, Strings.Measuring_the_weight);
+ //------------------------------------------------

- if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "End mass");
- else LogProcessDataHeaderHeatMeters(processDataLogger, "End mass");
+ if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "End mass");
+ else LogProcessDataHeaderHeatMeters(processDataLogger, "End mass");

State.Create(string.Format("{0}({1}) : Measuring the end mass", test.Method, test.Name))
- .AddOperation(checkUiOp)
+ .AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperation(scale.ReadStableMassOp(ref EndMass, test.TimeStop2Mass, test.MassMethod, test.MassRepeats, test.MassSpread))
.AddOperation(new Operations.TimerOp(StableMassMsrmntTimeoutSec))
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
- e = StateMachine.WaitRunDevsRunOps();
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(test,e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
if (e.Contains(Event.ScaleTimeout))
{
Bridge.OnError(this, Strings.Mass_measurement_timeout);
@@ -639,7 +655,7 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
///
tMass2 = StateMachine.Time;
log.WarnFormat("End mass = {0}kg", EndMass);
- TestEndTime = DateTime.Now;
+ TestEndTime = DateTime.Now;

if (test.DoDrainingAfter)
{
@@ -648,47 +664,48 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
.AddOperation(cBrd.SetValvesOp(scale.DrainValve, null))
.AddOperations(readTempPressOps)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
}
while (e.Contains(Event.ValvesBusy));
}

- //------------------------------------------------
- Bridge.OnActivity(this, Strings.Test_completed);
- //------------------------------------------------
+ //------------------------------------------------
+ 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 (heatMetersPromptOp == null)
- {
- if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
- }
+ /// Make sure the CycleBeginForm is closed so that water meter data (s/n) can be copied into results
+ if (heatMetersPromptOp == null)
+ {
+ if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
+ }

- ///
- /// Populate TestResult data entity with data
- /// 
- Results.Entities.TestRslt tstRslt = BatchRslts.GetTestRslt(testName, test.Part);
+ ///
+ /// Populate TestResult data entity with data
+ /// 
+ Results.Entities.TestRslt tstRslt = BatchRslts.GetTestRslt(testName, test.Part);

bool stopCycle = false;
if (tstRslt != null)
{
Results.Utils.GetCounterStates(tstRslt, Program.LocalSettings.Counters);

- /// Raw data
+ /// Raw data
UpdateTempPressDensAmb(tstRslt);
- tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName;
- tstRslt.StartTime = TestStartTime;
- tstRslt.EndTime = TestEndTime;
- tstRslt.FlowSetTime = flowSetTime;
- tstRslt.TestTime = cBrd.TestTime; /// [s] measurement time
- tstRslt.PulsesMaster = Convert.ToDouble(cBrd.RefPulses); /// Pulses of the master flow meter (test total)
- tstRslt.MassStartRaw = StartMass.Val;
- tstRslt.MassEndRaw = EndMass.Val;
+ tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName;
+ tstRslt.StartTime = TestStartTime;
+ tstRslt.EndTime = TestEndTime;
+ tstRslt.FlowSetTime = flowSetTime;
+ tstRslt.TestTime = cBrd.TestTime; /// [s] measurement time
+ tstRslt.PulsesMaster = Convert.ToDouble(cBrd.RefPulses); /// Pulses of the master flow meter (test total)
+ tstRslt.MassStartRaw = StartMass.Val;
+ tstRslt.MassEndRaw = EndMass.Val;
tstRslt.TimeBtwnMassMsrmnts = tMass2 - tMass1;
tstRslt.ConstMasterRaw = outPath.FlowMeter.LtrPerPulse;
- tstRslt.VolumeMaster = tstRslt.ConstMasterRaw * tstRslt.PulsesMaster; /// [l] volume from the master flow meter
- double flowMID = 3.6 * tstRslt.VolumeMaster / tstRslt.TestTime; /// [m3/h] flow before correction from the master flow meter
+ tstRslt.VolumeMaster = tstRslt.ConstMasterRaw * tstRslt.PulsesMaster; /// [l] volume from the master flow meter
+ double flowMID = 3.6 * tstRslt.VolumeMaster / tstRslt.TestTime; /// [m3/h] flow before correction from the master flow meter

/// Corrected data
tstRslt.MassStart = MeasurementCorrection.CorrectedValue(tstRslt.MassStartRaw, scale.Corrections);
@@ -698,23 +715,37 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
tstRslt.ConstMasterCorr = outPath.FlowMeter.LtrPerPulseCorrected(flowMID, tstRslt.TempDownMean);

/// Main result calculation
- tstRslt.VolumeCTV = 1000 * tstRslt.Batch.Buoyancy * mass / tstRslt.DensityLine;
+ tstRslt.VolumeCTV = 1000 * tstRslt.Batch.Buoyancy * mass / tstRslt.DensityLine;
if ((outPath.Diverter != null) && (tstRslt.TestTime > float.Epsilon))
{
tstRslt.TestTimeCorrection = outPath.Diverter.TestTimeCorrection(flowMID);
tstRslt.VolumeCTV *= tstRslt.TestTime + tstRslt.TestTimeCorrection;
tstRslt.VolumeCTV /= tstRslt.TestTime;
}
- tstRslt.Flow = 3.6 * tstRslt.VolumeCTV / tstRslt.TestTime; /// Flow from VolumeCTV and time
+ tstRslt.Flow = 3.6 * tstRslt.VolumeCTV / tstRslt.TestTime; /// Flow from VolumeCTV and time
tstRslt.ErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.VolumeCTV);
tstRslt.ConstMaster = (tstRslt.PulsesMaster != 0) ? (tstRslt.VolumeCTV / tstRslt.PulsesMaster) : tstRslt.ConstMasterCorr;
- /// Master pulses per liter from the measured mass
+ /// Master pulses per liter from the measured mass
+
+ /// Main result calculation for mass
+ tstRslt.MassCTV = tstRslt.Batch.Buoyancy * mass;
+ if ((outPath.Diverter != null) && (tstRslt.TestTime > float.Epsilon))
+ {
+ tstRslt.TestTimeCorrection = outPath.Diverter.TestTimeCorrection(flowMID);
+ tstRslt.MassCTV *= tstRslt.TestTime + tstRslt.TestTimeCorrection;
+ tstRslt.MassCTV /= tstRslt.TestTime;
+ }
+ tstRslt.MassFlow = 3.6 * tstRslt.MassCTV / tstRslt.TestTime; /// Flow from MassCTV and time
+ tstRslt.MassErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.MassCTV);
+ tstRslt.MassConstMaster = (tstRslt.PulsesMaster != 0) ? (tstRslt.MassCTV / tstRslt.PulsesMaster) : tstRslt.ConstMasterCorr;
+
+
/// Flow statistics correction
- tstRslt.FlowMean = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Average / tstRslt.ConstMasterRaw);
+ tstRslt.FlowMean = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Average / tstRslt.ConstMasterRaw);
tstRslt.FlowStart = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.First / tstRslt.ConstMasterRaw);
- tstRslt.FlowEnd = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Last / tstRslt.ConstMasterRaw);
- tstRslt.FlowMin = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Min / tstRslt.ConstMasterRaw);
- tstRslt.FlowMax = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Max / tstRslt.ConstMasterRaw);
+ tstRslt.FlowEnd = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Last / tstRslt.ConstMasterRaw);
+ tstRslt.FlowMin = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Min / tstRslt.ConstMasterRaw);
+ tstRslt.FlowMax = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Max / tstRslt.ConstMasterRaw);

tstRslt.DiverterStart = outPath.Diverter.SwitchTimeStart.Val;
tstRslt.DivStart10 = 0;
@@ -734,114 +765,114 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
: 0;
tstRslt.InfoFlags = infoFlags;

- if (compoundTestParams != null)
- {
- ///
- /// Compound meters
- ///
- for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
- {
- if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
+ if (compoundTestParams != null)
+ {
+ ///
+ /// Compound meters
+ ///
+ for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
+ {
+ if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;

- var mainMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundMain);
- var auxMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundAux);
+ var mainMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundMain);
+ var auxMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundAux);

- for (int isAux = 0; isAux <= 1; isAux++) /// 0=main, 1=aux
+ for (int isAux = 0; isAux <= 1; isAux++) /// 0=main, 1=aux
{
- IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];
- var oneMTR = (isAux == 0) ? mainMeterRslt : auxMeterRslt;
+ IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];
+ var oneMTR = (isAux == 0) ? mainMeterRslt : auxMeterRslt;

- if (oneMTR != null && regReader != null)
- {
+ if (oneMTR != null && regReader != null)
+ {
oneMTR.RegReaderType = (int)regReader.RegisterReaderType;
if (regReader is PoseidonReader poseidon) //is Poseidon reader family
{
- oneMTR.PulsesPerLiter = 0;
-
- /// Optionally supress pulses from the large water meter
- oneMTR.PulsesMeter = 0;
- oneMTR.PulsesMaster = 0;
- oneMTR.TestTime = cBrd.TestTime;
- oneMTR.VolumeStart = 0;
- oneMTR.VolumeEnd = 0;
- oneMTR.VolumeRef = tstRslt.VolumeCTV;
-
- if (oneMTR.PulsesMaster != 0)
- {
- oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
- oneMTR.PulsesMaster = tstRslt.PulsesMaster;
- }
-
- oneMTR.VolumeMeter = poseidon.WMVolume;
- 
- oneMTR.Error =
- Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
- tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
+ oneMTR.PulsesPerLiter = 0;
+
+ /// Optionally supress pulses from the large water meter
+ oneMTR.PulsesMeter = 0;
+ oneMTR.PulsesMaster = 0;
+ oneMTR.TestTime = cBrd.TestTime;
+ oneMTR.VolumeStart = 0;
+ oneMTR.VolumeEnd = 0;
+ oneMTR.VolumeRef = tstRslt.VolumeCTV;
+
+ if (oneMTR.PulsesMaster != 0)
+ {
+ oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
+ oneMTR.PulsesMaster = tstRslt.PulsesMaster;
+ }
+
+ oneMTR.VolumeMeter = poseidon.WMVolume;
+
+ oneMTR.Error =
+ Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
+ tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
}
else
{
- oneMTR.PulsesPerLiter = regReader.PulsesPerLtr;
-
- /// Optionally supress pulses from the large water meter
- oneMTR.PulsesMeter = (isAux == 0 && compoundTestParams.SupressTrills)
- ? 0
- : Convert.ToDouble(regReader.WMPulses);
- oneMTR.PulsesMaster = Convert.ToDouble(regReader.WMRefPulses);
- oneMTR.TestTime = cBrd.TestTime;
- oneMTR.VolumeStart = 0;
- oneMTR.VolumeEnd = 0;
- oneMTR.VolumeRef = tstRslt.VolumeCTV;
-
- if (oneMTR.PulsesMaster != 0)
- {
- oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
- oneMTR.PulsesMaster = tstRslt.PulsesMaster;
- }
-
- oneMTR.VolumeMeter = oneMTR.PulsesMeter * regReader.LtrsPerPulse; /// liter
-
- oneMTR.Error =
- Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
- tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
+ oneMTR.PulsesPerLiter = regReader.PulsesPerLtr;
+
+ /// Optionally supress pulses from the large water meter
+ oneMTR.PulsesMeter = (isAux == 0 && compoundTestParams.SupressTrills)
+ ? 0
+ : Convert.ToDouble(regReader.WMPulses);
+ oneMTR.PulsesMaster = Convert.ToDouble(regReader.WMRefPulses);
+ oneMTR.TestTime = cBrd.TestTime;
+ oneMTR.VolumeStart = 0;
+ oneMTR.VolumeEnd = 0;
+ oneMTR.VolumeRef = tstRslt.VolumeCTV;
+
+ if (oneMTR.PulsesMaster != 0)
+ {
+ oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
+ oneMTR.PulsesMaster = tstRslt.PulsesMaster;
+ }
+
+ oneMTR.VolumeMeter = oneMTR.PulsesMeter * regReader.LtrsPerPulse; /// liter
+
+ oneMTR.Error =
+ Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
+ tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
}
- }
- }
+ }
+ }

- var compoundMTR = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.Compound);
+ var compoundMTR = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.Compound);

- if (compoundMTR != null && mainMeterRslt != null && auxMeterRslt != null)
- {
- compoundMTR.VolumeRef = tstRslt.VolumeCTV;
- compoundMTR.VolumeMeter = mainMeterRslt.VolumeMeter + auxMeterRslt.VolumeMeter;
- compoundMTR.PulsesMaster = tstRslt.PulsesMaster;
- compoundMTR.TestTime = tstRslt.TestTime;
- compoundMTR.Error = Formulas.ErrorFromVolumes(compoundMTR.VolumeMeter, compoundMTR.VolumeRef);
- compoundMTR.Passed = (compoundMTR.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
- && (compoundMTR.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
+ if (compoundMTR != null && mainMeterRslt != null && auxMeterRslt != null)
+ {
+ compoundMTR.VolumeRef = tstRslt.VolumeCTV;
+ compoundMTR.VolumeMeter = mainMeterRslt.VolumeMeter + auxMeterRslt.VolumeMeter;
+ compoundMTR.PulsesMaster = tstRslt.PulsesMaster;
+ compoundMTR.TestTime = tstRslt.TestTime;
+ compoundMTR.Error = Formulas.ErrorFromVolumes(compoundMTR.VolumeMeter, compoundMTR.VolumeRef);
+ compoundMTR.Passed = (compoundMTR.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
+ && (compoundMTR.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
&& (tstRslt.ErrorFlags == 0);
- mainMeterRslt.Passed = auxMeterRslt.Passed = compoundMTR.Passed;
- mainMeterRslt.TestDone = auxMeterRslt.TestDone = compoundMTR.TestDone = true;
+ mainMeterRslt.Passed = auxMeterRslt.Passed = compoundMTR.Passed;
+ mainMeterRslt.TestDone = auxMeterRslt.TestDone = compoundMTR.TestDone = true;
tstRslt.TestDone = true;
- }
- }
- }
- else if (heatMetersTestParams != null)
- {
+ }
+ }
+ }
+ else if (heatMetersTestParams != null)
+ {
///
/// Heat meters
///
tstRslt.RefEnergy = Energy.Sum * tstRslt.VolumeCTV / VolumeForEnergy.Sum; /// [J] = [J] * [l] / [l]

- tstRslt.Custom1 = (float)TempRefHiStat.Average;
- tstRslt.Custom2 = (float)TempRefHiStat.First;
- tstRslt.Custom3 = (float)TempRefHiStat.Last;
- tstRslt.Custom4 = (float)TempRefHiStat.Min;
- tstRslt.Custom5 = (float)TempRefHiStat.Max;
- tstRslt.Custom6 = (float)TempRefLoStat.Average;
- tstRslt.Custom7 = (float)TempRefLoStat.First;
- tstRslt.Custom8 = (float)TempRefLoStat.Last;
- tstRslt.Custom9 = (float)TempRefLoStat.Min;
- tstRslt.Custom10 = (float)TempRefLoStat.Max; 
+ tstRslt.Custom1 = (float)TempRefHiStat.Average;
+ tstRslt.Custom2 = (float)TempRefHiStat.First;
+ tstRslt.Custom3 = (float)TempRefHiStat.Last;
+ tstRslt.Custom4 = (float)TempRefHiStat.Min;
+ tstRslt.Custom5 = (float)TempRefHiStat.Max;
+ tstRslt.Custom6 = (float)TempRefLoStat.Average;
+ tstRslt.Custom7 = (float)TempRefLoStat.First;
+ tstRslt.Custom8 = (float)TempRefLoStat.Last;
+ tstRslt.Custom9 = (float)TempRefLoStat.Min;
+ tstRslt.Custom10 = (float)TempRefLoStat.Max;

for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
{
@@ -868,10 +899,10 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
volumeRslt.TestTime = cBrd.TestTimeWM(i + 1); /// [s]

volumeRslt.Error = Formulas.ErrorFromVolumes(volumeRslt.VolumeMeter, volumeRslt.VolumeRef);
- volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
- ((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
- (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
- (tstRslt.ErrorFlags == 0));
+ volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
+ ((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
+ (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
+ (tstRslt.ErrorFlags == 0));
volumeRslt.TestDone = true;
tstRslt.TestDone = true;
}
@@ -883,103 +914,131 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
energyRslt.PulsesMaster = Convert.ToDouble(energyRegReader.WMRefPulses);
energyRslt.VolumeStart = 0;
energyRslt.VolumeEnd = 0;
- energyRslt.VolumeRef = tstRslt.RefEnergy * (energyRslt.PulsesMaster / tstRslt.PulsesMaster); /// [J]
+ energyRslt.VolumeRef = tstRslt.RefEnergy * (energyRslt.PulsesMaster / tstRslt.PulsesMaster); /// [J]
energyRslt.VolumeMeter = energyRslt.PulsesMeter * Common.Units.ConvertFrom(Common.Unit.kWh, energyRegReader.LtrsPerPulse); /// [J]
energyRslt.TestTime = cBrd.TestTimeWM(i + 1); /// [s]

energyRslt.Error = Formulas.ErrorFromVolumes(energyRslt.VolumeMeter, energyRslt.VolumeRef);
- energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
- && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
+ energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
+ && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
&& (tstRslt.ErrorFlags == 0);
energyRslt.TestDone = true;
tstRslt.TestDone = true;
}
}
}
- else
- {
- ///
- /// Single meters
- ///
- for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
- {
- if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
-
- /// MetersKind.Single meters
- Results.Entities.MeterTestRslt meterRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.Single);
- GenericDevices.IRegReader regReader = sensPath.RegisterReaders[i];
+ else
+ {
+ ///
+ /// Single meters
+ ///
+ for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
+ {
+ if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
+
+ /// MetersKind.Single meters
+ Results.Entities.MeterTestRslt meterRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.Single);
+ GenericDevices.IRegReader regReader = sensPath.RegisterReaders[i];
GenericDevices.IRegReaderDatastream dstrReader = regReader as GenericDevices.IRegReaderDatastream;
TestMethods.iPerlCommunication.iPerlHead.IperlHead iPerl = regReader as TestMethods.iPerlCommunication.iPerlHead.IperlHead;
GenericDevices.IRegReaderLiveCamera cameraRoi = regReader as GenericDevices.IRegReaderLiveCamera;

- if (meterRslt != null && regReader != null)
- {
+ if (meterRslt != null && regReader != null)
+ {
meterRslt.RegReaderType = (int)regReader.RegisterReaderType;
- meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;
- meterRslt.PulsesMeter = Convert.ToDouble(regReader.WMPulses);
+ ComponentProcedure procParamsEntity = test.Procedure.GetProcedureParamsEntity(regReader.Name);
+
+ try
+ {
+ if (regReader.RegisterReaderType == RegisterReaderType.Pulses)
+ {
+ XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(RRProcParams) })[0];
+ RRProcParams tmp = Serializer.Deserialize(new StringReader(procParamsEntity.Parameters.ToString())) as RRProcParams;
+ regReader.PulsesPerLtr = tmp.PulsesPerLtr;
+ regReader.QuantityUnits = tmp.Units;
+ }
+ else
+ {
+ //MessageBox.Show("Cannot create or initialize a printer", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
+ }
+ }
+ catch (Exception ex)
+ {
+ /*log.DebugFormat(
+ "Error during Procedure parameters deserialization. CmpntName='{0}', Procedure='{1}', Parameters='{2}', Exception: {3}",
+ dbEntity?.CmpntName,
+ dbEntity?.Procedure,
+ dbEntity?.Parameters,
+ ex
+ );*/
+ }
+
+ meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;//...MF 11.12.2025 toto chybalo, v .csv bol stlpec naplneny nulami
+ meterRslt.QuantityUnits = regReader.QuantityUnits;
+ meterRslt.PulsesMeter = Convert.ToDouble(regReader.WMPulses);

if (dstrReader != null)
- {
-
- if (dstrReader is SmartReader poseidon) //is Poseidon reader family
- {
- log.Info("Poseidon reader detected - Results");
- meterRslt.TimestampStart = poseidon.TimestampSecStart;
- meterRslt.TimestampEnd = !poseidon.NoSamples
- ? poseidon.TimestampSecEnd
- : (poseidon.TimestampSecStart + tstRslt.TestTime);
- meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
- meterRslt.VolumeStart = poseidon.VolumeLtrStart; /// liter
+ {
+
+ if (dstrReader is SmartReader poseidon) //is Poseidon reader family
+ {
+ log.Info("Poseidon reader detected - Results");
+ meterRslt.TimestampStart = poseidon.TimestampSecStart;
+ meterRslt.TimestampEnd = !poseidon.NoSamples
+ ? poseidon.TimestampSecEnd
+ : (poseidon.TimestampSecStart + tstRslt.TestTime);
+ meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
+ meterRslt.VolumeStart = poseidon.VolumeLtrStart; /// liter
meterRslt.VolumeEnd = poseidon.VolumeLtrStart + poseidon.WMVolume; //dstrReader.VolumeLtrEnd; /// liter
- meterRslt.VolumeMeter = poseidon.WMVolume;
-
- if (!(meterRslt.TestTime == 0 || tstRslt.TestTime == 0))
- {
- meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
- meterRslt.PulsesMaster =
- tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
- }
- else
- {
- meterRslt.VolumeRef = tstRslt.VolumeCTV;
- meterRslt.PulsesMaster = tstRslt.PulsesMaster;
- }
-
- log.Info($"meterRslt.TimestampStart = {meterRslt.TimestampStart} \n" +
- $"meterRslt.TimestampEnd = {meterRslt.TimestampEnd }\n" +
- $"meterRslt.TestTime = {meterRslt.TestTime}\n" +
- $"meterRslt.VolumeStart = {meterRslt.VolumeStart}\n" +
- $"meterRslt.VolumeEnd = {meterRslt.VolumeEnd}\n" +
- $"meterRslt.VolumeMeter = {meterRslt.VolumeMeter}\n" +
- $"meterRslt.VolumeRef = {meterRslt.VolumeRef}\n" +
- $"meterRslt.PulsesMaster = {meterRslt.PulsesMaster}\n");
- 
- 
- }
- else
- {
- meterRslt.TimestampStart = dstrReader.TimestampSecStart;
- meterRslt.TimestampEnd = !dstrReader.NoSamples
- ? dstrReader.TimestampSecEnd
- : (dstrReader.TimestampSecStart + tstRslt.TestTime);
- meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
- meterRslt.VolumeStart = dstrReader.VolumeLtrStart; /// liter
+ meterRslt.VolumeMeter = poseidon.WMVolume;
+
+ if (!(meterRslt.TestTime == 0 || tstRslt.TestTime == 0))
+ {
+ meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
+ meterRslt.PulsesMaster =
+ tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
+ }
+ else
+ {
+ meterRslt.VolumeRef = tstRslt.VolumeCTV;
+ meterRslt.PulsesMaster = tstRslt.PulsesMaster;
+ }
+
+ log.Info($"meterRslt.TimestampStart = {meterRslt.TimestampStart} \n" +
+ $"meterRslt.TimestampEnd = {meterRslt.TimestampEnd}\n" +
+ $"meterRslt.TestTime = {meterRslt.TestTime}\n" +
+ $"meterRslt.VolumeStart = {meterRslt.VolumeStart}\n" +
+ $"meterRslt.VolumeEnd = {meterRslt.VolumeEnd}\n" +
+ $"meterRslt.VolumeMeter = {meterRslt.VolumeMeter}\n" +
+ $"meterRslt.VolumeRef = {meterRslt.VolumeRef}\n" +
+ $"meterRslt.PulsesMaster = {meterRslt.PulsesMaster}\n");
+
+
+ }
+ else
+ {
+ meterRslt.TimestampStart = dstrReader.TimestampSecStart;
+ meterRslt.TimestampEnd = !dstrReader.NoSamples
+ ? dstrReader.TimestampSecEnd
+ : (dstrReader.TimestampSecStart + tstRslt.TestTime);
+ meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
+ meterRslt.VolumeStart = dstrReader.VolumeLtrStart; /// liter
meterRslt.VolumeEnd = dstrReader.VolumeLtrEnd; /// liter
meterRslt.VolumeMeter =
- Math.Abs(dstrReader.VolumeLtrEnd - dstrReader.VolumeLtrStart);
- meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
- meterRslt.PulsesMaster =
- tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
- }
+ Math.Abs(dstrReader.VolumeLtrEnd - dstrReader.VolumeLtrStart);
+ meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
+ meterRslt.PulsesMaster =
+ tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
+ }

- if (iPerl != null)
+ if (iPerl != null)
{
if (iPerl.ResultCode != 0 && (meterRslt.WaterMeter.ResultCode & (int)Results.Entities.ResultCode.OptoErrorCodeMask) == 0)
{
meterRslt.WaterMeter.ResultCode |= iPerl.ResultCode;
}
#if IPERL
- meterRslt.WaterMeter.CalibFactor = iPerl.CalibFactor;
+ meterRslt.WaterMeter.CalibFactor = iPerl.CalibFactor;
meterRslt.ExtraDataPath = iPerl.ExtraDataPath;
if (TestMethods.iPerlCommunication.iPerlHead.IperlHead.FeatureVectorSize >= 1) meterRslt.X1 = iPerl.X[0];
if (TestMethods.iPerlCommunication.iPerlHead.IperlHead.FeatureVectorSize >= 2) meterRslt.X2 = iPerl.X[1];
@@ -1005,18 +1064,18 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
meterRslt.VolumeMeter,
meterRslt.VolumeRef);
}
- else if (cameraRoi != null)
- {
- meterRslt.TimestampStart = cameraRoi.TimestampStart; /// [s]
- meterRslt.TimestampEnd = cameraRoi.TimestampEnd; /// [s]
- meterRslt.VolumeStart = cameraRoi.VolumeStart; /// [l]
- meterRslt.VolumeEnd = cameraRoi.VolumeEnd; /// [l]
- meterRslt.VolumeMeter = cameraRoi.VolumeEnd - cameraRoi.VolumeStart; /// [l]
+ else if (cameraRoi != null)
+ {
+ meterRslt.TimestampStart = cameraRoi.TimestampStart; /// [s]
+ meterRslt.TimestampEnd = cameraRoi.TimestampEnd; /// [s]
+ meterRslt.VolumeStart = cameraRoi.VolumeStart; /// [l]
+ meterRslt.VolumeEnd = cameraRoi.VolumeEnd; /// [l]
+ meterRslt.VolumeMeter = cameraRoi.VolumeEnd - cameraRoi.VolumeStart; /// [l]

if (meterRslt.VolumeMeter != 0)
{
/// Normal measurement with camera
- meterRslt.TestTime = cameraRoi.TimestampEnd - cameraRoi.TimestampStart; /// [s]
+ meterRslt.TestTime = cameraRoi.TimestampEnd - cameraRoi.TimestampStart; /// [s]
meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
meterRslt.PulsesMaster = tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
}
@@ -1038,11 +1097,11 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
meterRslt.VolumeMeter,
meterRslt.VolumeRef);
}
- else
- {
+ else
+ {
meterRslt.PulsesMaster = Convert.ToDouble(regReader.WMRefPulses);
meterRslt.VolumeStart = 0;
- meterRslt.VolumeEnd = 0;
+ meterRslt.VolumeEnd = 0;
meterRslt.VolumeMeter = meterRslt.PulsesMeter * regReader.LtrsPerPulse; /// [l]

if (regReader.WMPulses >= 1)
@@ -1050,43 +1109,67 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
/// Normal measurement
meterRslt.TestTime = cBrd.TestTimeWM(regReader.Position);
meterRslt.VolumeRef = meterRslt.PulsesMaster * tstRslt.ConstMaster; /// [l]
+ meterRslt.MassRef = meterRslt.PulsesMaster * tstRslt.MassConstMaster; /// [kg]
}
else
{
/// None or one pulse from the water meter
meterRslt.TestTime = tstRslt.TestTime;
meterRslt.VolumeRef = tstRslt.VolumeCTV; /// [l]
+ meterRslt.MassRef = tstRslt.MassCTV;
}

- log.DebugFormat("Pulses: Pref4meter={0} Vmeter={1} Vref4meter={2} Ttime4meter={3} Ttime={4}",
+ log.DebugFormat("Pulses: Pref4meter={0} Vmeter={1} Vref4meter={2} Mmeter={3} Mref4meter={4} Ttime4meter={5} Ttime={6}",
meterRslt.PulsesMaster,
meterRslt.VolumeMeter,
meterRslt.VolumeRef,
+ meterRslt.MassMeter,
+ meterRslt.MassRef,
meterRslt.TestTime,
tstRslt.TestTime);
}

- meterRslt.Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
- meterRslt.Passed = (meterRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
- && (meterRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
- && (tstRslt.ErrorFlags == 0);
+ double Error = 0;
+ if (meterRslt.GetQuantityFromUnits() == "Mass")
+ Error = Formulas.ErrorFromVolumes(meterRslt.MassMeter, meterRslt.MassRef);
+ else
+ Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
+
+ meterRslt.Error = Error;
+
+ var ErrLimLo_Volume = test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime);
+ var ErrLimHi_Volume = test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime);
+ var ErrLimLo_Mass = test.GetErrLimLo(tstRslt.MassCTV, tstRslt.TestTime);
+ var ErrLimHi_Mass = test.GetErrLimHi(tstRslt.MassCTV, tstRslt.TestTime);
+
+ bool Passed;
+ if (meterRslt.GetQuantityFromUnits() == "Mass")
+ Passed = (meterRslt.Error >= ErrLimLo_Volume + test.Uncertainty) &&
+ (meterRslt.Error <= ErrLimHi_Volume - test.Uncertainty) &&
+ (tstRslt.ErrorFlags == 0);
+ else
+ Passed = (meterRslt.Error >= ErrLimLo_Mass + test.Uncertainty) &&
+ (meterRslt.Error <= ErrLimHi_Mass - test.Uncertainty) &&
+ (tstRslt.ErrorFlags == 0);
+
+ meterRslt.Passed = Passed;
meterRslt.TestDone = true;
tstRslt.TestDone = true;
#if ORACLE_DB
meterRslt.ErrorBC = meterRslt.Error;
#endif
}
- }
- }
-
- tstRslt.Components = Results.Entities.Components.UpdateList(BatchRslts.ComponentsList,
- new Results.Entities.Components((BenchInfo != null) ? BenchInfo.TestBenchId : 1,
- (BenchInfo != null) ? BenchInfo.TestBenchName : "testbench",
- inPath.Pump != null ? inPath.Pump.Name : string.Empty,
- outPath.FlowMeter != null ? outPath.FlowMeter.Name : string.Empty,
- cBrd.Devices.Scale.Name,
- outPath.RegValve != null ? outPath.RegValve.Name : string.Empty,
- outPath.Diverter != null ? outPath.Diverter.Name : string.Empty));
+ }
+ }
+
+ tstRslt.Components = Results.Entities.Components.UpdateList(BatchRslts.ComponentsList,
+ new Results.Entities.Components((BenchInfo != null) ? BenchInfo.TestBenchId : 1,
+ (BenchInfo != null) ? BenchInfo.TestBenchName : "testbench",
+ inPath.Pump != null ? inPath.Pump.Name : string.Empty,
+ outPath.FlowMeter != null ? outPath.FlowMeter.Name : string.Empty,
+ cBrd.Devices.Scale.Name,
+ outPath.RegValve != null ? outPath.RegValve.Name : string.Empty,
+ outPath.Diverter != null ? outPath.Diverter.Name : string.Empty));

/// Update water meter error flags
if (ErrorFlagsComp != null)
@@ -1105,24 +1188,24 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
}
}

- /// Update results
- Bridge.OnTestCompleted(this, new TestCompletedEventArgs(testName, tstRslt));
- }
+ /// Update results
+ Bridge.OnTestCompleted(this, new TestCompletedEventArgs(testName, tstRslt));
+ }

- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.TransitionAfter));
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.TransitionAfter));

- /// Append the results to the CSV-file
- allResults.Info(TestResult2CsvLine(testName, test.Part));
+ /// Append the results to the CSV-file
+ allResults.Info(TestResult2CsvLine(testName, test.Part));

if (stopCycle) retVal = Event.ErrorFlagsStop;

- stopTest:
+ stopTest:

- StopRecordingStatistics(); /// Make sure graph files are closed
+ StopRecordingStatistics(); /// Make sure graph files are closed

- ///
- /// Quit this sequence
- ///
+ ///
+ /// Quit this sequence
+ ///
if (isLastRepetition || retVal == Event.UiCmdStop
|| retVal == Event.OpArgumentError
|| retVal == Event.RecoverableError
@@ -1133,18 +1216,18 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
cBrd.StopAll(false);
}

- return new List<Event> { retVal };
- }
+ return new List<Event> { retVal };
+ }


- IList<Event> Simulate1(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
- Compound.CombinedTestParams compoundTestParams,
- HeatMeters.TestParams heatMetersTestParams)
- {
- ///
- /// Test method simulation
- /// 
- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+ IList<Event> Simulate1(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
+ Compound.CombinedTestParams compoundTestParams,
+ HeatMeters.TestParams heatMetersTestParams)
+ {
+ ///
+ /// Test method simulation
+ /// 
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

foreach (var rr in sensPath.RegisterReaders)
{
@@ -1157,12 +1240,12 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
StateMachine.WaitRunDevsRunOps();
StateMachine.WaitRunDevsRunOps();

- 
- if (compoundTestParams != null)
- {
+
+ if (compoundTestParams != null)
+ {
if (test.Name.ToLower().Contains("nok")) MakeSimulatedCompound(test, 1, test.Part, 4.7f, 0.9f);
else MakeSimulatedCompound(test, repetitionNr, test.Part, 0.7f, 1.0f);
- }
+ }
else if (heatMetersTestParams != null)
{
MakeSimulatedHeatMeters(test, repetitionNr, test.Part, 1.5f, 1000000, heatMetersTestParams.ErrorLimitLo, heatMetersTestParams.ErrorLimitHi, heatMetersTestParams.EvaluateVolume);
@@ -1170,91 +1253,91 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
else
{
float errorPctBase = -1.0f;
- if (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
+ if (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
else if (test.Name.ToLower().Contains("q2")) errorPctBase = 0.5f;
else if (test.Name.ToLower().Contains("q1")) errorPctBase = -5.1f;

MakeSimulated(test, repetitionNr, test.Part, errorPctBase + repetitionNr * 0.1f);
}

- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
- Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
- allResults.Info(TestResult2CsvLine(test.Name, 0)); /// Append the results to the CSV-file
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
+ Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
+ allResults.Info(TestResult2CsvLine(test.Name, 0)); /// Append the results to the CSV-file

- //-------------------------------------------------------------------
- Bridge.OnActivity(this, string.Format("{0} Simulation", test.Name));
- //-------------------------------------------------------------------
+ //-------------------------------------------------------------------
+ Bridge.OnActivity(this, string.Format("{0} Simulation", test.Name));
+ //-------------------------------------------------------------------

- State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
- .AddOperation(checkUiOp)
- .EnterState();
- IList<Event> e = StateMachine.WaitRunDevsRunOps();
+ State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
+ .AddOperation(checkUiOp)
+ .EnterState();
+ IList<Event> e = StateMachine.WaitRunDevsRunOps();

return new List<Event> { TestAndLogUiCmdStop(test, e) ? Event.UiCmdStop : Event.Done };
- }
+ }


- IList<Event> Simulate2(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
- Compound.CombinedTestParams compoundTestParams,
- HeatMeters.TestParams heatMetersTestParams)
- {
- IList<Event> e;
- Event retVal = Event.Done;
+ IList<Event> Simulate2(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
+ Compound.CombinedTestParams compoundTestParams,
+ HeatMeters.TestParams heatMetersTestParams)
+ {
+ IList<Event> e;
+ Event retVal = Event.Done;

- ///
- /// Test method with flow chart simulation
- /// 
- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+ ///
+ /// Test method with flow chart simulation
+ /// 
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));


- /// Simulate flow
+ /// Simulate flow
StartNewStatistics(null, BatchRslts.Batch.BatchNr, test, repetitionNr, 0);

- IntBox remainingTime = new IntBox((int)test.TestTime);
- State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
- .AddOperation(checkUiOp)
- .AddOperation(new Operations.TimerOp((int)test.TestTime, remainingTime))
- .EnterState();
- do
- {
- e = StateMachine.WaitRunDevsRunOps();
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
-
- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
-
- if (remainingTime.Val > 60)
- {
- Bridge.OnActivity(this, string.Format("{0} ... {1} {2} {3} {4}", Strings.Test_in_progress, remainingTime.Val / 60, "min", remainingTime.Val % 60, Strings.sec));
- }
- else
- {
- Bridge.OnActivity(this, string.Format("{0} ... {1} s", Strings.Test_in_progress, remainingTime.Val));
- }
- //------------------------------------------------
-
- RefFlow.Val = (1.0 + 0.2 * Math.Sin(2 * Math.PI * (float)remainingTime.Val / test.TestTime)) * (test.QfromM3ph() + test.QtoM3ph()) / 2.0;
+ IntBox remainingTime = new IntBox((int)test.TestTime);
+ State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
+ .AddOperation(checkUiOp)
+ .AddOperation(new Operations.TimerOp((int)test.TestTime, remainingTime))
+ .EnterState();
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
+
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
+
+ if (remainingTime.Val > 60)
+ {
+ Bridge.OnActivity(this, string.Format("{0} ... {1} {2} {3} {4}", Strings.Test_in_progress, remainingTime.Val / 60, "min", remainingTime.Val % 60, Strings.sec));
+ }
+ else
+ {
+ Bridge.OnActivity(this, string.Format("{0} ... {1} s", Strings.Test_in_progress, remainingTime.Val));
+ }
+ //------------------------------------------------
+
+ RefFlow.Val = (1.0 + 0.2 * Math.Sin(2 * Math.PI * (float)remainingTime.Val / test.TestTime)) * (test.QfromM3ph() + test.QtoM3ph()) / 2.0;
PressUp.Val = 2.7f;
PressDown.Val = 2.2f;

- UpdateAllStatistics();
- }
- while (!e.Contains(Event.TimerExpired));
+ UpdateAllStatistics();
+ }
+ while (!e.Contains(Event.TimerExpired));

- StopRecordingStatistics();
+ StopRecordingStatistics();

- if (retVal != Event.UiCmdStop)
- {
- float errorPctBase = -1.0f;
+ if (retVal != Event.UiCmdStop)
+ {
+ float errorPctBase = -1.0f;

- if (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
- else if (test.Name.ToLower().Contains("q2")) errorPctBase = 0.5f;
- else if (test.Name.ToLower().Contains("q1")) errorPctBase = -5.1f;
+ if (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
+ else if (test.Name.ToLower().Contains("q2")) errorPctBase = 0.5f;
+ else if (test.Name.ToLower().Contains("q1")) errorPctBase = -5.1f;

- MakeSimulated(test, repetitionNr, test.Part, errorPctBase + repetitionNr * 0.1f);
+ MakeSimulated(test, repetitionNr, test.Part, errorPctBase + repetitionNr * 0.1f);

- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
- Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
- allResults.Info(TestResult2CsvLine(test.Name, 0)); /// Append the results to the CSV-file
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
+ Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
+ allResults.Info(TestResult2CsvLine(test.Name, 0)); /// Append the results to the CSV-file
}

return new List<Event> { retVal }; /// default 'retVal' value is Event.Done
diff --git a/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs b/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs
--- a/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs
+++ b/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs
@@ -1,13 +1,14 @@
-///
+using Common;
+using Config.Entities;
+using log4net;
+///
/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
-using log4net;
-using Common;
-using Config.Entities;
+using System.Xml.Serialization;
using TBF.Boxes;
using TBF.Resources;
using TBF.Rig.GenericDevices;
@@ -74,21 +75,21 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
return true;
}

- /// <summary>
- /// Fixed start mass collection method sequence
- /// </summary>
- /// <param name="test">Test entity</param>
- /// <returns>
- /// Event.Done . . . . . . . OK
- /// Event.MakeSecondPass . . OK, 2nd pass (=evaluation) required
- /// 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(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
+ /// <summary>
+ /// Fixed start mass collection method sequence
+ /// </summary>
+ /// <param name="test">Test entity</param>
+ /// <returns>
+ /// Event.Done . . . . . . . OK
+ /// Event.MakeSecondPass . . OK, 2nd pass (=evaluation) required
+ /// 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(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
bool compound,
- HeatMeters.TestParams heatMetersTestParams,
- Common.DebugMode debugLevel)
+ HeatMeters.TestParams heatMetersTestParams,
+ Common.DebugMode debugLevel)
{
ControlBoard.IControlBoard cBrd = StateMachine.ControlBoardMain;
IScale scale = cBrd.Devices.Scale as IScale;
@@ -101,7 +102,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
}

IList<Event> e; /// Events from currently running operations
- int waterMetersCount = Math.Min(BenchInfo.WaterMetersCount, sensPath.RegisterReaders.Length); 
+ int waterMetersCount = Math.Min(BenchInfo.WaterMetersCount, sensPath.RegisterReaders.Length);
DateTimeBox timeStampStart = new DateTimeBox();
DateTimeBox timeStampEnd = new DateTimeBox();
FloatBox startSwitchTime = new FloatBox();
@@ -154,7 +155,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
@@ -172,53 +174,54 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
IOperation heatMetersPromptOp = null;
if (heatMetersTestParams != null && !string.IsNullOrEmpty(heatMetersTestParams.Prompt))
{
- /// Make sure the CycleBeginForm is closed
- if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
+ /// Make sure the CycleBeginForm is closed
+ if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;

- heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
+ heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
}


if (test.DoDraining || (scale.Mass + test.Volume >= scale.Capacity * Constants.TankFullFactor))
- {
+ {
///
/// There is not enough room in the tank OR unconditional draining ... drain the water tank
///
IList<IOperation> ops = new List<IOperation>(readTempPressOps);
ops.Add(heatMetersPromptOp);
- switch (DrainTheTank(scale, ops))
- {
- case Event.Error: { retVal = Event.Error; goto stopTest; }
- case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
- }
- }
- ///
- /// Make sure the drain valve is closed
- ///
- State.Create(string.Format("{0}({1}) : Make sure the drain valve is closed", test.Method, test.Name))
- .AddOperation(checkUiOp)
+ switch (DrainTheTank(scale, ops))
+ {
+ case Event.Error: { retVal = Event.Error; goto stopTest; }
+ case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
+ }
+ }
+ ///
+ /// Make sure the drain valve is closed
+ ///
+ State.Create(string.Format("{0}({1}) : Make sure the drain valve is closed", test.Method, test.Name))
+ .AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
- .AddOperation(heatMetersPromptOp)
- .AddOperation(cBrd.SetValvesOp(null, scale.DrainValve))
- .EnterState();
- do {
- e = StateMachine.WaitRunDevsRunOps();
- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.JustStarted));
+ .AddOperation(heatMetersPromptOp)
+ .AddOperation(cBrd.SetValvesOp(null, scale.DrainValve))
+ .EnterState();
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.JustStarted));

- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
- }
- while (!e.Contains(Event.ValvesSet));
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ }
+ while (!e.Contains(Event.ValvesSet));


//------------------------------------------------
Bridge.OnActivity(this, Strings.Starting_the_pump);
//------------------------------------------------

- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
- int flowSetTime0 = StateMachine.Time;
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+ int flowSetTime0 = StateMachine.Time;

- if (inPath.Pump is GenericDevices.IPumpFM) (inPath.Pump as GenericDevices.IPumpFM).TurnOn(test.PumpPower);
+ 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)
@@ -227,14 +230,15 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(heatMetersPromptOp)
.AddOperation(inPath.Pump != null ? cBrd.SetValvesOp(inPath.Pump, null) : null)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
}
- while (e.Contains(Event.ValvesBusy) /* || !e.Contains(Event.AllPositionsReached)*/);
+ while (e.Contains(Event.ValvesBusy) /* || !e.Contains(Event.AllPositionsReached)*/);


if (test.TimePump2StartV > 0)
@@ -245,7 +249,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(new Operations.TimerOp(test.TimePump2StartV))
.AddOperation(heatMetersPromptOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

@@ -263,10 +268,11 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(cBrd.SetValvesOp(benchPath.StopBFValve, null))
.AddOperation(heatMetersPromptOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
}
while (!e.Contains(Event.ValvesSet));
}
@@ -280,7 +286,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(new Operations.TimerOp(test.TimeBeforeFlow))
.AddOperation(heatMetersPromptOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

@@ -302,8 +309,9 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperations(readTempPressOps)
.AddOperation(cBrd.SetValvesOp(inPath.Pump, null))
.AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

@@ -317,7 +325,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(cBrd.OpenStartValveOp())
.AddOperation(heatMetersPromptOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

@@ -329,14 +338,15 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperation(cBrd.SetFlowOp(test.QfromM3ph(), test.QtoM3ph(), RefFlow, FlowSettingTimeoutSec))
- .AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .AddOperation(heatMetersPromptOp)
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));

if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
if (e.Contains(Event.RegulValveTimeOut))
{
Bridge.OnError(this, Strings.Flow_adjustment_failed);
@@ -362,15 +372,16 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
//---------------------------------------------------

int lastTimeSec = StateMachine.Time;
- double Tw_last = 0;
- double Tc_last = 0;
+ double Tw_last = 0;
+ double Tc_last = 0;

State.Create(string.Format("{0}({1}) : Checking if the temperature is stable", test.Method, test.Name))
.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
- .AddOperation(heatMetersPromptOp)
- .EnterState();
- do {
+ .AddOperation(heatMetersPromptOp)
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
if (e.Contains(Event.Next))
@@ -378,56 +389,57 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
break; /// Simulate temperature is within range
}

- if (TempRefHi1.Val != 0 && TempRefHi2.Val != 0 && TempRefLo1.Val != 0 && TempRefLo2.Val != 0)
- {
- if (StateMachine.Time - lastTimeSec > 10 || StateMachine.Time - lastTimeSec < 0)
- {
- double Tw = (TempRefHi1.Val + TempRefHi2.Val) / 2;
- double Tc = (TempRefLo1.Val + TempRefLo2.Val) / 2;
- if ((heatMetersTestParams.TempWarmLo <= Tw) && (Tw <= heatMetersTestParams.TempWarmHi) &&
- (heatMetersTestParams.TempColdLo <= Tc) && (Tc <= heatMetersTestParams.TempColdHi) &&
- (Math.Abs(Tw - Tw_last) <= heatMetersTestParams.ChangeInTimeWarm) &&
- (Math.Abs(Tc - Tc_last) <= heatMetersTestParams.ChangeInTimeCold) &&
- (Math.Abs(TempRefHi1.Val - TempRefHi2.Val) <= heatMetersTestParams.DeltaTempWarm) &&
- (Math.Abs(TempRefLo1.Val - TempRefLo2.Val) <= heatMetersTestParams.DeltaTempCold))
- {
+ if (TempRefHi1.Val != 0 && TempRefHi2.Val != 0 && TempRefLo1.Val != 0 && TempRefLo2.Val != 0)
+ {
+ if (StateMachine.Time - lastTimeSec > 10 || StateMachine.Time - lastTimeSec < 0)
+ {
+ double Tw = (TempRefHi1.Val + TempRefHi2.Val) / 2;
+ double Tc = (TempRefLo1.Val + TempRefLo2.Val) / 2;
+ if ((heatMetersTestParams.TempWarmLo <= Tw) && (Tw <= heatMetersTestParams.TempWarmHi) &&
+ (heatMetersTestParams.TempColdLo <= Tc) && (Tc <= heatMetersTestParams.TempColdHi) &&
+ (Math.Abs(Tw - Tw_last) <= heatMetersTestParams.ChangeInTimeWarm) &&
+ (Math.Abs(Tc - Tc_last) <= heatMetersTestParams.ChangeInTimeCold) &&
+ (Math.Abs(TempRefHi1.Val - TempRefHi2.Val) <= heatMetersTestParams.DeltaTempWarm) &&
+ (Math.Abs(TempRefLo1.Val - TempRefLo2.Val) <= heatMetersTestParams.DeltaTempCold))
+ {
break; /// Temperature is withing required range
}

- lastTimeSec = StateMachine.Time;
- Tw_last = Tw;
- Tc_last = Tc;
- }
- }
+ lastTimeSec = StateMachine.Time;
+ Tw_last = Tw;
+ Tc_last = Tc;
+ }
+ }
}
while (true);
}
- else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
- {
- //---------------------------------------------------
- Bridge.OnActivity(this, Strings.Setting_temperature);
- //---------------------------------------------------
-
- State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
- .AddOperation(checkUiOp)
+ else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
+ {
+ //---------------------------------------------------
+ Bridge.OnActivity(this, Strings.Setting_temperature);
+ //---------------------------------------------------
+
+ State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
+ .AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
- .EnterState();
- do {
- e = StateMachine.WaitRunDevsRunOps();
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ .EnterState();
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
if (e.Contains(Event.Next))
{
break; /// Simulate temperature is within range
}

- if (TempUp.Val >= test.TempLimLo && TempUp.Val <= test.TempLimHi &&
- TempDown.Val >= test.TempLimLo && TempDown.Val <= test.TempLimHi)
- {
+ if (TempUp.Val >= test.TempLimLo && TempUp.Val <= test.TempLimHi &&
+ TempDown.Val >= test.TempLimLo && TempDown.Val <= test.TempLimHi)
+ {
break; /// Temperature set withing required range
}
- }
- while (true);
- }
+ }
+ while (true);
+ }

///
/// Temperature is withing required range at this point
@@ -435,7 +447,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection

//-----------------------------------------------------------------
Bridge.OnActivity(this, Strings.Stopping_flow_for_the_fixed_start);
- //-----------------------------------------------------------------
+ //-----------------------------------------------------------------
State.Create(string.Format("{0}({1}) : Stop flow regulation", test.Method, test.Name))
.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
@@ -451,10 +463,11 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperation(cBrd.CloseStartValveOp())
- .EnterState();
- do {
+ .EnterState();
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
}
while (!e.Contains(Event.ValvesSet));
@@ -483,10 +496,10 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "Start mass");
else LogProcessDataHeaderHeatMeters(processDataLogger, "Start mass");

- ///
- /// Enter water meter begin states and read the start mass at the same time
- ///
- GenericDevices.IHasWMStatesForm dataEntryCmpnt = TbfComponents.FindComponent(StateMachine.Procedure.DataEntry) as GenericDevices.IHasWMStatesForm;
+ ///
+ /// Enter water meter begin states and read the start mass at the same time
+ ///
+ GenericDevices.IHasWMStatesForm dataEntryCmpnt = TbfComponents.FindComponent(StateMachine.Procedure.DataEntry) as GenericDevices.IHasWMStatesForm;
IOperation readStartMassOp = scale.ReadStableMassOp(ref StartMass, test.TimeFlow2Mass, test.MassMethod, test.MassRepeats, test.MassSpread);

if (dataEntryCmpnt != null)
@@ -515,7 +528,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
triggerValve = roi.GetValve();
if (triggerValve != null && !triggerSend)
{
- OpenValveGrabImage(cBrd,testInProgress, triggerValve, e,
+ OpenValveGrabImage(cBrd, testInProgress, triggerValve, e,
string.Format("{0}({1}) : Grabbing images - valve open", test.Method, test.Name));
triggerSend = true;
}
@@ -533,27 +546,28 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
}
}
state2.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();

Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));

- if (e.Contains(Event.Error)) { retVal = Event.Error; break; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; break; }
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
}
while (e.Contains(Event.CameraBusy));

(dataEntryCmpnt as GenericDevices.IDataEntryForCamera).StartImages = startImages;
}
- 
+
///valve trigger camera close
if (triggerValve != null)
{
- CloseValveGrabImage(cBrd,testInProgress,triggerValve, e,
+ CloseValveGrabImage(cBrd, testInProgress, triggerValve, e,
string.Format("{0}({1}) : Grabbing images - valve close", test.Method, test.Name));
}
///////
- 
+

Bridge.OnActivity(this, Strings.Enter_water_meter_data);
long readStartTime = StateMachine.Time;
@@ -564,13 +578,14 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation((dataEntryCmpnt as GenericDevices.IHasWMStatesForm).ShowTestStartFormOp(sensPath.RegisterReaders))
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
}
while (!e.Contains(Event.ModelessFormClosed));
long readEndTime = StateMachine.Time;
- 
+
log.Debug("Read poseidon - took:" + (readEndTime - readStartTime));

if (heatMetersTestParams != null)
@@ -612,7 +627,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
{
(rr as Rig.Network.Camera.RoiForFixedStartKeyence.Roi).BeginWMState =
dataEntryCmpnt.WMStartState(i);
- log.DebugFormat(" StandingStartMassCollectionSeq.cs - BeginWMState [{0}] -> RoiForFixedStartKeyence.Roi",dataEntryCmpnt.WMStartState(i));
+ log.DebugFormat(" StandingStartMassCollectionSeq.cs - BeginWMState [{0}] -> RoiForFixedStartKeyence.Roi", dataEntryCmpnt.WMStartState(i));
}
if (rr is Rig.Network.Camera.RoiForFixedStartCJMS11.Roi)
(rr as Rig.Network.Camera.RoiForFixedStartCJMS11.Roi).BeginWMState = dataEntryCmpnt.WMStartState(i);
@@ -638,7 +653,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
string destFName = string.IsNullOrEmpty((dataEntryCmpnt as IDataEntryForCamera).TestStartImgName(i, testName))
? fileName : (dataEntryCmpnt as IDataEntryForCamera).TestStartImgName(i, testName);
File.Copy(Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName), true);
- log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ",Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
+ log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ", Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
}
}
catch (Exception exc)
@@ -681,7 +696,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(scale.ReadStableMassOp(ref StartMass, test.TimeFlow2Mass, test.MassMethod, test.MassRepeats, test.MassSpread))
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
@@ -724,11 +740,12 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(controlFlowOp)
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }

/// Show remaining time
if ((remainingTime = Math.Max(estimtdEndTime - StateMachine.Time, 0)) > 60)
@@ -767,8 +784,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection

Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
}
- while ((cBrd.DebugLevel==DebugMode.Simulate && !e.Contains(Event.FlowReached)) || 
- (cBrd.DebugLevel!=DebugMode.Simulate && cBrd.RefPulses < initialPulsesCount + totalPulses && !e.Contains(Event.TestCompleted) && !e.Contains(Event.Next)));
+ while ((cBrd.DebugLevel == DebugMode.Simulate && !e.Contains(Event.FlowReached)) ||
+ (cBrd.DebugLevel != DebugMode.Simulate && cBrd.RefPulses < initialPulsesCount + totalPulses && !e.Contains(Event.TestCompleted) && !e.Contains(Event.Next)));

/// Measurement loop end
log.WarnFormat("Start valve switch time on test start = {0} ms", cBrd.ValveOpenCloseTime);
@@ -783,7 +800,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(cBrd.CloseStartValveOp(timeStampEnd, stopSwitchTime))
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
}
@@ -807,9 +825,10 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
.AddOperation(new Operations.TimerOp(StableMassMsrmntTimeoutSec))
.AddOperation(processDataLoggingOp)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
- if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+ if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
if (e.Contains(Event.ScaleTimeout))
{
@@ -844,7 +863,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
double buoyancy = Formulas.Buoyancy();
double massOfEvaporatedWater = (double)(tMass2 - tMass1) * outPath.Scale.EvaporationRate(TempDivStat.Average);
double volumeCTV = 1000.0 * buoyancy * (massEnd - massStart + massOfEvaporatedWater) / densityOut;
- if (debugLevel == Common.DebugMode.Simulate) volumeCTV = test.Volume;
+ if (debugLevel == Common.DebugMode.Simulate) volumeCTV = test.Volume;

double refEnergy = Energy.Sum * volumeCTV / VolumeForEnergy.Sum; /// [J]=[J]*[l]/[l]

@@ -853,33 +872,33 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
///
if (dataEntryCmpnt != null)
{
- string fileName = string.Format("{0}-{1}-end.bmp", test.Name, repetitionNr); //string.Format("{0}-end.bmp", test.Name);
- 
+ string fileName = string.Format("{0}-{1}-end.bmp", test.Name, repetitionNr); //string.Format("{0}-end.bmp", test.Name);
+
IValve triggerValve = null;
bool triggerSend = false;
- if (dataEntryCmpnt is GenericDevices.IDataEntryForCamera)
- {
- string[] endImages = new string[sensPath.RegisterReaders.Length];
-
- State state2 = State.Create(string.Format("{0}({1}) : Grabbing images", test.Method, test.Name))
- .AddOperation(checkUiOp);
- for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
- {
- GenericDevices.IRegReaderStillCamera roi = sensPath.RegisterReaders[i] as GenericDevices.IRegReaderStillCamera;
- if (roi != null)
- {
+ if (dataEntryCmpnt is GenericDevices.IDataEntryForCamera)
+ {
+ string[] endImages = new string[sensPath.RegisterReaders.Length];
+
+ State state2 = State.Create(string.Format("{0}({1}) : Grabbing images", test.Method, test.Name))
+ .AddOperation(checkUiOp);
+ for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
+ {
+ GenericDevices.IRegReaderStillCamera roi = sensPath.RegisterReaders[i] as GenericDevices.IRegReaderStillCamera;
+ if (roi != null)
+ {
///if exist valve trigger camera open
triggerValve = roi.GetValve();
if (triggerValve != null && !triggerSend)
{
- OpenValveGrabImage(cBrd,testInProgress,triggerValve, e,
+ OpenValveGrabImage(cBrd, testInProgress, triggerValve, e,
string.Format("{0}({1}) : Grabbing images - valve open", test.Method, test.Name));
triggerSend = true;
}
- string directory = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
- Directory.CreateDirectory(directory);
- endImages[i] = Path.Combine(directory, fileName);
- state2.AddOperation(roi.GrabImageOp(endImages[i]));
+ string directory = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
+ Directory.CreateDirectory(directory);
+ endImages[i] = Path.Combine(directory, fileName);
+ state2.AddOperation(roi.GrabImageOp(endImages[i]));
state2.AddOperation(testInProgress);
}
else
@@ -890,47 +909,49 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
endImages[i] = Path.Combine(directory, fileName);
}
}
- state2.EnterState();
- do {
- e = StateMachine.WaitRunDevsRunOps();
+ state2.EnterState();
+ do
+ {
+ e = StateMachine.WaitRunDevsRunOps();
+
+ Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));

- Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
+ if (e.Contains(Event.Error)) { retVal = Event.Error; break; }
+ if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
+ }
+ while (e.Contains(Event.CameraBusy));

- if (e.Contains(Event.Error)) { retVal = Event.Error; break; }
- if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
- }
- while (e.Contains(Event.CameraBusy));
+ (dataEntryCmpnt as GenericDevices.IDataEntryForCamera).EndImages = endImages;
+ }

- (dataEntryCmpnt as GenericDevices.IDataEntryForCamera).EndImages = endImages;
- }
- 
///valve trigger camera close
if (triggerValve != null)
{
- CloseValveGrabImage(cBrd,testInProgress, triggerValve, e,
+ CloseValveGrabImage(cBrd, testInProgress, triggerValve, e,
string.Format("{0}({1}) : Grabbing images - valve close", test.Method, test.Name));
}
///////
- 
- Bridge.OnActivity(this, Strings.Enter_water_meter_data);
+
+ Bridge.OnActivity(this, Strings.Enter_water_meter_data);
State state = State.Create(string.Format("{0}({1}) : Entering the end-state", test.Method, test.Name));
if (heatMetersTestParams != null && dataEntryCmpnt is GenericDevices.IHasHeatMtrStatesForm)
{
state.AddOperation((dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).
- ShowTestEndFormOp(sensPath.RegisterReaders,
- volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty,
+ ShowTestEndFormOp(sensPath.RegisterReaders,
+ volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty,
refEnergy, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty));
}
else
{
- state.AddOperation(dataEntryCmpnt.ShowTestEndFormOp(sensPath.RegisterReaders,
- volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty));
+ state.AddOperation(dataEntryCmpnt.ShowTestEndFormOp(sensPath.RegisterReaders,
+ volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty));
}
state.AddOperation(checkUiOp)
.AddOperations(readTempPressOps)
.AddOperation(testInProgress)
.EnterState();
- do {
+ do
+ {
e = StateMachine.WaitRunDevsRunOps();
if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
}
@@ -958,41 +979,41 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
{
for (int i = 0; i < waterMetersCount; i++)
{
- GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];
- 
+ GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];
+
if (rr is ICommonRegReader)
(rr as ICommonRegReader).EndWMState = dataEntryCmpnt.WMEndState(i);


- if (rr is Rig.RegisterReaders.StandingStartStop.RegisterReader)
- (rr as Rig.RegisterReaders.StandingStartStop.RegisterReader).EndWMState = dataEntryCmpnt.WMEndState(i);
+ if (rr is Rig.RegisterReaders.StandingStartStop.RegisterReader)
+ (rr as Rig.RegisterReaders.StandingStartStop.RegisterReader).EndWMState = dataEntryCmpnt.WMEndState(i);

- if (rr is Rig.Network.Camera.RoiForFixedStart.Roi)
- (rr as Rig.Network.Camera.RoiForFixedStart.Roi).EndWMState = dataEntryCmpnt.WMEndState(i);
+ if (rr is Rig.Network.Camera.RoiForFixedStart.Roi)
+ (rr as Rig.Network.Camera.RoiForFixedStart.Roi).EndWMState = dataEntryCmpnt.WMEndState(i);

if (rr is Rig.Network.Camera.RoiForFixedStartKeyence.Roi)
{
(rr as Rig.Network.Camera.RoiForFixedStartKeyence.Roi).EndWMState =
dataEntryCmpnt.WMEndState(i);
- log.DebugFormat(" StandingStartMassCollectionSeq.cs - EndWMState [{0}] -> RoiForFixedStartKeyence.Roi",dataEntryCmpnt.WMEndState(i));
+ log.DebugFormat(" StandingStartMassCollectionSeq.cs - EndWMState [{0}] -> RoiForFixedStartKeyence.Roi", dataEntryCmpnt.WMEndState(i));
}
- if(rr is Rig.Network.Camera.RoiForFixedStartCJMS11.Roi)
+ if (rr is Rig.Network.Camera.RoiForFixedStartCJMS11.Roi)
(rr as Rig.Network.Camera.RoiForFixedStartCJMS11.Roi).EndWMState = dataEntryCmpnt.WMEndState(i);

}
}

- if (dataEntryCmpnt is IDataEntryForCamera && (dataEntryCmpnt as IDataEntryForCamera).SaveImages)
- {
+ if (dataEntryCmpnt is IDataEntryForCamera && (dataEntryCmpnt as IDataEntryForCamera).SaveImages)
+ {
log.Debug("Save images EndWMState...");
- /// SaveImages==true ... copy images to the directory that will be archived at the end of the cycle
- for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
- {
- var roi = sensPath.RegisterReaders[i] as IRegReaderStillCamera;
- if (roi != null)
- {
- string srcDir = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
- string destDir = Path.Combine(Program.ImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
+ /// SaveImages==true ... copy images to the directory that will be archived at the end of the cycle
+ for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
+ {
+ var roi = sensPath.RegisterReaders[i] as IRegReaderStillCamera;
+ if (roi != null)
+ {
+ string srcDir = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
+ string destDir = Path.Combine(Program.ImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
try
{
if (File.Exists(Path.Combine(srcDir, fileName)))
@@ -1001,7 +1022,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
string destFName = string.IsNullOrEmpty((dataEntryCmpnt as IDataEntryForCamera).TestEndImgName(i, testName))
? fileName : (dataEntryCmpnt as IDataEntryForCamera).TestEndImgName(i, testName);
File.Copy(Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName), true);
- log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ",Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
+ log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ", Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
}
}
catch (Exception exc)
@@ -1009,8 +1030,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
log.ErrorFormat("Failed to copy image {0} to {1}: {2}", fileName, destDir, exc.Message);
}
}
- }
- }
+ }
+ }

//...MF...kvapkanie
//------------------------------------------------
@@ -1059,14 +1080,14 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection

/// Raw data
UpdateTempPressDensAmb(tstRslt);
- tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName;
- tstRslt.StartTime = TestStartTime;
- tstRslt.EndTime = TestEndTime;
- tstRslt.FlowSetTime = flowSetTime;
- tstRslt.TestTime = Math.Max(1.0, DateTimeBox.DurationSec(timeStampStart, timeStampEnd)); /// Min. 1s to prevent division by zero
+ tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName;
+ tstRslt.StartTime = TestStartTime;
+ tstRslt.EndTime = TestEndTime;
+ tstRslt.FlowSetTime = flowSetTime;
+ tstRslt.TestTime = Math.Max(1.0, DateTimeBox.DurationSec(timeStampStart, timeStampEnd)); /// Min. 1s to prevent division by zero
tstRslt.PulsesMaster = Convert.ToDouble(cBrd.RefPulses); /// Pulses of the master flow meter (test total)
tstRslt.MassStartRaw = StartMass.Val;
- tstRslt.MassEndRaw = EndMass.Val;
+ tstRslt.MassEndRaw = EndMass.Val;
tstRslt.TimeBtwnMassMsrmnts = tMass2 - tMass1;

/// Corrected values
@@ -1077,6 +1098,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
/// Main results
tstRslt.VolumeCTV = volumeCTV; /// [l] 1000.0f is because density is in [kg/m3]
tstRslt.Flow = 3.6 * volumeCTV / tstRslt.TestTime; /// [m3/h]
+ tstRslt.MassCTV = massCTV; /// [kg] 1000.0f is because density is in [kg/m3]
+ tstRslt.MassFlow = 3.6 * massCTV / tstRslt.TestTime; /// [kg/h]

if (cBrd is ControlBoard.Uni.UniCB)
{
@@ -1085,6 +1108,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
tstRslt.ConstMasterCorr = outPath.FlowMeter.LtrPerPulseCorrected(tstRslt.Flow, tstRslt.TempDownMean);
tstRslt.VolumeMaster = tstRslt.ConstMasterRaw * tstRslt.PulsesMaster; /// [l] volume from the master flow meter
tstRslt.ConstMaster = (tstRslt.VolumeMaster != 0) ? (tstRslt.ConstMasterRaw * tstRslt.VolumeCTV / tstRslt.VolumeMaster) : tstRslt.ConstMasterCorr;
+ tstRslt.MassConstMaster = (tstRslt.PulsesMaster != 0) ? (tstRslt.MassCTV / tstRslt.PulsesMaster) : tstRslt.ConstMasterCorr;
}
else
{
@@ -1095,11 +1119,12 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
tstRslt.ConstMaster = 1;
}
tstRslt.ErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.VolumeCTV);
+ tstRslt.MassErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.MassCTV);

tstRslt.FlowMean = (float)RefFlowStat.Average;
- tstRslt.FlowStart = (float)RefFlowStat.First;
- tstRslt.FlowEnd = (float)RefFlowStat.Last;
- tstRslt.FlowMin = (float)RefFlowStat.Min;
+ tstRslt.FlowStart = (float)RefFlowStat.First;
+ tstRslt.FlowEnd = (float)RefFlowStat.Last;
+ tstRslt.FlowMin = (float)RefFlowStat.Min;
tstRslt.FlowMax = (float)RefFlowStat.Max;

tstRslt.DiverterStart = startSwitchTime.Val;
@@ -1124,7 +1149,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
for (int isAux = 0; isAux <= 1; isAux++) /// 0=main, 1=aux
{
Results.Entities.MeterTestRslt meterRslt = (isAux == 0) ? mainMeterRslt : auxMeterRslt;
- GenericDevices.IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];
+ GenericDevices.IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];

if (meterRslt != null && regReader != null)
{
@@ -1166,63 +1191,63 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
///
tstRslt.RefEnergy = Energy.Sum * tstRslt.VolumeCTV / VolumeForEnergy.Sum; /// [J] = [J] * [l] / [l]

- tstRslt.Custom1 = (float)TempRefHiStat.Average;
- tstRslt.Custom2 = (float)TempRefHiStat.First;
- tstRslt.Custom3 = (float)TempRefHiStat.Last;
- tstRslt.Custom4 = (float)TempRefHiStat.Min;
- tstRslt.Custom5 = (float)TempRefHiStat.Max;
- tstRslt.Custom6 = (float)TempRefLoStat.Average;
- tstRslt.Custom7 = (float)TempRefLoStat.First;
- tstRslt.Custom8 = (float)TempRefLoStat.Last;
- tstRslt.Custom9 = (float)TempRefLoStat.Min;
- tstRslt.Custom10 = (float)TempRefLoStat.Max; 
+ tstRslt.Custom1 = (float)TempRefHiStat.Average;
+ tstRslt.Custom2 = (float)TempRefHiStat.First;
+ tstRslt.Custom3 = (float)TempRefHiStat.Last;
+ tstRslt.Custom4 = (float)TempRefHiStat.Min;
+ tstRslt.Custom5 = (float)TempRefHiStat.Max;
+ tstRslt.Custom6 = (float)TempRefLoStat.Average;
+ tstRslt.Custom7 = (float)TempRefLoStat.First;
+ tstRslt.Custom8 = (float)TempRefLoStat.Last;
+ tstRslt.Custom9 = (float)TempRefLoStat.Min;
+ tstRslt.Custom10 = (float)TempRefLoStat.Max;

for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
{
if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;

Results.Entities.MeterTestRslt volumeRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.HeatMeterVolume);
- Results.Entities.MeterTestRslt energyRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.HeatMeterEnergy);
+ Results.Entities.MeterTestRslt energyRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.HeatMeterEnergy);

- GenericDevices.IRegReader volumeRegReader =
+ GenericDevices.IRegReader volumeRegReader =
(sensPath.RegisterReaders.Length > 2 * i) ? sensPath.RegisterReaders[2 * i] : null;

- GenericDevices.IRegReader energyRegReader =
+ GenericDevices.IRegReader energyRegReader =
(sensPath.RegisterReaders.Length > 2 * i + 1) ? sensPath.RegisterReaders[2 * i + 1] : null;

if (volumeRslt != null && volumeRegReader != null)
{
- volumeRslt.PulsesPerLiter = volumeRegReader.PulsesPerLtr;
- volumeRslt.VolumeStart = volumeRegReader.BeginWMState;
- volumeRslt.VolumeEnd = volumeRegReader.EndWMState;
- volumeRslt.VolumeMeter = volumeRslt.VolumeEnd - volumeRslt.VolumeStart;
- volumeRslt.VolumeRef = tstRslt.VolumeCTV;
- volumeRslt.PulsesMeter = volumeRslt.VolumeMeter;
- volumeRslt.PulsesMaster = tstRslt.PulsesMaster; /// <----------------- ???
+ volumeRslt.PulsesPerLiter = volumeRegReader.PulsesPerLtr;
+ volumeRslt.VolumeStart = volumeRegReader.BeginWMState;
+ volumeRslt.VolumeEnd = volumeRegReader.EndWMState;
+ volumeRslt.VolumeMeter = volumeRslt.VolumeEnd - volumeRslt.VolumeStart;
+ volumeRslt.VolumeRef = tstRslt.VolumeCTV;
+ volumeRslt.PulsesMeter = volumeRslt.VolumeMeter;
+ volumeRslt.PulsesMaster = tstRslt.PulsesMaster; /// <----------------- ???
volumeRslt.TestTime = tstRslt.TestTime;

volumeRslt.Error = Formulas.ErrorFromVolumes(volumeRslt.VolumeMeter, volumeRslt.VolumeRef);
- volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
- ((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
- (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
- (tstRslt.ErrorFlags == 0));
- volumeRslt.TestDone = true;
+ volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
+ ((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
+ (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
+ (tstRslt.ErrorFlags == 0));
+ volumeRslt.TestDone = true;
tstRslt.TestDone = true;
}

if (energyRslt != null && energyRegReader != null && dataEntryCmpnt is GenericDevices.IHasHeatMtrStatesForm)
- {
- volumeRslt.PulsesPerLiter = energyRegReader.PulsesPerLtr;
- energyRslt.VolumeStart = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyStartState(i);
- energyRslt.VolumeEnd = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyEndState(i);
- energyRslt.VolumeMeter = energyRslt.VolumeEnd - energyRslt.VolumeStart;
- energyRslt.VolumeRef = tstRslt.RefEnergy;
- energyRslt.PulsesMeter = energyRslt.VolumeMeter;
+ {
+ volumeRslt.PulsesPerLiter = energyRegReader.PulsesPerLtr;
+ energyRslt.VolumeStart = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyStartState(i);
+ energyRslt.VolumeEnd = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyEndState(i);
+ energyRslt.VolumeMeter = energyRslt.VolumeEnd - energyRslt.VolumeStart;
+ energyRslt.VolumeRef = tstRslt.RefEnergy;
+ energyRslt.PulsesMeter = energyRslt.VolumeMeter;
energyRslt.PulsesMaster = tstRslt.PulsesMaster; /// <----------------- ???

energyRslt.Error = Formulas.ErrorFromVolumes(energyRslt.VolumeMeter, energyRslt.VolumeRef);
- energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
- && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
+ energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
+ && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
&& (tstRslt.ErrorFlags == 0);
energyRslt.TestDone = true;
tstRslt.TestDone = true;
@@ -1244,18 +1269,75 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
if (meterRslt != null && regReader != null)
{
meterRslt.RegReaderType = (int)regReader.RegisterReaderType;
- meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;
+
+
+ ComponentProcedure procParamsEntity = test.Procedure.GetProcedureParamsEntity(regReader.Name);
+
+ try
+ {
+ if (regReader.RegisterReaderType == RegisterReaderType.Pulses || regReader.RegisterReaderType == RegisterReaderType.Manual)
+ {
+ XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(RRProcParams) })[0];
+ RRProcParams tmp = Serializer.Deserialize(new StringReader(procParamsEntity.Parameters.ToString())) as RRProcParams;
+ regReader.PulsesPerLtr = tmp.PulsesPerLtr;
+ regReader.QuantityUnits = tmp.Units;
+ }
+ else
+ {
+ //MessageBox.Show("Cannot create or initialize a printer", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
+ }
+ }
+ catch (Exception ex)
+ {
+ /*log.DebugFormat(
+ "Error during Procedure parameters deserialization. CmpntName='{0}', Procedure='{1}', Parameters='{2}', Exception: {3}",
+ dbEntity?.CmpntName,
+ dbEntity?.Procedure,
+ dbEntity?.Parameters,
+ ex
+ );*/
+ }
+
+ meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;//...MF 11.12.2025 toto chybalo, v .csv bol stlpec naplneny nulami
+ meterRslt.QuantityUnits = regReader.QuantityUnits;
meterRslt.VolumeStart = regReader.BeginWMState;
meterRslt.VolumeEnd = regReader.EndWMState;
meterRslt.VolumeMeter = Math.Abs(meterRslt.VolumeEnd - meterRslt.VolumeStart);
- meterRslt.VolumeRef = tstRslt.VolumeCTV; /// liter
+ meterRslt.MassMeter = Math.Abs(meterRslt.VolumeEnd - meterRslt.VolumeStart);
+ meterRslt.VolumeRef = tstRslt.VolumeCTV; /// liter
+ meterRslt.MassRef = tstRslt.MassCTV; /// kg
meterRslt.PulsesMeter = meterRslt.VolumeMeter;
meterRslt.PulsesMaster = tstRslt.PulsesMaster;
meterRslt.TestTime = tstRslt.TestTime;
- meterRslt.Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
- meterRslt.Passed = (meterRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
+
+ //meterRslt.Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
+ double Error = 0;
+ if (meterRslt.GetQuantityFromUnits() == "Mass")
+ Error = Formulas.ErrorFromVolumes(meterRslt.MassMeter, meterRslt.MassRef);
+ else
+ Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
+
+ meterRslt.Error = Error;
+
+ /*meterRslt.Passed = (meterRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
&& (meterRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
- && (tstRslt.ErrorFlags == 0);
+ && (tstRslt.ErrorFlags == 0);*/
+ var ErrLimLo_Volume = test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime);
+ var ErrLimHi_Volume = test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime);
+ var ErrLimLo_Mass = test.GetErrLimLo(tstRslt.MassCTV, tstRslt.TestTime);
+ var ErrLimHi_Mass = test.GetErrLimHi(tstRslt.MassCTV, tstRslt.TestTime);
+
+ bool Passed;
+ if (meterRslt.GetQuantityFromUnits() == "Mass")
+ Passed = (meterRslt.Error >= ErrLimLo_Volume + test.Uncertainty) &&
+ (meterRslt.Error <= ErrLimHi_Volume - test.Uncertainty) &&
+ (tstRslt.ErrorFlags == 0);
+ else
+ Passed = (meterRslt.Error >= ErrLimLo_Mass + test.Uncertainty) &&
+ (meterRslt.Error <= ErrLimHi_Mass - test.Uncertainty) &&
+ (tstRslt.ErrorFlags == 0);
+
+ meterRslt.Passed = Passed;
meterRslt.TestDone = true;
tstRslt.TestDone = true;
if (regReader is ICommonRegReader regReaderCommon)
@@ -1265,7 +1347,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
{
meterRslt.WaterMeter.SerialNr = regReaderCommon.SerialNr;
}
- 
+
}
}
}
@@ -1308,9 +1390,9 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection

if (stopCycle) retVal = Event.ErrorFlagsStop;

- stopTest:
+ stopTest:

- StopRecordingStatistics();
+ StopRecordingStatistics();

///
/// Quit this sequence
Reference in New Issue View Git Blame Copy Permalink