Bugfix FlowMeterInParallel and RegValve OUT OF RANGE regulation part1
This commit is contained in:
parent
c09e266b2c
commit
ff5954d85b
@ -175,8 +175,8 @@ namespace TBF.Rig.ControlBoard.Uni
|
||||
double reqFlowLo = (0.7 * qFrom) + (0.3 * reqFlowAve); /// Move the lower limit 15% of the range up
|
||||
double reqFlowHi = (0.7 * qTo) + (0.3 * reqFlowAve); /// Move the upper limit 15% of the range down
|
||||
///
|
||||
uniCB.SetFlow(false, regV.Idx1, 2000.0 * reqFlowLo / flowMeter.NominalFlow,
|
||||
2000.0 * reqFlowHi / flowMeter.NominalFlow);
|
||||
uniCB.SetFlow(false, regV.Idx1, flowMeter.NominalFreq * reqFlowLo / flowMeter.NominalFlow,
|
||||
flowMeter.NominalFreq * reqFlowHi / flowMeter.NominalFlow);
|
||||
if (readDivTransition)
|
||||
{
|
||||
/// Schedule reading diverter transition data
|
||||
|
||||
@ -803,12 +803,60 @@ namespace TBF.Rig.ControlBoard.Uni
|
||||
/// </summary>
|
||||
public void SetFlow(bool isFromUI, int regVId, double freqLo, double freqHi, int regulationMinStep = 0)
|
||||
{
|
||||
if (IsUIBlocked && isFromUI) return;
|
||||
LiveLogDiag.Log1("----------------------------------------");
|
||||
LiveLogDiag.Log1(
|
||||
"SetFlow() >> ENTER isFromUI={0} regVId={1} freqLo={2} freqHi={3} regulationMinStep={4} IsUIBlocked={5}",
|
||||
isFromUI, regVId, freqLo, freqHi, regulationMinStep, IsUIBlocked);
|
||||
|
||||
actionQueue.Enqueue(Action.SetFlow(isFromUI, regVId, freqLo, freqHi, Convert.ToInt32(Math.Round(Devices.PidCoef)), 200, regulationMinStep));
|
||||
log.InfoFormat("Enqueue( SetFlow(rv={0}, fLo={1}, fHi={2}, pid={3}) )", regVId, freqLo, freqHi, Convert.ToInt32(Math.Round(Devices.PidCoef)));
|
||||
if (IsUIBlocked && isFromUI)
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"SetFlow() >> EXIT (UI BLOCKED) isFromUI={0}",
|
||||
isFromUI);
|
||||
return;
|
||||
}
|
||||
|
||||
foreach (var a in actionQueue) log.DebugFormat(" {0}", a);
|
||||
int pid = Convert.ToInt32(Math.Round(Devices.PidCoef));
|
||||
int fixedParam = 200;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"SetFlow() >> PREPARE pid={0} fixedParam={1} regulationMinStep={2}",
|
||||
pid, fixedParam, regulationMinStep);
|
||||
|
||||
var action = Action.SetFlow(
|
||||
isFromUI,
|
||||
regVId,
|
||||
freqLo,
|
||||
freqHi,
|
||||
pid,
|
||||
fixedParam,
|
||||
regulationMinStep);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"SetFlow() >> ACTION CREATED: rv={0} fLo={1} fHi={2} pid={3} p6={4} minStep={5}",
|
||||
regVId, freqLo, freqHi, pid, fixedParam, regulationMinStep);
|
||||
|
||||
actionQueue.Enqueue(action);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"SetFlow() >> ENQUEUED actionQueue.Count={0}",
|
||||
actionQueue.Count);
|
||||
|
||||
log.InfoFormat(
|
||||
"Enqueue( SetFlow(rv={0}, fLo={1}, fHi={2}, pid={3}) )",
|
||||
regVId, freqLo, freqHi, pid);
|
||||
|
||||
int i = 0;
|
||||
foreach (var a in actionQueue)
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"SetFlow() >> QUEUE[{0}] = {1}",
|
||||
i++, a);
|
||||
log.DebugFormat(" {0}", a);
|
||||
}
|
||||
|
||||
LiveLogDiag.Log1("SetFlow() >> EXIT");
|
||||
LiveLogDiag.Log1("----------------------------------------");
|
||||
}
|
||||
|
||||
public void StartTest(bool isFromUI, int flowMId, int divId, int divThreshold,
|
||||
@ -981,5 +1029,18 @@ namespace TBF.Rig.ControlBoard.Uni
|
||||
{
|
||||
/// TODO
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Logging
|
||||
/// For activation use compilation condition: LIVELOGDIAG_FlowMeter_cs
|
||||
/// </summary>
|
||||
static class LiveLogDiag
|
||||
{
|
||||
[Conditional("LIVELOGDIAG_UniCB_cs")]
|
||||
public static void Log1(string format, params object[] args)
|
||||
{
|
||||
LiveLogCache.Instance.AddLog("UniCB.cs LOG>> " + string.Format(format, args));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,20 +6,21 @@ using TBF.Rig.Generic;
|
||||
|
||||
namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
{
|
||||
public class Factory : IComponentFactory
|
||||
{
|
||||
public class Factory : IComponentFactory
|
||||
{
|
||||
public string ClassName { get { return GetType().Namespace.Substring(12); } }
|
||||
public override string ToString() { return ClassName; }
|
||||
|
||||
public IComponent DummyComponent() { return new FlowMeter(); }
|
||||
public IComponent DummyComponent() { return new FlowMeter(); }
|
||||
|
||||
public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new FlowMeter(cfg, components); }
|
||||
public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new FlowMeter(cfg, components); }
|
||||
|
||||
public IComponentCfg DefaultConfig() { return new FlowMeterCfg(this, "I11+I12"); }
|
||||
public IComponentCfg DefaultConfig() { return new FlowMeterCfg(this, "I11+I12"); }
|
||||
|
||||
public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
|
||||
{
|
||||
return ComponentCfgBase.CreateFromDbEntity(FlowMeterCfg.Serializer, component, this);
|
||||
}
|
||||
}
|
||||
public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
|
||||
{
|
||||
return ComponentCfgBase.CreateFromDbEntity(FlowMeterCfg.Serializer, component, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,10 +1,12 @@
|
||||
///
|
||||
using log4net;
|
||||
using SchematicDrawing;
|
||||
using SharedComponents;
|
||||
///
|
||||
/// Copyright (c) 2021-2022 Sensus Slovensko a.s.
|
||||
///
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using log4net;
|
||||
using SchematicDrawing;
|
||||
using System.Diagnostics;
|
||||
using TBF.Boxes;
|
||||
using TBF.Rig.ControlBoard.Uni;
|
||||
using TBF.Rig.GenericDevices;
|
||||
@ -12,17 +14,16 @@ using TBF.Rig.GenericDevices;
|
||||
namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
{
|
||||
public class FlowMeter : ComponentBase, IFlowMeter, IDrawingItCmpntWithMeasuredVal
|
||||
{
|
||||
private static readonly ILog log = LogManager.GetLogger(typeof(FlowMeter));
|
||||
{
|
||||
private static readonly ILog log = LogManager.GetLogger(typeof(FlowMeter));
|
||||
public override string ToString() { return string.Format("{0}({1})", ClassName, Cfg.ToString(-1)); }
|
||||
|
||||
readonly FlowMeterCfg myCfg;
|
||||
readonly FlowMeterCfg flowMeterCfg;
|
||||
|
||||
UniCB uniCB;
|
||||
IFlowMeterSingle flowMtr1;
|
||||
IFlowMeterSingle flowMtr2;
|
||||
IFlowMeterSingle flowMtr3;
|
||||
IFlowMeterSingle inactiveFlowMtr;
|
||||
double nominalFlow;
|
||||
double nominalFreq;
|
||||
double ltrPerPulse;
|
||||
@ -34,22 +35,20 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
public double NominalFreq { get { return nominalFreq; } }
|
||||
public double LtrPerPulse { get { return ltrPerPulse; } }
|
||||
|
||||
public SchematicDrawing.IDrawingItem DrawingItem { get { return myCfg as SchematicDrawing.IDrawingItem; } }
|
||||
public string MsrdFormat { get { return myCfg.MsrdFormat; } }
|
||||
public Common.Unit MsrdUnit { get { return myCfg.MsrdUnit; } }
|
||||
public double MsrdValLimLo { get { return myCfg.MsrdValLimLo; } set { myCfg.MsrdValLimLo = value; } }
|
||||
public double MsrdValLimHi { get { return myCfg.MsrdValLimHi; } set { myCfg.MsrdValLimHi = value; } }
|
||||
|
||||
public SchematicDrawing.IDrawingItem DrawingItem { get { return flowMeterCfg as SchematicDrawing.IDrawingItem; } }
|
||||
public string MsrdFormat { get { return flowMeterCfg.MsrdFormat; } }
|
||||
public Common.Unit MsrdUnit { get { return flowMeterCfg.MsrdUnit; } }
|
||||
public double MsrdValLimLo { get { return flowMeterCfg.MsrdValLimLo; } set { flowMeterCfg.MsrdValLimLo = value; } }
|
||||
public double MsrdValLimHi { get { return flowMeterCfg.MsrdValLimHi; } set { flowMeterCfg.MsrdValLimHi = value; } }
|
||||
|
||||
public bool MsrmntAvailable
|
||||
{
|
||||
get
|
||||
{
|
||||
bool result = true;
|
||||
if (flowMtr1 != null) result = (result && flowMtr1.MsrmntAvailable);
|
||||
if (flowMtr2 != null) result = (result && flowMtr2.MsrmntAvailable);
|
||||
if (flowMtr3 != null) result = (result && flowMtr3.MsrmntAvailable);
|
||||
if (inactiveFlowMtr != null) result = (result && !inactiveFlowMtr.MsrmntAvailable);
|
||||
if (flowMtr1 != null) result = result && flowMtr1.MsrmntAvailable;
|
||||
if (flowMtr2 != null) result = result && flowMtr2.MsrmntAvailable;
|
||||
if (flowMtr3 != null) result = result && flowMtr3.MsrmntAvailable;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@ -61,26 +60,27 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
|
||||
public string AltString { get { return "Invalid format"; } }
|
||||
|
||||
public FlowMeter() { }
|
||||
|
||||
public FlowMeter() { }
|
||||
|
||||
public FlowMeter(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
|
||||
: base(cfg)
|
||||
{
|
||||
myCfg = cfg as FlowMeterCfg;
|
||||
}
|
||||
public FlowMeter(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
|
||||
: base(cfg)
|
||||
{
|
||||
flowMeterCfg = cfg as FlowMeterCfg;
|
||||
}
|
||||
|
||||
public override void Initialize()
|
||||
{
|
||||
uniCB = TbfComponents.FindComponent(myCfg.ParentName) as UniCB;
|
||||
uniCB = TbfComponents.FindComponent(flowMeterCfg.ParentName) as UniCB;
|
||||
if (uniCB == null) throw new Exception("Cannot find " + Name + " parent");
|
||||
|
||||
if (!string.IsNullOrEmpty(myCfg.Flowmeter1)) flowMtr1 = TbfComponents.FindComponent(myCfg.Flowmeter1) as IFlowMeterSingle;
|
||||
if (!string.IsNullOrEmpty(myCfg.Flowmeter2)) flowMtr2 = TbfComponents.FindComponent(myCfg.Flowmeter2) as IFlowMeterSingle;
|
||||
if (!string.IsNullOrEmpty(myCfg.Flowmeter3)) flowMtr3 = TbfComponents.FindComponent(myCfg.Flowmeter3) as IFlowMeterSingle;
|
||||
if (!string.IsNullOrEmpty(myCfg.InactiveFlowmtr)) inactiveFlowMtr = TbfComponents.FindComponent(myCfg.InactiveFlowmtr) as IFlowMeterSingle;
|
||||
if (!string.IsNullOrEmpty(flowMeterCfg.Flowmeter1)) flowMtr1 = TbfComponents.FindComponent(flowMeterCfg.Flowmeter1) as IFlowMeterSingle;
|
||||
if (!string.IsNullOrEmpty(flowMeterCfg.Flowmeter2)) flowMtr2 = TbfComponents.FindComponent(flowMeterCfg.Flowmeter2) as IFlowMeterSingle;
|
||||
if (!string.IsNullOrEmpty(flowMeterCfg.Flowmeter3)) flowMtr3 = TbfComponents.FindComponent(flowMeterCfg.Flowmeter3) as IFlowMeterSingle;
|
||||
|
||||
LiveLogDiag.Log1("{0} >> Initialize() >> ----------------------initialising------------------------", Name);
|
||||
|
||||
nominalFlow = 0;
|
||||
nominalFreq = 0;
|
||||
flowMetersCount = 0;
|
||||
flowMetersBitfield = 0;
|
||||
|
||||
@ -90,62 +90,122 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
nominalFreq += flowMtr1.NominalFreq;
|
||||
flowMetersBitfield |= (4 << flowMtr1.Idx1);
|
||||
flowMetersCount++;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Initialize() >> flowMtr1.NominalFlow = {1} m3/h flowMtr1.NominalFreq = {2} Hz",
|
||||
Name, flowMtr1.NominalFlow, flowMtr1.NominalFreq);
|
||||
}
|
||||
if (flowMtr2 != null)
|
||||
{
|
||||
|
||||
if (flowMtr2 != null)
|
||||
{
|
||||
nominalFlow += flowMtr2.NominalFlow;
|
||||
nominalFreq += flowMtr2.NominalFreq;
|
||||
flowMetersBitfield |= (4 << flowMtr2.Idx1);
|
||||
flowMetersCount++;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Initialize() >> flowMtr2.NominalFlow = {1} m3/h flowMtr2.NominalFreq = {2} Hz",
|
||||
Name, flowMtr2.NominalFlow, flowMtr2.NominalFreq);
|
||||
}
|
||||
|
||||
if (flowMtr3 != null)
|
||||
{
|
||||
nominalFlow += flowMtr3.NominalFlow;
|
||||
nominalFreq += flowMtr3.NominalFreq;
|
||||
flowMetersBitfield |= (4 << flowMtr3.Idx1);
|
||||
flowMetersCount++;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Initialize() >> flowMtr3.NominalFlow = {1} m3/h flowMtr3.NominalFreq = {2} Hz",
|
||||
Name, flowMtr3.NominalFlow, flowMtr3.NominalFreq);
|
||||
}
|
||||
|
||||
if (flowMetersCount == 0) throw new Exception("Missing flowmeters");
|
||||
|
||||
MsrdValLimHi = nominalFlow;
|
||||
|
||||
ltrPerPulse = nominalFlow / (3.6 * nominalFreq); /// Nominal freq. is sum of particular nominal frquencies
|
||||
ltrPerPulse = nominalFlow / (3.6 * nominalFreq);
|
||||
|
||||
log.FatalFormat("{0} initialized: {1} nom.flow={2} m3/h nom.freq={3} Hz bitfield=0x{4:X2}",
|
||||
Name, this, nominalFlow, nominalFreq, flowMetersBitfield);
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Initialize() >> nominalFlow = {1} m3/h nominalFreq = {2} Hz bitfield = 0x{3:X2} ltrPerPulse = {4}",
|
||||
Name, nominalFlow, nominalFreq, flowMetersBitfield, ltrPerPulse);
|
||||
|
||||
log.FatalFormat(
|
||||
"{0} initialized: nom.flow={1} m3/h nom.freq={2} Hz bitfield=0x{3:X2}",
|
||||
Name, nominalFlow, nominalFreq, flowMetersBitfield);
|
||||
}
|
||||
|
||||
public double ReadFlow()
|
||||
{
|
||||
return ReadFrequency() * nominalFlow / nominalFreq;
|
||||
double flowByNewFormulaSum = 0;
|
||||
|
||||
if (flowMtr1 != null)
|
||||
{
|
||||
double contrib1 = flowMtr1.NominalFlow * uniCB.Data.ReferenceFreq[flowMtr1.Idx1] / flowMtr1.NominalFreq;
|
||||
flowByNewFormulaSum += contrib1;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> ReadFlow() >> FM1: NominalFlow={1} m3/h RefFreq[1]={2} Hz NominalFreq={3} Hz Contribution={4} m3/h",
|
||||
Name, flowMtr1.NominalFlow, uniCB.Data.ReferenceFreq[1], flowMtr1.NominalFreq, contrib1);
|
||||
}
|
||||
|
||||
if (flowMtr2 != null)
|
||||
{
|
||||
double contrib2 = flowMtr2.NominalFlow * uniCB.Data.ReferenceFreq[flowMtr2.Idx1] / flowMtr2.NominalFreq;
|
||||
flowByNewFormulaSum += contrib2;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> ReadFlow() >> FM2: NominalFlow={1} m3/h RefFreq[2]={2} Hz NominalFreq={3} Hz Contribution={4} m3/h",
|
||||
Name, flowMtr2.NominalFlow, uniCB.Data.ReferenceFreq[2], flowMtr2.NominalFreq, contrib2);
|
||||
}
|
||||
|
||||
if (flowMtr3 != null)
|
||||
{
|
||||
double contrib3 = flowMtr3.NominalFlow * uniCB.Data.ReferenceFreq[flowMtr3.Idx1] / flowMtr3.NominalFreq;
|
||||
flowByNewFormulaSum += contrib3;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> ReadFlow() >> FM3: NominalFlow={1} m3/h RefFreq[3]={2} Hz NominalFreq={3} Hz Contribution={4} m3/h",
|
||||
Name, flowMtr3.NominalFlow, uniCB.Data.ReferenceFreq[3], flowMtr3.NominalFreq, contrib3);
|
||||
}
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> ReadFlow() >> return = flowByNewFormulaSum = {1} m3/h",
|
||||
Name, flowByNewFormulaSum);
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> FM1: Idx1={1}, RefFreq[1]={2}, RefFreq[Idx1]={3}",
|
||||
Name,
|
||||
flowMtr1.Idx1,
|
||||
uniCB.Data.ReferenceFreq[1],
|
||||
uniCB.Data.ReferenceFreq[flowMtr1.Idx1]);
|
||||
|
||||
return flowByNewFormulaSum;
|
||||
}
|
||||
|
||||
public double ReadFrequency()
|
||||
{
|
||||
return uniCB.RefFrequency;
|
||||
double freq = uniCB.RefFrequency;
|
||||
LiveLogDiag.Log1("{0} >> ReadFrequency() >> return = {1} Hz", Name, freq);
|
||||
return freq;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Events: FlowDone, Error
|
||||
/// </summary>
|
||||
/// <param name="flow">Reference to a variable for the flow in Bar</param>
|
||||
/// <returns>ReadFlowOp instance reference casted to IOperaton</returns>
|
||||
public IOperation ReadFlowOp(ref DoubleBox flow)
|
||||
{
|
||||
return new ReadFlowOp(this, ref flow);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Events: flowDone, Error
|
||||
/// </summary>
|
||||
/// <param name="flow">Reference to a variable for the flow in Bar</param>
|
||||
/// <param name="flowDone">Event returned when measurement done</param>
|
||||
/// <returns>ReadFlowOp instance reference casted to IOperaton</returns>
|
||||
public IOperation ReadFlowOp(ref DoubleBox flow, Event flowDone)
|
||||
{
|
||||
return new ReadFlowOp(this, ref flow, flowDone);
|
||||
}
|
||||
/// <summary>
|
||||
/// Events: FlowDone, Error
|
||||
/// </summary>
|
||||
public IOperation ReadFlowOp(ref DoubleBox flow)
|
||||
{
|
||||
LiveLogDiag.Log1("{0} >> ReadFlowOp(ref DoubleBox) >> operation created", Name);
|
||||
return new ReadFlowOp(this, ref flow);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Events: flowDone, Error
|
||||
/// </summary>
|
||||
public IOperation ReadFlowOp(ref DoubleBox flow, Event flowDone)
|
||||
{
|
||||
LiveLogDiag.Log1("{0} >> ReadFlowOp(ref DoubleBox, Event) >> operation created", Name);
|
||||
return new ReadFlowOp(this, ref flow, flowDone);
|
||||
}
|
||||
|
||||
double flowRawSum;
|
||||
double flowSum;
|
||||
@ -163,42 +223,98 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
if (flowMtr1 != null) rng1 = Math.Max(0, flowMtr1.GetRange(test.TempLimLo, test.TempLimHi));
|
||||
if (flowMtr2 != null) rng2 = Math.Max(0, flowMtr2.GetRange(test.TempLimLo, test.TempLimHi));
|
||||
if (flowMtr3 != null) rng3 = Math.Max(0, flowMtr3.GetRange(test.TempLimLo, test.TempLimHi));
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> StartStatistics() >> flowRawSum={1} flowSum={2} timeSum={3} rng1={4} rng2={5} rng3={6}",
|
||||
Name, flowRawSum, flowSum, timeSum, rng1, rng2, rng3);
|
||||
}
|
||||
|
||||
public void UpdateStatistics(int timeDelta)
|
||||
{
|
||||
double tempFlow;
|
||||
|
||||
if (flowMtr1 != null)
|
||||
{
|
||||
flowRawSum += timeDelta * (tempFlow = flowMtr1.ReadFlow());
|
||||
flowSum += timeDelta * flowMtr1.CorrectedFlow(tempFlow, rng1); ;
|
||||
tempFlow = flowMtr1.ReadFlow();
|
||||
flowRawSum += timeDelta * tempFlow;
|
||||
flowSum += timeDelta * flowMtr1.CorrectedFlow(tempFlow, rng1);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> UpdateStatistics() >> FM1: timeDelta={1} tempFlow={2} corrected={3}",
|
||||
Name, timeDelta, tempFlow, flowMtr1.CorrectedFlow(tempFlow, rng1));
|
||||
}
|
||||
|
||||
if (flowMtr2 != null)
|
||||
{
|
||||
flowRawSum += timeDelta * (tempFlow = flowMtr2.ReadFlow());
|
||||
flowSum += timeDelta * flowMtr2.CorrectedFlow(tempFlow, rng2); ;
|
||||
tempFlow = flowMtr2.ReadFlow();
|
||||
flowRawSum += timeDelta * tempFlow;
|
||||
flowSum += timeDelta * flowMtr2.CorrectedFlow(tempFlow, rng2);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> UpdateStatistics() >> FM2: timeDelta={1} tempFlow={2} corrected={3}",
|
||||
Name, timeDelta, tempFlow, flowMtr2.CorrectedFlow(tempFlow, rng2));
|
||||
}
|
||||
|
||||
if (flowMtr3 != null)
|
||||
{
|
||||
flowRawSum += timeDelta * (tempFlow = flowMtr3.ReadFlow());
|
||||
flowSum += timeDelta * flowMtr3.CorrectedFlow(tempFlow, rng3); ;
|
||||
tempFlow = flowMtr3.ReadFlow();
|
||||
flowRawSum += timeDelta * tempFlow;
|
||||
flowSum += timeDelta * flowMtr3.CorrectedFlow(tempFlow, rng3);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> UpdateStatistics() >> FM3: timeDelta={1} tempFlow={2} corrected={3}",
|
||||
Name, timeDelta, tempFlow, flowMtr3.CorrectedFlow(tempFlow, rng3));
|
||||
}
|
||||
|
||||
timeSum += timeDelta;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> UpdateStatistics() >> flowRawSum={1} flowSum={2} timeSum={3}",
|
||||
Name, flowRawSum, flowSum, timeSum);
|
||||
}
|
||||
|
||||
public void StopStatistics()
|
||||
{
|
||||
flowRawSum /= Convert.ToDouble(timeSum);
|
||||
flowSum /= Convert.ToDouble(timeSum);
|
||||
log.WarnFormat("StopStatistics() flowRawSum = {0:F3} m3/h flowSum = {1:F3} m3/h", flowRawSum, flowSum);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> StopStatistics() >> flowRawSum={1:F3} m3/h flowSum={2:F3} m3/h",
|
||||
Name, flowRawSum, flowSum);
|
||||
|
||||
log.WarnFormat(
|
||||
"StopStatistics() flowRawSum = {0:F3} m3/h flowSum = {1:F3} m3/h",
|
||||
flowRawSum, flowSum);
|
||||
}
|
||||
|
||||
public double LtrPerPulseCorrected(double flow, float temperature)
|
||||
{
|
||||
double ltrPerPulseCorrected = (flowRawSum == 0) ? LtrPerPulse : LtrPerPulse * flowSum / flowRawSum;
|
||||
log.WarnFormat("LtrPerPulseCorrected() flow = {0:F3} m3/h flowRawSum = {1:F3} m3/h flowSum = {2:F3} m3/h temperature = {3:F1} C ltrPerPulseCorrected = {4}", flow, flowRawSum, flowSum, temperature, ltrPerPulseCorrected);
|
||||
double ltrPerPulseCorrected = (flowRawSum == 0)
|
||||
? LtrPerPulse
|
||||
: LtrPerPulse * flowSum / flowRawSum;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> LtrPerPulseCorrected() >> flow={1} m3/h flowRawSum={2} flowSum={3} temperature={4} C ltrPerPulseCorrected={5}",
|
||||
Name, flow, flowRawSum, flowSum, temperature, ltrPerPulseCorrected);
|
||||
|
||||
log.WarnFormat(
|
||||
"LtrPerPulseCorrected() flow = {0} m3/h flowRawSum = {1} m3/h flowSum = {2} m3/h temperature = {3} C ltrPerPulseCorrected = {4}",
|
||||
flow, flowRawSum, flowSum, temperature, ltrPerPulseCorrected);
|
||||
|
||||
return ltrPerPulseCorrected;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Logging
|
||||
/// For activation use compilation condition: LIVELOGDIAG_FlowMeter_cs
|
||||
/// </summary>
|
||||
static class LiveLogDiag
|
||||
{
|
||||
[Conditional("LIVELOGDIAG_FlowMeter_cs")]
|
||||
public static void Log1(string format, params object[] args)
|
||||
{
|
||||
LiveLogCache.Instance.AddLog("FlowMeter.cs LOG>> " + string.Format(format, args));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -13,9 +13,9 @@ using TBF.Rig.Generic;
|
||||
namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
{
|
||||
public class FlowMeterCfg : ComponentCfgBase, IChildComponentCfg, IParamsProvider, IDrawingItemWithMeasuredVal
|
||||
{
|
||||
public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(FlowMeterCfg) })[0];
|
||||
public override XmlSerializer GetSerializer() { return Serializer; }
|
||||
{
|
||||
public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(FlowMeterCfg) })[0];
|
||||
public override XmlSerializer GetSerializer() { return Serializer; }
|
||||
|
||||
public IComponentCfgCtrl GetControl(IList<Config.Entities.Component> cmpntEntities)
|
||||
{
|
||||
@ -24,15 +24,14 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
return new Configs.ParamsProvider.ComponentCfgCtrl(this, parents);
|
||||
}
|
||||
|
||||
///
|
||||
/// Serialized parameters
|
||||
///
|
||||
///
|
||||
/// Serialized parameters
|
||||
///
|
||||
public string Flowmeter1; /// 0 Flowmeter component name or string.Empty
|
||||
public string Flowmeter2; /// 1 - ' ' -
|
||||
public string Flowmeter3; /// 2 - ' ' -
|
||||
public string InactiveFlowmtr; /// 3 Inactive flowmeter component name or string.Empty
|
||||
public string MsrdFormat { get; set; } /// 4
|
||||
public Unit MsrdUnit { get; set; } /// 5
|
||||
public string MsrdFormat { get; set; } /// 3
|
||||
public Unit MsrdUnit { get; set; } /// 4
|
||||
|
||||
/// Schematic drawing info
|
||||
public Shape Shape { get; set; }
|
||||
@ -55,12 +54,12 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
[XmlIgnore]
|
||||
public double MsrdValLimHi { get; set; }
|
||||
|
||||
|
||||
private IEnumerable<Config.Entities.Component> flowMeters;
|
||||
|
||||
[XmlIgnore]
|
||||
public bool IsOffline { get; set; }
|
||||
|
||||
|
||||
private IEnumerable<Config.Entities.Component> flowMeters;
|
||||
|
||||
/// Private parameterless constructor invoked by all other (public) constructors
|
||||
FlowMeterCfg()
|
||||
{
|
||||
@ -87,7 +86,6 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
Flowmeter1 = "I11";
|
||||
Flowmeter2 = "I12";
|
||||
Flowmeter3 = string.Empty;
|
||||
InactiveFlowmtr = "I13";
|
||||
MsrdFormat = "{0:F3} m3/h";
|
||||
MsrdUnit = Unit.m3ph;
|
||||
}
|
||||
@ -97,9 +95,8 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
"Flow meter 1", /// 0
|
||||
"Flow meter 2", /// 1
|
||||
"Flow meter 3", /// 2
|
||||
"Inactive flow meter", /// 3
|
||||
"Display format", /// 4
|
||||
"Unit of flow on a display", /// 5
|
||||
"Display format", /// 3
|
||||
"Unit of flow on a display", /// 4
|
||||
};
|
||||
public string ParamName(int i) { return paramNames[i]; }
|
||||
public int ParamsCount() { return paramNames.Length; }
|
||||
@ -111,48 +108,44 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
case 0:
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
if (flowMeters == null) return null;
|
||||
var fmtrs = new List<string>();
|
||||
foreach (var fmtr in flowMeters) fmtrs.Add(fmtr.Name);
|
||||
fmtrs.Add("---");
|
||||
return fmtrs;
|
||||
case 5:
|
||||
return new string[] { "m3/h", "l/h", "gal/m" };
|
||||
case 4:
|
||||
return new string[] { "m3/h", "l/h" };
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public string ToString(int i)
|
||||
{
|
||||
public string ToString(int i)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: return string.IsNullOrEmpty(Flowmeter1) ? "---" : Flowmeter1;
|
||||
case 1: return string.IsNullOrEmpty(Flowmeter2) ? "---" : Flowmeter2;
|
||||
case 2: return string.IsNullOrEmpty(Flowmeter3) ? "---" : Flowmeter3;
|
||||
case 3: return string.IsNullOrEmpty(InactiveFlowmtr) ? "---" : InactiveFlowmtr;
|
||||
case 4: return MsrdFormat;
|
||||
case 5: return MsrdUnit.ToDescription();
|
||||
case 3: return MsrdFormat;
|
||||
case 4: return MsrdUnit.ToDescription();
|
||||
|
||||
default:
|
||||
return string.Format("Name={0} {1} {2} {3} ~{4} fmt={5} unit={6} Lo={7} Hi={8}",
|
||||
Name, Flowmeter1, Flowmeter2, Flowmeter3, InactiveFlowmtr,
|
||||
return string.Format("Name={0} {1} {2} {3} fmt={4} unit={5} Lo={6} Hi={7}",
|
||||
Name, Flowmeter1, Flowmeter2, Flowmeter3,
|
||||
MsrdFormat, MsrdUnit.ToDescription(), MsrdValLimLo, MsrdValLimHi);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public CfgUpdateFlags UpdateParam(int i, string str)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: Flowmeter1 = (str != "---") ? str : string.Empty; return CfgUpdateFlags.RestartRqrd;
|
||||
case 1: Flowmeter2 = (str != "---") ? str : string.Empty; return CfgUpdateFlags.RestartRqrd;
|
||||
case 2: Flowmeter3 = (str != "---") ? str : string.Empty; return CfgUpdateFlags.RestartRqrd;
|
||||
case 3: InactiveFlowmtr = (str != "---") ? str : string.Empty; return CfgUpdateFlags.RestartRqrd;
|
||||
case 4: MsrdFormat = str; return CfgUpdateFlags.RestartRqrd;
|
||||
//case 5: MsrdUnit = (str == "l/h") ? Unit.lph : Unit.m3ph; return CfgUpdateFlags.RestartRqrd;
|
||||
case 5: MsrdUnit = ParseFlowUnit(str); return CfgUpdateFlags.RestartRqrd;
|
||||
case 0: Flowmeter1 = (str != "---") ? str : string.Empty; return CfgUpdateFlags.RestartRqrd;
|
||||
case 1: Flowmeter2 = (str != "---") ? str : string.Empty; return CfgUpdateFlags.RestartRqrd;
|
||||
case 2: Flowmeter3 = (str != "---") ? str : string.Empty; return CfgUpdateFlags.RestartRqrd;
|
||||
case 3: MsrdFormat = str; return CfgUpdateFlags.RestartRqrd;
|
||||
case 4: MsrdUnit = (str == "l/h") ? Unit.lph : Unit.m3ph; return CfgUpdateFlags.RestartRqrd;
|
||||
default:
|
||||
return CfgUpdateFlags.None;
|
||||
}
|
||||
@ -167,11 +160,10 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
case 0:
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
case 5:
|
||||
case 4:
|
||||
if (ParamValues(i).Contains(str)) return true;
|
||||
break;
|
||||
case 4:
|
||||
case 3:
|
||||
return true;
|
||||
default:
|
||||
message = "Invalid index";
|
||||
@ -187,7 +179,6 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
prms.Flowmeter1 = this.Flowmeter1;
|
||||
prms.Flowmeter2 = this.Flowmeter2;
|
||||
prms.Flowmeter3 = this.Flowmeter3;
|
||||
prms.InactiveFlowmtr = this.InactiveFlowmtr;
|
||||
prms.MsrdFormat = this.MsrdFormat;
|
||||
prms.MsrdUnit = this.MsrdUnit;
|
||||
}
|
||||
@ -203,19 +194,5 @@ namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
{
|
||||
return true; /// =OK, do nothing
|
||||
}
|
||||
public static Unit ParseFlowUnit(string str)
|
||||
{
|
||||
//Check if the string is a valid unit description
|
||||
Unit fromDescription = Units.FromDescription(str);
|
||||
if (fromDescription != Unit.None) return fromDescription;
|
||||
//check if the string is a valid unit name
|
||||
switch (str)
|
||||
{
|
||||
case "l/h": return Unit.lph;
|
||||
case "gal/m": return Unit.USgalpm;
|
||||
case "m3/h":
|
||||
default: return Unit.m3ph;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -8,57 +8,57 @@ using TBF.Rig.GenericDevices;
|
||||
|
||||
namespace TBF.Rig.Uni.FlowMetersInParallel
|
||||
{
|
||||
public class ReadFlowOp : IOperation
|
||||
{
|
||||
private static readonly ILog log = LogManager.GetLogger(typeof(ReadFlowOp));
|
||||
public class ReadFlowOp : IOperation
|
||||
{
|
||||
private static readonly ILog log = LogManager.GetLogger(typeof(ReadFlowOp));
|
||||
public override string ToString() { return string.Format("ReadFlowOp({0},.,.,{1})", flowMeter.Idx1, eventDone); }
|
||||
|
||||
/// Set by the constructor
|
||||
/// Set by the constructor
|
||||
readonly IFlowMeter flowMeter;
|
||||
readonly DoubleBox flowBox;
|
||||
readonly Event eventDone;
|
||||
readonly DoubleBox flowBox;
|
||||
readonly Event eventDone;
|
||||
|
||||
/// <summary>
|
||||
/// Events: FlowInDone, FlowOutDone or Error
|
||||
/// </summary>
|
||||
/// <param name="flowMeter">Flow meter reference</param>
|
||||
/// <param name="flowBox">Reference to the measured flow variable, value is in bar</param>
|
||||
/// <param name="eventDone">Event to be returned by Run() when completed OK</param>
|
||||
/// <summary>
|
||||
/// Events: FlowInDone, FlowOutDone or Error
|
||||
/// </summary>
|
||||
/// <param name="flowMeter">Flow meter reference</param>
|
||||
/// <param name="flowBox">Reference to the measured flow variable, value is in bar</param>
|
||||
/// <param name="eventDone">Event to be returned by Run() when completed OK</param>
|
||||
public ReadFlowOp(IFlowMeter flowMeter, ref DoubleBox flowBox, Event eventDone)
|
||||
{
|
||||
if (flowMeter == null) throw new ArgumentNullException();
|
||||
|
||||
this.flowMeter = flowMeter;
|
||||
this.eventDone = eventDone;
|
||||
this.flowBox = flowBox;
|
||||
this.eventDone = eventDone;
|
||||
this.flowBox = flowBox;
|
||||
|
||||
log.Debug(this.ToString());
|
||||
log.Debug(this.ToString());
|
||||
}
|
||||
|
||||
public ReadFlowOp(IFlowMeter flowMeter, ref DoubleBox flowBox)
|
||||
: this(flowMeter, ref flowBox, Event.FlowMeasurementDone)
|
||||
{
|
||||
}
|
||||
: this(flowMeter, ref flowBox, Event.FlowMeasurementDone)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>Start this operation</summary>
|
||||
public void Start() { }
|
||||
/// <summary>Start this operation</summary>
|
||||
public void Start() { }
|
||||
|
||||
/// <summary>Run this operation</summary>
|
||||
/// <returns>
|
||||
/// Event.FlowInDone or Event.FlowOutDone
|
||||
/// </returns>
|
||||
public Event Run()
|
||||
{
|
||||
/// <summary>Run this operation</summary>
|
||||
/// <returns>
|
||||
/// Event.FlowInDone or Event.FlowOutDone
|
||||
/// </returns>
|
||||
public Event Run()
|
||||
{
|
||||
if (flowMeter.MsrmntAvailable)
|
||||
{
|
||||
{
|
||||
if (flowBox != null) flowBox.Val = flowMeter.ReadFlow();
|
||||
return eventDone;
|
||||
}
|
||||
return eventDone;
|
||||
}
|
||||
|
||||
return Event.Error;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Stop this operation</summary>
|
||||
public void Stop() { }
|
||||
}
|
||||
/// <summary>Stop this operation</summary>
|
||||
public void Stop() { }
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,28 +1,28 @@
|
||||
///
|
||||
/// Copyright (c) 2021 Sensus Slovensko a.s.
|
||||
///
|
||||
using Config.Entities;
|
||||
using log4net;
|
||||
using SharedComponents;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using log4net;
|
||||
using Config.Entities;
|
||||
using System.Diagnostics;
|
||||
using TBF.Boxes;
|
||||
using TBF.Rig.ControlBoard.Uni;
|
||||
using TBF.Rig.GenericDevices;
|
||||
using TBF.Boxes;
|
||||
|
||||
namespace TBF.Rig.Uni.RegValve
|
||||
{
|
||||
public class SetFlowOp : IOperation
|
||||
{
|
||||
private static readonly ILog log = LogManager.GetLogger(typeof(SetFlowOp));
|
||||
public override string ToString()
|
||||
{
|
||||
return string.Format("SetFlowOp({0}, Qfrom={1}, Qto={2})", regV.Name, shrinkedTgtFlowLo, shrinkedTgtFlowHi);
|
||||
}
|
||||
public class SetFlowOp : IOperation
|
||||
{
|
||||
private static readonly ILog log = LogManager.GetLogger(typeof(SetFlowOp));
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
return string.Format("SetFlowOp({0}, Qfrom={1}, Qto={2})", regV.Name, shrinkedTgtFlowLo, shrinkedTgtFlowHi);
|
||||
}
|
||||
|
||||
public const double RqrdFlowRangeRatio = 0.5;
|
||||
|
||||
///
|
||||
/// Set by the constructor
|
||||
/// Set by the constructor
|
||||
///
|
||||
readonly UniCB uniCB;
|
||||
readonly RegValve regV;
|
||||
@ -36,22 +36,22 @@ namespace TBF.Rig.Uni.RegValve
|
||||
|
||||
readonly double maximalFlow;
|
||||
|
||||
///
|
||||
/// Internal state of this operation
|
||||
///
|
||||
enum OpState
|
||||
{
|
||||
Idle = 0,
|
||||
ValveMoveToPosition1, /// Wait 1 takt
|
||||
ValveMoveToPosition2, /// This is actual move to position
|
||||
ValveMoveToPosition3, /// Wait 1 takt
|
||||
SettingPosition,
|
||||
Wait4FlowMsrmntAndSendRVMove, /// Wait until the flow measurement starts, then issue reg. valve move command
|
||||
SettingFlow, /// Measure the flow and verify whether it is within limits sufficiently long time
|
||||
FlowReached,
|
||||
SendCommandAgain,
|
||||
}
|
||||
OpState opState;
|
||||
///
|
||||
/// Internal state of this operation
|
||||
///
|
||||
enum OpState
|
||||
{
|
||||
Idle = 0,
|
||||
ValveMoveToPosition1,
|
||||
ValveMoveToPosition2,
|
||||
ValveMoveToPosition3,
|
||||
SettingPosition,
|
||||
Wait4FlowMsrmntAndSendRVMove,
|
||||
SettingFlow,
|
||||
FlowReached,
|
||||
SendCommandAgain,
|
||||
}
|
||||
OpState opState;
|
||||
|
||||
double currentReqFlowLo;
|
||||
double currentReqFlowHi;
|
||||
@ -60,32 +60,29 @@ namespace TBF.Rig.Uni.RegValve
|
||||
|
||||
int setFlowTime;
|
||||
int expireTime;
|
||||
DoubleBox msrdFlow;
|
||||
DoubleBox msrdFlow;
|
||||
int isFlowOkDuration;
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// <summary>
|
||||
/// Set required water flow. Conditionally leave the measurement running.
|
||||
/// Events: FlowSet, FlowTimeOut
|
||||
/// </summary>
|
||||
/// <param name="uniCB">Control board device</param>
|
||||
/// <param name="regValve">Regulation valve component</param>
|
||||
/// <param name="flowMeter">Flowmeter component</param>
|
||||
/// <param name="qFrom">Lower limit of the flow to be achieved in [m3/h]</param>
|
||||
/// <param name="qTo">Upper limit of the flow to be achieved in [m3/h]</param>
|
||||
/// <param name="msrdFlow">DoubleBox for measured flow</param>
|
||||
/// <param name="timeout">Timeout for the flow setting in [s]</param>
|
||||
/// <param name="delay">Flow setting starts after this delay in [s]</param>
|
||||
/// <param name="leaveFlowControlRunning">true = Leave the measurement running after op. stop</param>
|
||||
/// <remarks>Only Elde.Valve flow are used, other flow on the lists are ignored</remarks>
|
||||
public SetFlowOp(UniCB uniCB, IRegValve regValve, IFlowMeter flowMeter, double qFrom, double qTo, DoubleBox msrdFlow,
|
||||
int timeout, int delay, bool leaveFlowControlRunning)
|
||||
/// Events: FlowSet, FlowTimeOut
|
||||
/// </summary>
|
||||
public SetFlowOp(
|
||||
UniCB uniCB,
|
||||
IRegValve regValve,
|
||||
IFlowMeter flowMeter,
|
||||
double qFrom,
|
||||
double qTo,
|
||||
DoubleBox msrdFlow,
|
||||
int timeout,
|
||||
int delay,
|
||||
bool leaveFlowControlRunning)
|
||||
{
|
||||
this.uniCB = uniCB;
|
||||
this.uniCB = uniCB;
|
||||
if (this.uniCB == null) throw new ArgumentNullException("Control board is null or not Uni");
|
||||
|
||||
this.regV = regValve as RegValve;
|
||||
if (this.regV == null) throw new ArgumentNullException(string.Format("{0} is not Uni.RegValve", regValve.Name));
|
||||
if (this.regV == null) throw new ArgumentNullException(string.Format("{0} is not Uni.RegValve", regValve.Name));
|
||||
|
||||
this.flowMeter = flowMeter;
|
||||
if (this.flowMeter == null) throw new ArgumentNullException("flowMeter");
|
||||
@ -96,242 +93,397 @@ namespace TBF.Rig.Uni.RegValve
|
||||
double rqrdFlowHiBeforeCorr = qTo - MeasurementCorrection.GetCorrection(qTo, flowMeter.Corrections);
|
||||
targetFlowAve = (rqrdFlowLoBeforeCorr + rqrdFlowHiBeforeCorr) / 2;
|
||||
shrinkedTgtFlowLo = (RqrdFlowRangeRatio * rqrdFlowLoBeforeCorr)
|
||||
+ ((1 - RqrdFlowRangeRatio) * targetFlowAve); /// Move the lower limit 15% of the range up
|
||||
+ ((1 - RqrdFlowRangeRatio) * targetFlowAve);
|
||||
shrinkedTgtFlowHi = (RqrdFlowRangeRatio * rqrdFlowHiBeforeCorr)
|
||||
+ ((1 - RqrdFlowRangeRatio) * targetFlowAve); /// Move the upper limit 15% of the range down
|
||||
+ ((1 - RqrdFlowRangeRatio) * targetFlowAve);
|
||||
|
||||
this.msrdFlow = msrdFlow;
|
||||
this.timeout = timeout;
|
||||
this.delay = delay;
|
||||
this.leaveFlowControlRunning = leaveFlowControlRunning;
|
||||
|
||||
log.Debug(this.ToString());
|
||||
log.Debug(this.ToString());
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> CTOR() >> qFrom={1} qTo={2} rqrdFlowLoBeforeCorr={3} rqrdFlowHiBeforeCorr={4} targetFlowAve={5} shrinkedTgtFlowLo={6} shrinkedTgtFlowHi={7} nominalFlow={8} nominalFreq={9} maximalFlow={10} delay={11} timeout={12} leaveFlowControlRunning={13}",
|
||||
regV.Name, qFrom, qTo, rqrdFlowLoBeforeCorr, rqrdFlowHiBeforeCorr, targetFlowAve,
|
||||
shrinkedTgtFlowLo, shrinkedTgtFlowHi, flowMeter.NominalFlow, flowMeter.NominalFreq,
|
||||
maximalFlow, delay, timeout, leaveFlowControlRunning);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set required water flow - Do not leave the measurement running.
|
||||
/// Events: FlowSet
|
||||
/// </summary>
|
||||
public SetFlowOp(UniCB uniCB, IRegValve regValve, IFlowMeter flowMeter, double qFrom, double qTo, DoubleBox flowbox, int timeout, int delay)
|
||||
: this(uniCB, regValve, flowMeter, qFrom, qTo, flowbox, timeout, delay, false)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set required water flow - Do not leave the measurement running.
|
||||
/// Events: FlowSet
|
||||
/// </summary>
|
||||
public SetFlowOp(UniCB uniCB, IRegValve regValve, IFlowMeter flowMeter, double qFrom, double qTo, DoubleBox flowbox, int timeout)
|
||||
: this(uniCB, regValve, flowMeter, qFrom, qTo, flowbox, timeout, 0, false)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set required water flow - No timeout.
|
||||
/// Events: FlowSet
|
||||
/// </summary>
|
||||
public SetFlowOp(UniCB uniCB, IRegValve regValve, IFlowMeter flowMeter, double qFrom, double qTo, DoubleBox flowbox)
|
||||
: this(uniCB, regValve, flowMeter, qFrom, qTo, flowbox, int.MaxValue, 0, false)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <summary>
|
||||
/// Fetch target position limits from the dictionary or return false
|
||||
/// </summary>
|
||||
/// <param name="avgReqFlow">Average of the flow targer range (input)</param>
|
||||
/// <param name="positionLo">Target valve position low limit (output)</param>
|
||||
/// <param name="positionHi">Target valve position high limit (output)</param>
|
||||
/// <returns>true when positions for the target flow are stored in the memory, otherwise return false</returns>
|
||||
/// </summary>
|
||||
bool FetchTargetPosition(double avgReqFlow, out double positionLo, out double positionHi)
|
||||
{
|
||||
{
|
||||
double targetPosition;
|
||||
if (regV.Dict.TryGetValue(avgReqFlow, out targetPosition))
|
||||
{
|
||||
positionLo = Math.Max(targetPosition * 0.95, 0.0);
|
||||
positionHi = Math.Min(targetPosition * 1.05, 100.0);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
positionLo = 0;
|
||||
positionHi = 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (regV.Dict.TryGetValue(avgReqFlow, out targetPosition))
|
||||
{
|
||||
positionLo = Math.Max(targetPosition * 0.95, 0.0);
|
||||
positionHi = Math.Min(targetPosition * 1.05, 100.0);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> FetchTargetPosition() >> avgReqFlow={1} FOUND targetPosition={2} positionLo={3} positionHi={4}",
|
||||
regV.Name, avgReqFlow, targetPosition, positionLo, positionHi);
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
positionLo = 0;
|
||||
positionHi = 0;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> FetchTargetPosition() >> avgReqFlow={1} NOT FOUND",
|
||||
regV.Name, avgReqFlow);
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void StoreTargetPosition(double avgReqFlow, double actPosition)
|
||||
{
|
||||
if (!regV.Dict.ContainsKey(targetFlowAve))
|
||||
{
|
||||
regV.Dict.Add(new KeyValuePair<double, double>(avgReqFlow, actPosition));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/// <summary>Start this operation</summary>
|
||||
public void Start()
|
||||
{
|
||||
log.InfoFormat("SetFlowOp:Start() rv#={0} flowMtr#={1} TARGET: flowLo={2} flowHi={3}",
|
||||
regV.Idx1, flowMeter.Idx1, currentReqFlowLo, currentReqFlowHi);
|
||||
if (!regV.Dict.ContainsKey(targetFlowAve))
|
||||
{
|
||||
regV.Dict.Add(new KeyValuePair<double, double>(avgReqFlow, actPosition));
|
||||
|
||||
/// Store the current time, etc.
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> StoreTargetPosition() >> STORED avgReqFlow={1} actPosition={2}",
|
||||
regV.Name, avgReqFlow, actPosition);
|
||||
}
|
||||
else
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> StoreTargetPosition() >> SKIPPED because targetFlowAve={1} already exists in Dict",
|
||||
regV.Name, targetFlowAve);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/// <summary>Start this operation</summary>
|
||||
public void Start()
|
||||
{
|
||||
setFlowTime = StateMachine.Time + delay;
|
||||
expireTime = StateMachine.Time + timeout;
|
||||
if (expireTime < 0) expireTime = int.MaxValue;
|
||||
|
||||
isFlowOkDuration = 0;
|
||||
currentReqFlowLo = 0;
|
||||
currentReqFlowHi = 0;
|
||||
|
||||
log.InfoFormat(
|
||||
"SetFlowOp:Start() rv#={0} flowMtr#={1} TARGET_SHRINKED: flowLo={2} flowHi={3}",
|
||||
regV.Idx1, flowMeter.Idx1, shrinkedTgtFlowLo, shrinkedTgtFlowHi);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Start() >> rv#={1} flowMtr#={2} setFlowTime={3} expireTime={4} delay={5} timeout={6} shrinkedTgtFlowLo={7} shrinkedTgtFlowHi={8} targetFlowAve={9} nominalFlow={10} nominalFreq={11}",
|
||||
regV.Name, regV.Idx1, flowMeter.Idx1, setFlowTime, expireTime, delay, timeout,
|
||||
shrinkedTgtFlowLo, shrinkedTgtFlowHi, targetFlowAve, flowMeter.NominalFlow, flowMeter.NominalFreq);
|
||||
|
||||
/// Start the flow measurement
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Start() >> calling uniCB.MeasureFlow(false, flowMeter.Idx1={1})",
|
||||
regV.Name, flowMeter.Idx1);
|
||||
|
||||
uniCB.MeasureFlow(false, flowMeter.Idx1);
|
||||
|
||||
opState = OpState.Wait4FlowMsrmntAndSendRVMove;
|
||||
}
|
||||
opState = OpState.Wait4FlowMsrmntAndSendRVMove;
|
||||
|
||||
/// <summary>
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Start() >> opState={1}",
|
||||
regV.Name, opState);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Run this operation
|
||||
/// </summary>
|
||||
/// <returns>
|
||||
/// Event.OpArgumentError
|
||||
/// Event.Starting
|
||||
/// Event.Busy
|
||||
/// Event.FlowReached
|
||||
/// Event.RegulValveTimeOut
|
||||
/// </returns>
|
||||
public Event Run()
|
||||
{
|
||||
public Event Run()
|
||||
{
|
||||
log.DebugFormat("Op.Run() opState={0}", opState);
|
||||
|
||||
if (StateMachine.Time > expireTime) return Event.RegulValveTimeOut;
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> time={1} opState={2} currentReqFlowLo={3} currentReqFlowHi={4} isFlowOkDuration={5}",
|
||||
regV.Name, StateMachine.Time, opState, currentReqFlowLo, currentReqFlowHi, isFlowOkDuration);
|
||||
|
||||
if (StateMachine.Time > expireTime)
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> TIMEOUT: StateMachine.Time={1} > expireTime={2}",
|
||||
regV.Name, StateMachine.Time, expireTime);
|
||||
|
||||
return Event.RegulValveTimeOut;
|
||||
}
|
||||
|
||||
if (opState == OpState.Wait4FlowMsrmntAndSendRVMove)
|
||||
{
|
||||
if (!flowMeter.MsrmntAvailable) return Event.Starting;
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> Wait4FlowMsrmntAndSendRVMove: MsrmntAvailable={1}",
|
||||
regV.Name, flowMeter.MsrmntAvailable);
|
||||
|
||||
if (!flowMeter.MsrmntAvailable)
|
||||
return Event.Starting;
|
||||
|
||||
double flow1 = flowMeter.ReadFlow();
|
||||
|
||||
/// Set the targer flow/frequency range
|
||||
currentReqFlowLo = shrinkedTgtFlowLo; /// Default lower limit
|
||||
currentReqFlowHi = shrinkedTgtFlowHi; /// Default upper limit
|
||||
//if (flow1 >= targetFlowAve) currentReqFlowHi = targetFlowAve; /// Decrease upper limit
|
||||
//if (flow1 <= targetFlowAve) currentReqFlowLo = targetFlowAve; /// Increase lower limit
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> Wait4FlowMsrmntAndSendRVMove: initial measured flow1={1}",
|
||||
regV.Name, flow1);
|
||||
|
||||
/// Set the target flow/frequency range
|
||||
currentReqFlowLo = shrinkedTgtFlowLo;
|
||||
currentReqFlowHi = shrinkedTgtFlowHi;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> target range assigned: currentReqFlowLo={1} currentReqFlowHi={2} maximalFlow={3}",
|
||||
regV.Name, currentReqFlowLo, currentReqFlowHi, maximalFlow);
|
||||
|
||||
//if (flow1 >= targetFlowAve) currentReqFlowHi = targetFlowAve;
|
||||
//if (flow1 <= targetFlowAve) currentReqFlowLo = targetFlowAve;
|
||||
|
||||
if ((currentReqFlowLo >= currentReqFlowHi) || (currentReqFlowLo > maximalFlow) || (currentReqFlowHi <= 0))
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> OpArgumentError: currentReqFlowLo={1} currentReqFlowHi={2} maximalFlow={3}",
|
||||
regV.Name, currentReqFlowLo, currentReqFlowHi, maximalFlow);
|
||||
|
||||
return Event.OpArgumentError;
|
||||
}
|
||||
|
||||
if (StateMachine.Time > setFlowTime)
|
||||
{
|
||||
uniCB.SetFlow(false, regV.Idx1, flowMeter.NominalFreq * currentReqFlowLo / flowMeter.NominalFlow,
|
||||
flowMeter.NominalFreq * currentReqFlowHi / flowMeter.NominalFlow);
|
||||
double freqLo = flowMeter.NominalFreq * currentReqFlowLo / flowMeter.NominalFlow;
|
||||
double freqHi = flowMeter.NominalFreq * currentReqFlowHi / flowMeter.NominalFlow;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> calling uniCB.SetFlow(false, rv#={1}, freqLo={2}, freqHi={3}) from nominalFreq={4}, nominalFlow={5}, flowLo={6}, flowHi={7}",
|
||||
regV.Name, regV.Idx1, freqLo, freqHi, flowMeter.NominalFreq, flowMeter.NominalFlow, currentReqFlowLo, currentReqFlowHi);
|
||||
|
||||
uniCB.SetFlow(false, regV.Idx1, freqLo, freqHi);
|
||||
|
||||
log.InfoFormat("Run(): rv#={0} TARGET: flowLo={1} flowHi={2}", regV.Idx1, currentReqFlowLo, currentReqFlowHi);
|
||||
|
||||
opState = OpState.SettingFlow;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> opState changed to {1}",
|
||||
regV.Name, opState);
|
||||
}
|
||||
else
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> waiting for delay: StateMachine.Time={1}, setFlowTime={2}",
|
||||
regV.Name, StateMachine.Time, setFlowTime);
|
||||
}
|
||||
|
||||
return Event.Starting;
|
||||
}
|
||||
|
||||
if (opState == OpState.ValveMoveToPosition1)
|
||||
{
|
||||
opState = OpState.ValveMoveToPosition2;
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.ValveMoveToPosition2) /// Move to position
|
||||
{
|
||||
/// Issues the appropriate ValveMove(...) command
|
||||
regV.MoveToPosition(false, targetPositionLo, targetPositionHi);
|
||||
if (opState == OpState.ValveMoveToPosition1)
|
||||
{
|
||||
LiveLogDiag.Log1("{0} >> Run() >> ValveMoveToPosition1 -> ValveMoveToPosition2", regV.Name);
|
||||
opState = OpState.ValveMoveToPosition2;
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.ValveMoveToPosition2)
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> ValveMoveToPosition2: MoveToPosition(targetPositionLo={1}, targetPositionHi={2})",
|
||||
regV.Name, targetPositionLo, targetPositionHi);
|
||||
|
||||
regV.MoveToPosition(false, targetPositionLo, targetPositionHi);
|
||||
|
||||
opState = OpState.SettingPosition;
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.ValveMoveToPosition3)
|
||||
{
|
||||
opState = OpState.SettingPosition;
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.SettingPosition)
|
||||
{
|
||||
/// Repeated untill position is reached
|
||||
|
||||
LiveLogDiag.Log1("{0} >> Run() >> opState changed to {1}", regV.Name, opState);
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.ValveMoveToPosition3)
|
||||
{
|
||||
LiveLogDiag.Log1("{0} >> Run() >> ValveMoveToPosition3 -> SettingPosition", regV.Name);
|
||||
|
||||
opState = OpState.SettingPosition;
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.SettingPosition)
|
||||
{
|
||||
double rvPosition = regV.Position;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> SettingPosition: rvPosition={1}, targetPositionLo={2}, targetPositionHi={3}",
|
||||
regV.Name, rvPosition, targetPositionLo, targetPositionHi);
|
||||
|
||||
if ((targetPositionLo <= rvPosition) && (rvPosition <= targetPositionHi))
|
||||
{
|
||||
opState = OpState.Wait4FlowMsrmntAndSendRVMove;
|
||||
}
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.SettingFlow)
|
||||
{
|
||||
/// Regulation valve is setting flow to the required value
|
||||
///
|
||||
{
|
||||
opState = OpState.Wait4FlowMsrmntAndSendRVMove;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> position reached, opState changed to {1}",
|
||||
regV.Name, opState);
|
||||
}
|
||||
|
||||
return Event.Starting;
|
||||
}
|
||||
else if (opState == OpState.SettingFlow)
|
||||
{
|
||||
double frequency = flowMeter.ReadFrequency();
|
||||
double flow = flowMeter.ReadFlow();
|
||||
if (msrdFlow != null && flow != 0) msrdFlow.Val = flow;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> SettingFlow: frequency={1} flow={2} reqLo={3} reqHi={4}",
|
||||
regV.Name, frequency, flow, currentReqFlowLo, currentReqFlowHi);
|
||||
|
||||
if (msrdFlow != null && flow != 0)
|
||||
{
|
||||
msrdFlow.Val = flow;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> SettingFlow: msrdFlow.Val updated to {1}",
|
||||
regV.Name, msrdFlow.Val);
|
||||
}
|
||||
|
||||
if (currentReqFlowLo <= flow && flow <= currentReqFlowHi)
|
||||
{
|
||||
isFlowOkDuration++; /// Increment the flow within range duration
|
||||
{
|
||||
isFlowOkDuration++;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> SettingFlow: flow IN RANGE, isFlowOkDuration={1}/{2}",
|
||||
regV.Name, isFlowOkDuration, regV.FlowStableSec);
|
||||
|
||||
if (isFlowOkDuration >= regV.FlowStableSec)
|
||||
{
|
||||
/// Flow is within range for sufficiently long time
|
||||
{
|
||||
if (regV.StoredPositionReuse)
|
||||
{
|
||||
double rvPosition = regV.Position; /// Read the current position
|
||||
{
|
||||
double rvPosition = regV.Position;
|
||||
double storedPosition;
|
||||
if (regV.Dict.TryGetValue(targetFlowAve, out storedPosition))
|
||||
{
|
||||
/// update the stored valve position
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> StoredPositionReuse ON: rvPosition={1} targetFlowAve={2}",
|
||||
regV.Name, rvPosition, targetFlowAve);
|
||||
|
||||
if (regV.Dict.TryGetValue(targetFlowAve, out storedPosition))
|
||||
{
|
||||
StoreTargetPosition(targetFlowAve, (rvPosition + storedPosition) / 2.0);
|
||||
log.InfoFormat("Run(): rv#={0} reqFlow={1} pos={2}% stored={3} <--- Updating a stored position",
|
||||
regV.Idx1, targetFlowAve, rvPosition.ToString("F1"), storedPosition);
|
||||
}
|
||||
else
|
||||
{
|
||||
/// store the valve position
|
||||
StoreTargetPosition(targetFlowAve, rvPosition);
|
||||
log.InfoFormat("Run(): rv#={0} reqFlow={1} pos={2}% <--- Storing a new position",
|
||||
regV.Idx1, targetFlowAve, rvPosition.ToString("F1"));
|
||||
}
|
||||
}
|
||||
|
||||
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, REACHED)", flow, currentReqFlowLo, currentReqFlowHi);
|
||||
log.InfoFormat(
|
||||
"Run(): rv#={0} reqFlow={1} pos={2}% stored={3} <--- Updating a stored position",
|
||||
regV.Idx1, targetFlowAve, rvPosition.ToString("F1"), storedPosition);
|
||||
|
||||
opState = OpState.FlowReached;
|
||||
return Event.FlowReached;
|
||||
}
|
||||
else
|
||||
{
|
||||
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, FLOW_OK_TIMER={3}s)", flow, currentReqFlowLo, currentReqFlowHi, isFlowOkDuration);
|
||||
return Event.Busy;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/// Flow is out of range
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> updating stored position: old={1} newAvg={2}",
|
||||
regV.Name, storedPosition, (rvPosition + storedPosition) / 2.0);
|
||||
}
|
||||
else
|
||||
{
|
||||
StoreTargetPosition(targetFlowAve, rvPosition);
|
||||
|
||||
log.InfoFormat(
|
||||
"Run(): rv#={0} reqFlow={1} pos={2}% <--- Storing a new position",
|
||||
regV.Idx1, targetFlowAve, rvPosition.ToString("F1"));
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> storing new position: {1}",
|
||||
regV.Name, rvPosition);
|
||||
}
|
||||
}
|
||||
|
||||
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, REACHED)", flow, currentReqFlowLo, currentReqFlowHi);
|
||||
|
||||
opState = OpState.FlowReached;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> FLOW REACHED, opState changed to {1}",
|
||||
regV.Name, opState);
|
||||
|
||||
return Event.FlowReached;
|
||||
}
|
||||
else
|
||||
{
|
||||
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, FLOW_OK_TIMER={3}s)", flow, currentReqFlowLo, currentReqFlowHi, isFlowOkDuration);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> flow in range but not stable long enough yet",
|
||||
regV.Name);
|
||||
|
||||
return Event.Busy;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
isFlowOkDuration = 0;
|
||||
|
||||
|
||||
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2})", flow, currentReqFlowLo, currentReqFlowHi);
|
||||
return Event.Busy;
|
||||
}
|
||||
}
|
||||
else /// opState == OpState.FlowReached
|
||||
{
|
||||
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, REACHED)", flowMeter.ReadFlow(), currentReqFlowLo, currentReqFlowHi);
|
||||
return Event.FlowReached;
|
||||
}
|
||||
}
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> SettingFlow: flow OUT OF RANGE, reset isFlowOkDuration to 0",
|
||||
regV.Name);
|
||||
|
||||
return Event.Busy;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double finalFlow = flowMeter.ReadFlow();
|
||||
|
||||
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, REACHED)", finalFlow, currentReqFlowLo, currentReqFlowHi);
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Run() >> FlowReached state: finalFlow={1} reqLo={2} reqHi={3}",
|
||||
regV.Name, finalFlow, currentReqFlowLo, currentReqFlowHi);
|
||||
|
||||
return Event.FlowReached;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Stop this operation</summary>
|
||||
public void Stop()
|
||||
{
|
||||
{
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Stop() >> leaveFlowControlRunning={1} opState(before)={2}",
|
||||
regV.Name, leaveFlowControlRunning, opState);
|
||||
|
||||
if (!leaveFlowControlRunning)
|
||||
{
|
||||
uniCB.StopFlowControl(false, regV.Idx1); /// Stop the flow measurement
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Stop() >> calling uniCB.StopFlowControl(false, regV.Idx1={1})",
|
||||
regV.Name, regV.Idx1);
|
||||
|
||||
uniCB.StopFlowControl(false, regV.Idx1);
|
||||
}
|
||||
|
||||
opState = OpState.Idle;
|
||||
|
||||
LiveLogDiag.Log1(
|
||||
"{0} >> Stop() >> opState(after)={1}",
|
||||
regV.Name, opState);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Logging
|
||||
/// For activation use compilation condition: LIVELOGDIAG_FlowMeter_cs
|
||||
/// </summary>
|
||||
static class LiveLogDiag
|
||||
{
|
||||
[Conditional("LIVELOGDIAG_RegValve_cs")]
|
||||
public static void Log1(string format, params object[] args)
|
||||
{
|
||||
LiveLogCache.Instance.AddLog("RegValve.cs LOG>> " + string.Format(format, args));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -71,7 +71,7 @@
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
|
||||
<OutputPath>bin\x86\Release\</OutputPath>
|
||||
<DefineConstants>TRACE;CAMERA;LANG_PL;IPERL;</DefineConstants>
|
||||
<DefineConstants>TRACE;CAMERA;LANG_PL;IPERL;LIVELOGDIAG_FlowMeter_cs;LIVELOGDIAG_RegValve_cs</DefineConstants>
|
||||
<Optimize>true</Optimize>
|
||||
<DebugType>pdbonly</DebugType>
|
||||
<PlatformTarget>AnyCPU</PlatformTarget>
|
||||
|
||||
Loading…
Reference in New Issue
Block a user