582 lines
22 KiB
C#
582 lines
22 KiB
C#
///
|
|
/// Copyright (c) 2020 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using log4net;
|
|
using Common;
|
|
using Config.Entities;
|
|
using Dirichlet.Numerics;
|
|
using TBF.Boxes;
|
|
using TBF.Rig.GenericDevices;
|
|
using TBF.Rig.Modbus;
|
|
using TBF.Rig.Sequences;
|
|
|
|
namespace TBF.Rig.ControlBoard.Papouch
|
|
{
|
|
public class PapouchCB : ComponentBase, IControlBoard, IOperation
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(PapouchCB));
|
|
public override string ToString() { return string.Format("{0}({1})", ClassName, Cfg.ToString(-1)); }
|
|
|
|
readonly PapouchCBCfg cbCfg;
|
|
|
|
TBF.Rig.Modbus.Common.Modbus modbus;
|
|
|
|
const int quidosCount = 4;
|
|
QuidoVariant[] quidoVariants;
|
|
int[] modbusAddresses;
|
|
int[] offsetsOutputs;
|
|
int[] offsetsInputs;
|
|
UInt128[] routeOutputMasks;
|
|
UInt128[] routeInputMasks;
|
|
int[] lastStateMachineTimes;
|
|
bool outputsInitialized;
|
|
///
|
|
UInt128 currentOutputs;
|
|
|
|
UInt128 benchModelRoute;
|
|
UInt128 valvesToInvert; /// Route = valesToInvert ^ RequiredRouteWithoutInvertedVlaves
|
|
|
|
OutputPath devices;
|
|
|
|
|
|
enum SelectedOp
|
|
{
|
|
None,
|
|
SetFlow,
|
|
QueryMeasurementEnd,
|
|
}
|
|
SelectedOp scheduledOp;
|
|
SelectedOp runningOp;
|
|
///
|
|
bool opCompleted; /// true = Operation was completed and waits for Stop();
|
|
|
|
|
|
public PapouchCB() { }
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
public PapouchCB(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
|
|
: base(cfg)
|
|
{
|
|
cbCfg = cfg as PapouchCBCfg;
|
|
}
|
|
|
|
public void SpecifyInvertedValves(UInt128 valvesToInvert)
|
|
{
|
|
this.valvesToInvert = valvesToInvert;
|
|
this.benchModelRoute = valvesToInvert;
|
|
}
|
|
|
|
public override void Initialize()
|
|
{
|
|
modbus = TbfComponents.FindComponent(cbCfg.ParentName) as TBF.Rig.Modbus.Common.Modbus;
|
|
if (modbus == null) throw new Exception("Cannot find " + Name + " parent (Modbus)");
|
|
|
|
quidoVariants = new QuidoVariant[quidosCount] { cbCfg.Variant1, cbCfg.Variant2, cbCfg.Variant3, cbCfg.Variant4 };
|
|
modbusAddresses = new int[quidosCount] { cbCfg.ModbusAddress1, cbCfg.ModbusAddress2, cbCfg.ModbusAddress3, cbCfg.ModbusAddress4 };
|
|
offsetsOutputs = new int[quidosCount] { cbCfg.OffsetOutputs1, cbCfg.OffsetOutputs2, cbCfg.OffsetOutputs3, cbCfg.OffsetOutputs4 };
|
|
offsetsInputs = new int[quidosCount] { cbCfg.OffsetInputs1, cbCfg.OffsetInputs2, cbCfg.OffsetInputs3, cbCfg.OffsetInputs4 };
|
|
routeOutputMasks = new UInt128[quidosCount] { 0, 0, 0, 0 };
|
|
routeInputMasks = new UInt128[quidosCount] { 0, 0, 0, 0 };
|
|
lastStateMachineTimes = new int[quidosCount] { 0, 0, 0, 0 };
|
|
|
|
for (int quidoIx = 0; quidoIx < quidosCount; quidoIx++)
|
|
{
|
|
if (quidoVariants[quidoIx] != QuidoVariant.None)
|
|
{
|
|
modbus.ComponentNames[modbusAddresses[quidoIx]] = string.Format("{0}{1}", Name, quidoIx + 1);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 128; i++)
|
|
{
|
|
bool conflictAvoidanceFlag = false;
|
|
|
|
for (int quidoIx = 0; quidoIx < quidosCount; quidoIx++)
|
|
{
|
|
if (i >= offsetsOutputs[quidoIx] && i < offsetsOutputs[quidoIx] + OutputsCount(quidoIx))
|
|
{
|
|
if (conflictAvoidanceFlag) throw new Exception("Overlapping input/output bits");
|
|
conflictAvoidanceFlag = true;
|
|
routeOutputMasks[quidoIx] = routeOutputMasks[quidoIx] | ((UInt128)1 << i);
|
|
}
|
|
|
|
if (i >= offsetsInputs[quidoIx] && i < offsetsInputs[quidoIx] + InputsCount(quidoIx))
|
|
{
|
|
if (conflictAvoidanceFlag) throw new Exception("Overlapping input/output bits");
|
|
conflictAvoidanceFlag = true;
|
|
routeInputMasks[quidoIx] = routeInputMasks[quidoIx] | ((UInt128)1 << i);
|
|
}
|
|
}
|
|
}
|
|
|
|
outputsInitialized = false;
|
|
runningOp = SelectedOp.None;
|
|
|
|
TBF.UiBridge.Bridge.RouteChangeHandler += delegate(object sndr, TBF.UiBridge.RouteChangeArgs args)
|
|
{
|
|
UInt128 mask = ((UInt128)1) << args.BitNr;
|
|
if ((benchModelRoute & mask) == 0)
|
|
{
|
|
benchModelRoute |= mask;
|
|
}
|
|
else
|
|
{
|
|
benchModelRoute &= (~mask);
|
|
}
|
|
};
|
|
|
|
if (cbCfg.DebugLevel == DebugMode.Normal)
|
|
log.FatalFormat("{0} initialized: {1}", cbCfg.Name, this);
|
|
else
|
|
log.FatalFormat("{0} simulated: {1}", cbCfg.Name, this);
|
|
}
|
|
|
|
///
|
|
/// IDevice interface
|
|
///
|
|
public void RunDeviceBefore()
|
|
{
|
|
for (int quidoIx = 0; quidoIx < quidosCount; quidoIx++ )
|
|
{
|
|
if (modbus.ReceivedTelegrams[modbusAddresses[quidoIx]].Count > 0)
|
|
{
|
|
byte[] telegram = modbus.ReceivedTelegrams[modbusAddresses[quidoIx]].Dequeue();
|
|
|
|
if ((telegram.Length >= 8) && (telegram[1] == 0x11) && (telegram[2] == telegram.Length - 5))
|
|
{
|
|
int msgLen = telegram.Length - 7;
|
|
byte modbusAddress = telegram[3];
|
|
string msg = Encoding.ASCII.GetString(telegram, 5, msgLen);
|
|
|
|
string s = string.Format("Quido{0} detected: Address={1}, Message={2}", quidoIx + 1, modbusAddress, msg);
|
|
Debug.WriteLine(s);
|
|
log.Warn(s);
|
|
}
|
|
|
|
if ((telegram.Length == 6) && (telegram[1] == 0x02) && (telegram[2] == telegram.Length - 5))
|
|
{
|
|
UInt128 inputData = telegram[3];
|
|
benchModelRoute = (benchModelRoute & ~routeInputMasks[quidoIx]) | ((inputData << offsetsInputs[quidoIx]) & routeInputMasks[quidoIx]);
|
|
|
|
string s = string.Format("Quido{0} inputs: {1}", quidoIx + 1, telegram[3].ToString("X2"));
|
|
Debug.WriteLine(s);
|
|
log.Warn(s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RunDeviceAfter()
|
|
{
|
|
if (!outputsInitialized)
|
|
{
|
|
SendAllOutputs(benchModelRoute);
|
|
outputsInitialized = true;
|
|
}
|
|
else
|
|
{
|
|
for (int quidoIx = 0; quidoIx < quidosCount; quidoIx++)
|
|
{
|
|
if (quidoVariants[quidoIx] != QuidoVariant.None)
|
|
{
|
|
if ((currentOutputs & routeOutputMasks[quidoIx]) != (benchModelRoute & routeOutputMasks[quidoIx]) ||
|
|
(StateMachine.Time - lastStateMachineTimes[quidoIx]) >= 5)
|
|
{
|
|
SendOutputs(quidoIx, benchModelRoute, offsetsOutputs[quidoIx]);
|
|
}
|
|
else
|
|
{
|
|
RequestInputs(quidoIx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ProcessData.UpdateMeasuredValuesAndSetpoints();
|
|
TBF.UiBridge.Bridge.OnStateMachineTick(this, new TBF.UiBridge.StateMachineTickEventArgs(benchModelRoute,
|
|
ProcessData.MsrmntAvailableFlags,
|
|
ProcessData.MeasuredValues,
|
|
ProcessData.AltStrings,
|
|
ProcessData.Setpoints,
|
|
ProcessData.CustomBitmaps));
|
|
}
|
|
|
|
public void StopDevice()
|
|
{
|
|
SendAllOutputs(0);
|
|
}
|
|
|
|
public void StopDevice2() { }
|
|
|
|
|
|
|
|
private void RequestAllInputs()
|
|
{
|
|
for (int quidoIx = 0; quidoIx < quidosCount; quidoIx++)
|
|
{
|
|
if (quidoVariants[quidoIx] != QuidoVariant.None)
|
|
{
|
|
RequestInputs(quidoIx);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RequestInputs(int quidoIx)
|
|
{
|
|
byte addr = (byte)modbusAddresses[quidoIx];
|
|
byte cmd = (byte)Function.ReadSingleInput;
|
|
modbus.SendMessage(new byte[] { addr, cmd, 0, 0, 0, 2, 0, 0 }, string.Format("{0}{1}", Name, quidoIx + 1));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set outputs of QuidoRS board
|
|
/// </summary>
|
|
/// <param name="outputs">output value</param>
|
|
private void SendAllOutputs(UInt128 route)
|
|
{
|
|
for (int quidoIx = 0; quidoIx < quidosCount; quidoIx++)
|
|
{
|
|
if (quidoVariants[quidoIx] != QuidoVariant.None)
|
|
{
|
|
SendOutputs(quidoIx, route, offsetsOutputs[quidoIx]);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SendOutputs(int quidoIx, UInt128 outputs, int offset)
|
|
{
|
|
if (cbCfg.DebugLevel == Common.DebugMode.Normal)
|
|
{
|
|
byte addr = (byte)modbusAddresses[quidoIx];
|
|
byte cmd = (byte)Function.ForceMultipleCoils;
|
|
byte loByte = (byte)(outputs >> offset);
|
|
|
|
switch (quidoVariants[quidoIx])
|
|
{
|
|
case QuidoVariant.QuidoRS_4_4:
|
|
modbus.SendMessage(new byte[] { addr, cmd, 0, 0, 0, 4, 1, loByte, 0, 0 }, string.Format("{0}{1}", Name, quidoIx + 1));
|
|
break;
|
|
case QuidoVariant.QuidoRS_8_8:
|
|
modbus.SendMessage(new byte[] { addr, cmd, 0, 0, 0, 8, 1, loByte, 0, 0 }, string.Format("{0}{1}", Name, quidoIx + 1));
|
|
break;
|
|
case QuidoVariant.QuidoRS_2_16:
|
|
modbus.SendMessage(new byte[] { addr, cmd, 0, 0, 0, 16, 2, loByte, (byte)(outputs >> (offset + 8)), 0, 0 },
|
|
string.Format("{0}{1}", Name, quidoIx + 1));
|
|
break;
|
|
case QuidoVariant.QuidoRS_2_32:
|
|
modbus.SendMessage(new byte[] { addr, cmd, 0, 0, 0, 32, 4, loByte, (byte)(outputs >> (offset + 8)),
|
|
(byte)(outputs >> (offset + 16)),
|
|
(byte)(outputs >> (offset + 24)), 0, 0 },
|
|
string.Format("{0}{1}", Name, quidoIx + 1));
|
|
break;
|
|
}
|
|
}
|
|
|
|
currentOutputs = (currentOutputs & ~routeOutputMasks[quidoIx]) | (outputs & routeOutputMasks[quidoIx]);
|
|
lastStateMachineTimes[quidoIx] = StateMachine.Time;
|
|
}
|
|
|
|
int InputsCount(int quidoIx)
|
|
{
|
|
switch (quidoVariants[quidoIx])
|
|
{
|
|
case QuidoVariant.QuidoRS_4_4: return 4;
|
|
case QuidoVariant.QuidoRS_8_8: return 8;
|
|
case QuidoVariant.QuidoRS_2_16: return 2;
|
|
case QuidoVariant.QuidoRS_2_32: return 2;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
int OutputsCount(int quidoIx)
|
|
{
|
|
switch (quidoVariants[quidoIx])
|
|
{
|
|
case QuidoVariant.QuidoRS_4_4: return 4;
|
|
case QuidoVariant.QuidoRS_8_8: return 8;
|
|
case QuidoVariant.QuidoRS_2_16: return 16;
|
|
case QuidoVariant.QuidoRS_2_32: return 32;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
///
|
|
/// IControlBoard interface
|
|
///
|
|
|
|
public OutputPath Devices
|
|
{
|
|
set { devices = value; }
|
|
get { return devices; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Route: 128-bit word representing the current state of all valves and pumps
|
|
/// </summary>
|
|
public UInt128 Route { get { return benchModelRoute; } }
|
|
|
|
public UInt64 DigitalInputs { get { return 0; } }
|
|
|
|
public int FlowmeterId { get { return 0; } }
|
|
public double RefFrequency { get { return 0; } }
|
|
|
|
///
|
|
/// Last test result
|
|
///
|
|
public int RefPulses { get { return 0; } }
|
|
public double TestTime { get { return 1.0; } }
|
|
public int RefPulsesWM(int wmNr1) { return (wmNr1 > 0 && wmNr1 <= ProcessData.WMsCount) ? 0 : 0; }
|
|
public int PulsesWM(int wmNr1) { return (wmNr1 > 0 && wmNr1 <= ProcessData.WMsCount) ? 0 : 0; }
|
|
public double TestTimeWM(int wmNr1) { return (wmNr1 > 0 && wmNr1 <= ProcessData.WMsCount) ? 1.0 : 1.0; }
|
|
|
|
|
|
public void ClearProcessValues() { }
|
|
|
|
/// <summary>
|
|
/// Set valves to new positions.
|
|
/// </summary>
|
|
/// <param name="valvesToOpen">'UInt128' with bits of valves to open set to '1'</param>
|
|
/// <param name="valvesToClose">'UInt128' with bits of valves to close set to '1'</param>
|
|
/// <returns>'UInt128' with bits of valves that have changed set to '1'</returns>
|
|
public UInt128 SetValves(UInt128 valvesToOpen, UInt128 valvesToClose, IList<BuiltIn.ValveEx.Valve> extendedValves)
|
|
{
|
|
UInt128 oldRoute = benchModelRoute;
|
|
benchModelRoute = (((benchModelRoute ^ valvesToInvert) | valvesToOpen) & (~valvesToClose)) ^ valvesToInvert;
|
|
foreach (var extV in extendedValves) extV.UpdateRoute(ref benchModelRoute);
|
|
log.DebugFormat("SetValves(x,x), new route = {0}", Utils.ToBin40((ulong)benchModelRoute));
|
|
UInt128 retVal = oldRoute ^ benchModelRoute;
|
|
|
|
log.DebugFormat("{0}.SetValves({1}, {2}) returns {3}", Name, valvesToOpen.ToString("X"), valvesToClose.ToString("X"), retVal.ToString("X"));
|
|
return retVal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Open one valve and/or close one valve.
|
|
/// Events: ValvesSet
|
|
/// </summary>
|
|
/// <param name="valveOpen">Valve to be opened</param>
|
|
/// <param name="valveClose">Valve to be closed</param>
|
|
/// <returns>Created operation</returns>
|
|
public IOperation SetValvesOp(IValve valveOpen, IValve valveClose)
|
|
{
|
|
IOperation op = new BuiltIn.SetValvesOp(this, valveOpen, valveClose);
|
|
log.DebugFormat("{0}.SetValvesOp(vO, vC) returns {1}", Name, (op != null) ? op.ToString() : "null");
|
|
return op;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Open and/or close multiple valves.
|
|
/// Events: ValvesSet
|
|
/// </summary>
|
|
/// <param name="valvesOpen">A list of valves to be opened</param>
|
|
/// <param name="valvesClose">A list of valves to be closed</param>
|
|
/// <returns>Created operation</returns>
|
|
public IOperation SetValvesOp(IList<IValve> valvesOpen, IList<IValve> valvesClose)
|
|
{
|
|
IOperation op = new BuiltIn.SetValvesOp(this, valvesOpen, valvesClose);
|
|
log.DebugFormat("{0}.SetValvesOp(vlvsO, vlvsC) returns {1}", Name, (op != null) ? op.ToString() : "null");
|
|
return op;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Open start/stop valve.
|
|
/// Events: ValvesSet, ValvesBusy, Error
|
|
/// </summary>
|
|
/// <returns>Created operation</returns>
|
|
public IOperation OpenStartValveOp() { return OpenStartValveOp(null); }
|
|
public IOperation OpenStartValveOp(DateTimeBox openTimeStamp)
|
|
{
|
|
IOperation op = new BuiltIn.SetValvesOp(this, true, devices, openTimeStamp);
|
|
log.DebugFormat("{0}.OpenStartValveOp({1}) returns {2}", Name, devices.StartValve1.Name, (op != null) ? op.ToString() : "null");
|
|
return op;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Close start/stop valve.
|
|
/// Events: ValvesSet, ValvesBusy, Error
|
|
/// </summary>
|
|
/// <returns>Created operation</returns>
|
|
public IOperation CloseStartValveOp() { return CloseStartValveOp(null); }
|
|
public IOperation CloseStartValveOp(DateTimeBox closeTimeStamp)
|
|
{
|
|
IOperation op = new BuiltIn.SetValvesOp(this, false, devices, closeTimeStamp);
|
|
log.DebugFormat("{0}.CloseStartValveOp({1}) returns {2}", Name, devices.StartValve1.Name, (op != null) ? op.ToString() : "null");
|
|
return op;
|
|
}
|
|
|
|
public float ValveOpenCloseTime { get { return 0.1f; } }
|
|
|
|
|
|
/// <summary>
|
|
/// Returns operation to display a prompt message to set the flow.
|
|
/// </summary>
|
|
/// <param name="reqrdFlowLo">Lower limit</param>
|
|
/// <param name="reqrdFlowHi">Upper limit</param>
|
|
/// <param name="measuredFlow">Reference to a box for the measured flow or null</param>
|
|
/// <param name="timeout">Flow set timeout</param>
|
|
/// <param name="delay">Flow setting starts after this delay [s]</param>
|
|
/// <returns>Operation</returns>
|
|
public IOperation SetFlowOp(double reqrdFlowLo, double reqrdFlowHi, DoubleBox measuredFlow, int timeout)
|
|
{
|
|
return SetFlowOp(reqrdFlowLo, reqrdFlowHi, measuredFlow, timeout, 0);
|
|
}
|
|
public IOperation SetFlowOp(double reqrdFlowLo, double reqrdFlowHi, DoubleBox measuredFlow, int timeout, int delay)
|
|
{
|
|
string loLimStr = reqrdFlowLo.ToString(Common.Utils.SignificantDigitsToFmt(reqrdFlowLo, 2));
|
|
string hiLimStr = reqrdFlowHi.ToString(Common.Utils.SignificantDigitsToFmt(reqrdFlowHi, 2));
|
|
this.promptMsg = string.Format("Set flow measured by {0} withing {1} and {2} m3/h by regulation valve {3}",
|
|
devices.FlowMeter.Name, loLimStr, hiLimStr, devices.RegValve.Name);
|
|
this.backColor = System.Drawing.Color.LightSalmon;
|
|
|
|
scheduledOp = SelectedOp.SetFlow;
|
|
return this;
|
|
}
|
|
|
|
public IOperation StopFlowRegulationOp()
|
|
{
|
|
return new Operations.ReturnGivenEventOp(Event.FlowRegulationStopped);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start a standing start-stop test
|
|
/// </summary>
|
|
/// <returns>Operation</returns>
|
|
public IOperation StandingStartStopTestOp(Test test, int pulsesCount, bool withDiverter)
|
|
{
|
|
currentTest = test;
|
|
return new Operations.ReturnGivenEventOp(Event.TestInProgress);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start a flying start-stop test ... not supported by Papouch control board
|
|
/// </summary>
|
|
/// <returns>null</returns>
|
|
public IOperation FlyingStartStopTestOp(Test test, double qFrom, double qTo, int pulsesCount)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start a flying start-stop test with diverter ... not supported by Papouch control board
|
|
/// </summary>
|
|
/// <returns>null</returns>
|
|
public IOperation FlyingStartStopTestWithDivOp(Test test, double qFrom, double qTo, int pulsesCount, int massPulsesCount = 0, bool readDivTransition = true)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public IOperation QueryMeasurementEndOp()
|
|
{
|
|
scheduledOp = SelectedOp.QueryMeasurementEnd;
|
|
return this;
|
|
}
|
|
|
|
public IOperation ReadDiverterTransitionOp(bool isStart, Sequences.Statistics plotter, int batchNr, string testName, int repetition)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public void StopFlowControl(bool isFromUI, int rvId)
|
|
{
|
|
}
|
|
|
|
public void StopAll(bool isFromUI)
|
|
{
|
|
}
|
|
|
|
|
|
Test currentTest;
|
|
|
|
string promptMsg;
|
|
System.Drawing.Color backColor;
|
|
TBF.Rig.Operations.MessageBoxForm messageBoxForm;
|
|
///
|
|
delegate void MessageBoxFormDlgt(PapouchCB myRef);
|
|
///
|
|
void OpenFormDlg(PapouchCB myRef)
|
|
{
|
|
myRef.messageBoxForm = new TBF.Rig.Operations.MessageBoxForm(promptMsg, backColor);
|
|
messageBoxForm.Show();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Start selected operation
|
|
/// </summary>
|
|
public void Start()
|
|
{
|
|
if (scheduledOp == SelectedOp.None || runningOp != SelectedOp.None)
|
|
{
|
|
throw new Exception("Sequence error");
|
|
}
|
|
|
|
runningOp = scheduledOp;
|
|
scheduledOp = SelectedOp.None;
|
|
|
|
if (runningOp == SelectedOp.SetFlow)
|
|
{
|
|
Program.MainWnd.Invoke(new MessageBoxFormDlgt(OpenFormDlg), this);
|
|
}
|
|
else if (runningOp == SelectedOp.QueryMeasurementEnd)
|
|
{
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Run selected operation
|
|
/// </summary>
|
|
/// <returns>Event.None or Event.FlowReached or Event.MeasurementCompleted </returns>
|
|
public Event Run()
|
|
{
|
|
if (runningOp == SelectedOp.SetFlow)
|
|
{
|
|
if (opCompleted || messageBoxForm.Completed)
|
|
{
|
|
opCompleted = true;
|
|
messageBoxForm = null;
|
|
return Event.FlowReached;
|
|
}
|
|
}
|
|
else if (runningOp == SelectedOp.QueryMeasurementEnd)
|
|
{
|
|
if (opCompleted) return Event.TestCompleted;
|
|
|
|
double currentMass = (Devices.Scale is IScale) ? (Devices.Scale as IScale).Mass : 0;
|
|
|
|
if (currentMass - TBF.Rig.Sequences.ProcessData.StartMass.Val >= currentTest.Volume)
|
|
{
|
|
opCompleted = true;
|
|
return Event.TestCompleted;
|
|
}
|
|
}
|
|
|
|
return Event.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop this operation
|
|
/// </summary>
|
|
public void Stop()
|
|
{
|
|
if (runningOp == SelectedOp.SetFlow)
|
|
{
|
|
if (messageBoxForm != null)
|
|
{
|
|
messageBoxForm.OnCloseThisForm(this, null);
|
|
messageBoxForm = null;
|
|
}
|
|
}
|
|
|
|
runningOp = SelectedOp.None;
|
|
opCompleted = false;
|
|
}
|
|
}
|
|
}
|