498 lines
18 KiB
C#
498 lines
18 KiB
C#
///
|
|
/// Copyright (c) 2013-2017 Sensus Metering Systems
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using log4net;
|
|
using TBF.BenchControl.GenericDevices;
|
|
using TBF.Boxes;
|
|
|
|
namespace TBF.BenchControl.Elde.RegulValve
|
|
{
|
|
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}, PID={3})", regulValve.Name, finalReqFlowLo, finalReqFlowHi, pidCoef);
|
|
}
|
|
|
|
const int CoaxValveNr = 7; /// Coax. valve has number 7
|
|
|
|
|
|
/// Set by the constructor
|
|
readonly ControlBoardDev controlBoard;
|
|
readonly Elde.RegulValve.RegulValve regulValve;
|
|
readonly int regulValveNr;
|
|
readonly IFlowMeter flowMeter;
|
|
readonly float finalReqFlowLo;
|
|
readonly float finalReqFlowHi;
|
|
readonly float reqFlowAve;
|
|
readonly float pidCoef;
|
|
readonly int timeout;
|
|
readonly bool leaveMeasurementRunning;
|
|
readonly bool reTryCommands;
|
|
|
|
readonly float nominalFlow;
|
|
|
|
///
|
|
/// Internal states of this operation
|
|
///
|
|
enum OpState
|
|
{
|
|
Idle = 0,
|
|
ValveMoveToPosition1, /// Wait 1 takt
|
|
ValveMoveToPosition2, /// This is actual move to position
|
|
ValveMoveToPosition3, /// Wait 1 takt
|
|
CheckStatePosition, /// Verify
|
|
SettingPosition,
|
|
ValveMoveToFlow1, /// Wait 1 takt
|
|
ValveMoveToFlow2, /// This is actual move to flow
|
|
ValveMoveToFlow3, /// Wait 1 takt
|
|
CheckStateFlow, /// Verify
|
|
SettingFlow,
|
|
FlowReached,
|
|
SendCommandAgain,
|
|
}
|
|
OpState opState;
|
|
|
|
float currentReqFlowLo;
|
|
float currentReqFlowHi;
|
|
float targetPositionLo;
|
|
float targetPositionHi;
|
|
|
|
int expireTime;
|
|
DoubleBox flowBox;
|
|
int flowWithinBoundsTime;
|
|
|
|
|
|
/// <summary>
|
|
/// Set required water flow. Conditionally leave the measurement running.
|
|
/// Events: FlowSet, FlowTimeOut
|
|
/// </summary>
|
|
/// <param name="controlBoard">Control board device</param>
|
|
/// <param name="regulValve">Regulation valve component</param>
|
|
/// <param name="flowMeter">Flowmeter component</param>
|
|
/// <param name="requiredFlowLo">Lower limit of the flow to be achieved in [m3/h]</param>
|
|
/// <param name="requiredFlowHi">Upper limit of the flow to be achieved in [m3/h]</param>
|
|
/// <param name="pidCoef">PID coefficient (float)</param>
|
|
/// <param name="timeout">Timeout for the flow setting in [s]</param>
|
|
/// <param name="leaveMeasurementRunning">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(ControlBoardDev controlBoard, IRegulValve regulValve, IFlowMeter flowMeter,
|
|
float requiredFlowLo, float requiredFlowHi, float pidCoef, DoubleBox flowBox,
|
|
bool reTryCmds, int timeout, bool leaveMeasurementRunning)
|
|
{
|
|
if (controlBoard == null) throw new ArgumentNullException("ctrlBoard");
|
|
this.controlBoard = controlBoard;
|
|
|
|
this.regulValve = regulValve as Elde.RegulValve.RegulValve;
|
|
if (this.regulValve == null) throw new ArgumentNullException("regValve is null or not Elde");
|
|
regulValveNr = this.regulValve.Idx1;
|
|
|
|
if (flowMeter == null) throw new ArgumentNullException("flowMeter");
|
|
this.flowMeter = flowMeter;
|
|
|
|
nominalFlow = flowMeter.NominalFlow;
|
|
|
|
this.finalReqFlowLo = requiredFlowLo;
|
|
this.finalReqFlowHi = requiredFlowHi;
|
|
this.reqFlowAve = (requiredFlowLo + requiredFlowHi) / 2.0f;
|
|
this.pidCoef = pidCoef;
|
|
|
|
if (flowBox == null) throw new ArgumentNullException("flowBox");
|
|
this.flowBox = flowBox;
|
|
|
|
this.reTryCommands = reTryCmds;
|
|
|
|
this.timeout = timeout;
|
|
|
|
this.leaveMeasurementRunning = leaveMeasurementRunning;
|
|
|
|
log.Debug(this.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set required water flow - Do not leave the measurement running.
|
|
/// Events: FlowSet
|
|
/// </summary>
|
|
public SetFlowOp(ControlBoardDev controlBoard, IRegulValve regValve, IFlowMeter flowMeter,
|
|
float requiredFlowLo, float requiredFlowHi, float pidCoef, DoubleBox flowbox, bool reTryCmds, int timeout)
|
|
: this(controlBoard, regValve, flowMeter, requiredFlowLo, requiredFlowHi, pidCoef, flowbox, reTryCmds, timeout, false)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set required water flow - No timeout.
|
|
/// Events: FlowSet
|
|
/// </summary>
|
|
public SetFlowOp(ControlBoardDev controlBoard, IRegulValve regValve, IFlowMeter flowMeter,
|
|
float requiredFlowLo, float requiredFlowHi, float pidCoef, DoubleBox flowbox, bool reTryCmds)
|
|
: this(controlBoard, regValve, flowMeter, requiredFlowLo, pidCoef, requiredFlowHi, flowbox, reTryCmds, int.MaxValue, false)
|
|
{
|
|
}
|
|
|
|
/// <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>
|
|
bool FetchTargetPosition(float avgReqFlow, out float positionLo, out float positionHi)
|
|
{
|
|
float targetPosition;
|
|
if (regulValve.Dict.TryGetValue(avgReqFlow, out targetPosition))
|
|
{
|
|
positionLo = Math.Max(targetPosition * 0.95f, 0.0f);
|
|
positionHi = Math.Min(targetPosition * 1.05f, 100.0f);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
positionLo = 0.0f;
|
|
positionHi = 0.0f;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void StoreTargetPosition(float avgReqFlow, float actPosition)
|
|
{
|
|
if (!regulValve.Dict.ContainsKey(reqFlowAve))
|
|
{
|
|
regulValve.Dict.Add(new KeyValuePair<float, float>(avgReqFlow, actPosition));
|
|
}
|
|
return;
|
|
}
|
|
|
|
/// <summary>Start this operation</summary>
|
|
public void Start()
|
|
{
|
|
double flowMtrFreq = flowMeter.ReadFrequency();
|
|
currentReqFlowLo = reqFlowAve;
|
|
currentReqFlowHi = reqFlowAve;
|
|
double flow = flowMeter.ReadFlow();
|
|
///
|
|
if (flow != 0)
|
|
{
|
|
flowBox.Val = flow;
|
|
if (flow >= reqFlowAve) currentReqFlowLo = finalReqFlowLo;
|
|
if (flow <= reqFlowAve) currentReqFlowHi = finalReqFlowHi;
|
|
}
|
|
else
|
|
{
|
|
currentReqFlowLo = finalReqFlowLo; /// Unexpected case when flowMtrFreq==0
|
|
currentReqFlowHi = finalReqFlowHi;
|
|
}
|
|
|
|
flowWithinBoundsTime = 0;
|
|
|
|
if (regulValve.RegulValveCfg.StoredPositionReuse && FetchTargetPosition(reqFlowAve, out targetPositionLo, out targetPositionHi))
|
|
{
|
|
log.InfoFormat("SetFlowOp:Start() rv#={0} flowMtr#={1} TARGET: flowLo={2} flowHi={3} FETCHED: posLo={4} posHi={5}",
|
|
regulValveNr, flowMeter.Idx1, currentReqFlowLo, currentReqFlowHi, targetPositionLo, targetPositionHi);
|
|
|
|
opState = OpState.ValveMoveToPosition1;
|
|
}
|
|
else
|
|
{
|
|
log.InfoFormat("SetFlowOp:Start() rv#={0} flowMtr#={1} TARGET: flowLo={2} flowHi={3}",
|
|
regulValveNr, flowMeter.Idx1, currentReqFlowLo, currentReqFlowHi);
|
|
|
|
opState = OpState.ValveMoveToFlow1;
|
|
}
|
|
|
|
expireTime = StateMachine.Time + timeout;
|
|
if (expireTime < 0) expireTime = int.MaxValue;
|
|
|
|
TestMethods tm = 0;
|
|
StopDevs sd = 0;
|
|
// '_regulValve.RegulValveCfg.PidCoef' replaced by a casted operation parameter 'pidCoef'
|
|
controlBoard.SendCommand(Command.Start, flowMeter.Idx1, controlBoard.Route,
|
|
int.MaxValue, int.MaxValue, tm,
|
|
0.0f, (int)pidCoef, 0, sd);
|
|
}
|
|
|
|
/// <summary>Run this operation</summary>
|
|
/// <returns>
|
|
/// Event.None, Event.FlowReached, Event.RegulValveTimeOut, Event.OpArgumentError
|
|
/// </returns>
|
|
public Event Run()
|
|
{
|
|
float rvPosition = controlBoard.RValvePosition(regulValveNr);
|
|
double flowMtrFreq = flowMeter.ReadFrequency();
|
|
double flow = flowMeter.ReadFlow();
|
|
|
|
if (flow != 0)
|
|
{
|
|
flowBox.Val = flow;
|
|
if (flow >= reqFlowAve) currentReqFlowLo = finalReqFlowLo;
|
|
if (flow <= reqFlowAve) currentReqFlowHi = finalReqFlowHi;
|
|
}
|
|
|
|
log.InfoFormat("SetFlowOp:Run() rv#={0} pos={1}% freq={2} flow={3} opState={4}",
|
|
regulValveNr, rvPosition.ToString("F1"), flowMtrFreq, flow, opState);
|
|
|
|
|
|
if (opState == OpState.SendCommandAgain)
|
|
{
|
|
flowWithinBoundsTime = 0;
|
|
|
|
if (regulValve.RegulValveCfg.StoredPositionReuse && FetchTargetPosition(reqFlowAve, out targetPositionLo, out targetPositionHi))
|
|
{
|
|
log.InfoFormat("Run(): rv#={0} flowMtr#={1} TARGET: flowLo={2} flowHi={3} FETCHED: posLo={4} posHi={5}",
|
|
regulValveNr, flowMeter.Idx1, currentReqFlowLo, currentReqFlowHi, targetPositionLo, targetPositionHi);
|
|
|
|
opState = OpState.ValveMoveToPosition1;
|
|
}
|
|
else
|
|
{
|
|
log.InfoFormat("Run(): rv#={0} flowMtr#={1} TARGET: flowLo={2} flowHi={3}",
|
|
regulValveNr, flowMeter.Idx1, currentReqFlowLo, currentReqFlowHi);
|
|
|
|
opState = OpState.ValveMoveToFlow1;
|
|
}
|
|
|
|
expireTime = StateMachine.Time + timeout;
|
|
if (expireTime < 0) expireTime = int.MaxValue;
|
|
|
|
TestMethods tm = 0;
|
|
StopDevs sd = 0;
|
|
// '_regulValve.RegulValveCfg.PidCoef' replaced by a casted operation parameter 'pidCoef'
|
|
controlBoard.SendCommand(Command.Start, flowMeter.Idx1, controlBoard.Route,
|
|
int.MaxValue, int.MaxValue, tm,
|
|
0.0f, (int)pidCoef, 0, sd);
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.ValveMoveToPosition1)
|
|
{
|
|
opState = OpState.ValveMoveToPosition2;
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.ValveMoveToPosition2) /// Move to position
|
|
{
|
|
/// Issues the appropriate ValveMove(...) command
|
|
controlBoard.ValveMove(regulValveNr, RegulValveMode.TargetPosition,
|
|
new float[2] { targetPositionLo, targetPositionHi },
|
|
regulValve.StableTime);
|
|
|
|
opState = OpState.SettingPosition;
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.ValveMoveToPosition3)
|
|
{
|
|
if (reTryCommands)
|
|
{
|
|
opState = OpState.CheckStatePosition;
|
|
}
|
|
else
|
|
{
|
|
opState = OpState.SettingPosition;
|
|
}
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.CheckStatePosition) /// Verify
|
|
{
|
|
if (((ulong)controlBoard.StatusP & (ulong)StatusP.RefPulsesMsrmnt) == 0)
|
|
{
|
|
opState = OpState.SendCommandAgain;
|
|
return Event.None;
|
|
}
|
|
else if (regulValveNr == CoaxValveNr && ((ulong)controlBoard.StatusP & (ulong)StatusP.CoaxRegValveBusy) == 0)
|
|
{
|
|
/// Repeat appropriate ValveMove(...) command
|
|
controlBoard.ValveMove(regulValveNr, RegulValveMode.TargetPosition,
|
|
new float[2] { (targetPositionLo + targetPositionHi) / 2, (targetPositionLo + targetPositionHi) / 2 },
|
|
regulValve.StableTime);
|
|
|
|
log.InfoFormat("SetFlowOp: ValveMove({0}, Position, {1}, {2}, {3})",
|
|
regulValveNr, (targetPositionLo + targetPositionHi) / 2, (targetPositionLo + targetPositionHi) / 2, regulValve.StableTime);
|
|
|
|
opState = OpState.ValveMoveToPosition3;
|
|
return Event.None;
|
|
}
|
|
else if (regulValveNr < 6 && controlBoard.RegulValveState(regulValveNr) != RegulValveState.DacValueRegul)
|
|
{
|
|
/// Repeat appropriate ValveMove(...) command
|
|
controlBoard.ValveMove(regulValveNr, RegulValveMode.TargetPosition,
|
|
new float[2] { targetPositionLo, targetPositionHi },
|
|
regulValve.StableTime);
|
|
|
|
log.InfoFormat("SetFlowOp: ValveMove({0}, Position, {1}, {2}, {3})",
|
|
regulValveNr, targetPositionLo, targetPositionHi, regulValve.StableTime);
|
|
|
|
opState = OpState.ValveMoveToPosition3;
|
|
return Event.None;
|
|
}
|
|
else
|
|
{
|
|
opState = OpState.SettingPosition;
|
|
return Event.None;
|
|
}
|
|
}
|
|
else if (opState == OpState.SettingPosition)
|
|
{
|
|
/// Repeated untill position is reached
|
|
if ((targetPositionLo <= rvPosition) && (rvPosition <= targetPositionHi))
|
|
{
|
|
opState = OpState.ValveMoveToFlow1;
|
|
}
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.ValveMoveToFlow1)
|
|
{
|
|
opState = OpState.ValveMoveToFlow2;
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.ValveMoveToFlow2) /// Move to flow
|
|
{
|
|
///
|
|
/// Done once, issues an appropriate ValveMove(...) command
|
|
///
|
|
if (currentReqFlowLo >= currentReqFlowHi || currentReqFlowLo > nominalFlow || currentReqFlowHi <= 0)
|
|
{
|
|
return Event.OpArgumentError;
|
|
}
|
|
|
|
log.InfoFormat("Run(): rv#={0} flowMtr#={1} TARGET: flowLo={2} flowHi={3}",
|
|
regulValveNr, flowMeter.Idx1, currentReqFlowLo, currentReqFlowHi);
|
|
|
|
float freqLo = 2000.0f * currentReqFlowLo / nominalFlow;
|
|
float freqHi = 2000.0f * currentReqFlowHi / nominalFlow;
|
|
controlBoard.ValveMove(regulValveNr, RegulValveMode.TargetFrequency,
|
|
new float[2] { freqLo, freqHi },
|
|
regulValve.StableTime);
|
|
|
|
opState = OpState.ValveMoveToFlow3;
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.ValveMoveToFlow3)
|
|
{
|
|
if (reTryCommands)
|
|
{
|
|
opState = OpState.CheckStateFlow;
|
|
}
|
|
else
|
|
{
|
|
opState = OpState.SettingFlow;
|
|
}
|
|
return Event.None;
|
|
}
|
|
else if (opState == OpState.CheckStateFlow) /// Verify the flow setting
|
|
{
|
|
if (regulValveNr != CoaxValveNr && (((ulong)controlBoard.StatusP & (ulong)StatusP.RefPulsesMsrmnt) == 0 ||
|
|
(controlBoard.RegulValveState(regulValveNr) & RegulValveState.PwOrFreqRegul) != RegulValveState.PwOrFreqRegul))
|
|
{
|
|
opState = OpState.SendCommandAgain;
|
|
return Event.None;
|
|
}
|
|
else if (regulValveNr == CoaxValveNr && ((ulong)controlBoard.StatusP & (ulong)StatusP.CoaxRegValveBusy) == 0)
|
|
{
|
|
/// Done once, issues an appropriate ValveMove(...) command
|
|
float freqLo = 2000.0f * currentReqFlowLo / nominalFlow;
|
|
float freqHi = 2000.0f * currentReqFlowHi / nominalFlow;
|
|
controlBoard.ValveMove(regulValveNr, RegulValveMode.TargetFrequency,
|
|
new float[2] { (freqLo + freqHi) / 2.0f, (freqLo + freqHi) / 2.0f },
|
|
regulValve.StableTime);
|
|
|
|
log.InfoFormat("SetFlowOp: ValveMove({0}, Frequency, {1}, {2}, {3})",
|
|
regulValveNr, (freqLo + freqHi) / 2.0f, (freqLo + freqHi) / 2.0f, regulValve.StableTime);
|
|
|
|
opState = OpState.ValveMoveToFlow3;
|
|
return Event.None;
|
|
}
|
|
else if (regulValveNr < 6 && controlBoard.RegulValveState(regulValveNr) != RegulValveState.PwOrFreqRegul)
|
|
{
|
|
/// Done once, issues an appropriate ValveMove(...) command
|
|
float freqLo = 2000.0f * currentReqFlowLo / nominalFlow;
|
|
float freqHi = 2000.0f * currentReqFlowHi / nominalFlow;
|
|
controlBoard.ValveMove(regulValveNr, RegulValveMode.TargetFrequency,
|
|
new float[2] { freqLo, freqHi },
|
|
regulValve.StableTime);
|
|
|
|
log.InfoFormat("SetFlowOp: ValveMove({0}, Frequency, {1}, {2}, {3})",
|
|
regulValveNr, freqLo, freqHi, regulValve.StableTime);
|
|
|
|
opState = OpState.ValveMoveToFlow3;
|
|
return Event.None;
|
|
}
|
|
else
|
|
{
|
|
opState = OpState.SettingFlow;
|
|
return Event.None;
|
|
}
|
|
}
|
|
else if (opState == OpState.SettingFlow)
|
|
{
|
|
///
|
|
/// Repeated untill the required flow is reached
|
|
///
|
|
if ((currentReqFlowLo <= flow) && (flow <= currentReqFlowHi))
|
|
{
|
|
if (flowWithinBoundsTime++ >= regulValve.FlowStableSec)
|
|
{
|
|
if (regulValve.RegulValveCfg.StoredPositionReuse)
|
|
{
|
|
float storedPosition;
|
|
if (regulValve.Dict.TryGetValue(reqFlowAve, out storedPosition))
|
|
{
|
|
/// update the stored valve position
|
|
StoreTargetPosition(reqFlowAve, (rvPosition + storedPosition) / 2.0f);
|
|
log.InfoFormat("Run(): rv#={0} reqFlow={1} pos={2}% stored={3} <--- Updating a stored position",
|
|
regulValveNr, reqFlowAve, rvPosition.ToString("F1"), storedPosition);
|
|
}
|
|
else
|
|
{
|
|
/// store the valve position
|
|
StoreTargetPosition(reqFlowAve, rvPosition);
|
|
log.InfoFormat("Run(): rv#={0} reqFlow={1} pos={2}% <--- Storing a new position",
|
|
regulValveNr, reqFlowAve, rvPosition.ToString("F1"));
|
|
}
|
|
}
|
|
|
|
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, REACHED)", flow, currentReqFlowLo, currentReqFlowHi);
|
|
|
|
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, flowWithinBoundsTime);
|
|
return Event.None;
|
|
}
|
|
}
|
|
else if (StateMachine.Time > expireTime)
|
|
{
|
|
return Event.RegulValveTimeOut;
|
|
}
|
|
else
|
|
{
|
|
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2})", flow, currentReqFlowLo, currentReqFlowHi);
|
|
flowWithinBoundsTime = 0;
|
|
return Event.None;
|
|
}
|
|
}
|
|
else /// opState == OpState.FlowReached
|
|
{
|
|
log.InfoFormat("flow = {0} m3/h (lo={1}, hi={2}, REACHED)", flow, currentReqFlowLo, currentReqFlowHi);
|
|
return Event.FlowReached;
|
|
}
|
|
}
|
|
|
|
/// <summary>Start this operation</summary>
|
|
public void Stop()
|
|
{
|
|
opState = OpState.Idle;
|
|
|
|
if (leaveMeasurementRunning) return;
|
|
|
|
/// Stop measurement
|
|
TestMethods tm = 0;
|
|
StopDevs sd = StopDevs.RegValveRegulation;
|
|
controlBoard.SendCommand(Command.Stop, flowMeter.Idx1, controlBoard.Route,
|
|
50000, 50000, tm,
|
|
0.0f, (int)pidCoef, 0, sd);
|
|
}
|
|
}
|
|
}
|