Refactorization : BenchControl -> Rig

TBF/Rig/Dummy/Balance/Component.cs

@@ -0,0 +1,81 @@
+///
+/// Copyright (c) 2016-2017 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using log4net;
+using Config.Entities;
+using TBF.Rig.GenericDevices;
+
+namespace TBF.Rig.Dummy.Balance
+{
+    public class Component : ComponentBase, IScale, IOperation
+    {
+        private static readonly ILog log = LogManager.GetLogger(typeof(Component));
+        public override string ToString()
+        {
+            return string.Format("{0}({1})", this.GetType().Namespace.Substring(8), Cfg.ToString(1));
+        }
+
+        public Component()
+        {
+        }
+
+        public Component(Generic.IComponentCfg cfg)
+            : base(cfg)
+        {
+            log.Warn(this.ToString());
+        }
+
+        public int ScaleNr { get { return 0; } }
+        public double Capacity { get { return 10000.0; } }
+		public IValve DrainValve { get { return null; } }
+		public IValve DrainValve2 { get { return null; } }
+        public bool ContainsMoreThen(float thld) { return (thld == 0); }
+        public bool IsEmpty() { return true; }
+        public double EvaporationRate(double t) { return 0; }
+        public string Format { get { return "F3"; } }
+        public int EmptyTimeSec { get { return 5; } }
+        public float BuoyancyTemp { get { return 20.0f; } }
+        public float BuoyancyPress { get { return 1.013f; } }
+        public float BuoyancyHumi { get { return 50.0f; } }
+
+        public IOperation ZeroOp()
+        {
+            return this;
+        }
+
+        public IOperation ReadMassOp(ref Boxes.DoubleBox mass)
+        {
+            mass.Val = 0;
+            return this;
+        }
+
+		public IOperation ReadStableMassOp(ref Boxes.DoubleBox mass, int readingsCount, double maxSpread, Config.Entities.MassMethod method)
+        {
+            mass.Val = 0;
+            return this;
+        }
+
+        public IOperation GetSerNumOp(ref string serialNumber)
+        {
+            return null;
+        }
+
+        /// <summary>Start this operation</summary>
+        public void Start()
+        {
+        }
+
+        /// <summary>Run this operation</summary>
+        public Event Run()
+        {
+            return Event.BalanceDone;
+        }
+
+        /// <summary>Stop this operation</summary>
+        public void Stop()
+        {
+        }
+    }
+}

TBF/Rig/Dummy/Balance/Factory.cs

@@ -0,0 +1,28 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System.Collections.Generic;
+using TBF.Rig.Generic;
+using TBF.Rig.Configs.NameOnly;
+
+namespace TBF.Rig.Dummy.Balance
+{
+    public class Factory : IComponentFactory
+    {
+        public string ClassName { get { return this.GetType().Namespace.Substring(8); } }
+        public override string ToString() { return ClassName; }
+
+        public void ResetStaticProperties() { }
+
+        public IComponent DummyComponent() { return new Component(); }
+
+        public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new Component(cfg); }
+
+        public IComponentCfg DefaultConfig() { return new TestMethodCfg(this.GetType().Namespace.Substring(14), this); }
+
+        public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
+        {
+            return ComponentCfgBase.CreateFromDbEntity(TestMethodCfg.Serializer, component, this);
+        }
+    }
+}

TBF/Rig/Dummy/Diverter/Component.cs

@@ -0,0 +1,49 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System;
+using System.Collections.Generic;
+using log4net;
+using Config.Entities;
+using TBF.Rig.GenericDevices;
+using TBF.Boxes;
+
+namespace TBF.Rig.Dummy.Diverter
+{
+    public class Component : ComponentBase, IDiverter
+    {
+        private static readonly ILog log = LogManager.GetLogger(typeof(Component));
+        public override string ToString()
+        {
+            return string.Format("{0}({1})", this.GetType().Namespace.Substring(8), Cfg.ToString(1));
+        }
+
+        FloatBox switchTimeStart;
+        FloatBox switchTimeEnd;
+        public FloatBox SwitchTimeStart { get { return switchTimeStart; } }
+        public FloatBox SwitchTimeEnd { get { return switchTimeEnd; } }
+
+        public Component()
+        {
+        }
+
+        public Component(Generic.IComponentCfg cfg)
+            : base(cfg)
+        {
+            switchTimeStart = new FloatBox();
+            switchTimeEnd = new FloatBox();
+            log.Warn(this.ToString());
+        }
+
+        public int DiverterNr { get { return 0; } }
+		public bool State { get { return false; } }
+        public int ThresholdGate { get { return 50; } }
+        public int ThresholdLo { get { return 10; } }
+        public int ThresholdHi { get { return 90; } }
+
+        public double TestTimeCorrection(double flow)
+        {
+            return 0;
+        }
+    }
+}

TBF/Rig/Dummy/Diverter/Factory.cs

@@ -0,0 +1,28 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System.Collections.Generic;
+using TBF.Rig.Generic;
+using TBF.Rig.Configs.NameOnly;
+
+namespace TBF.Rig.Dummy.Diverter
+{
+    public class Factory : IComponentFactory
+    {
+        public string ClassName { get { return this.GetType().Namespace.Substring(8); } }
+        public override string ToString() { return ClassName; }
+
+        public void ResetStaticProperties() { }
+
+        public IComponent DummyComponent() { return new Component(); }
+
+        public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new Component(cfg); }
+
+        public IComponentCfg DefaultConfig() { return new TestMethodCfg(this.GetType().Namespace.Substring(14), this); }
+
+        public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
+        {
+            return ComponentCfgBase.CreateFromDbEntity(TestMethodCfg.Serializer, component, this);
+        }
+    }
+}

TBF/Rig/Dummy/FlowMeter/Factory.cs

@@ -0,0 +1,27 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System.Collections.Generic;
+using TBF.Rig.Generic;
+
+namespace TBF.Rig.Dummy.FlowMeter
+{
+	public class Factory : IComponentFactory
+	{
+		public string ClassName { get { return this.GetType().Namespace.Substring(8); } }
+        public override string ToString() { return ClassName; }
+
+		public void ResetStaticProperties() { FlowMeter.ResetStaticProperties(); }
+
+		public IComponent DummyComponent() { return new FlowMeter(); }
+
+		public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new FlowMeter(cfg, components); }
+
+		public IComponentCfg DefaultConfig() { return new FlowMeterCfg(this.GetType().Namespace.Substring(14), this); }
+
+		public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
+		{
+			return ComponentCfgBase.CreateFromDbEntity(FlowMeterCfg.Serializer, component, this);
+		}
+	}
+}

TBF/Rig/Dummy/FlowMeter/FlowMeter.cs

@@ -0,0 +1,69 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System;
+using System.Collections.Generic;
+using log4net;
+using SchematicDrawing;
+using TBF.Boxes;
+
+namespace TBF.Rig.Dummy.FlowMeter
+{
+    public class FlowMeter : ComponentBase, GenericDevices.IFlowMeter, IDrawingItCmpnt
+	{
+		private static readonly ILog log = LogManager.GetLogger(typeof(FlowMeter));
+        public override string ToString() { return string.Format("FlowMeter({0})", Cfg.ToString(1)); }
+
+		readonly FlowMeterCfg flowMeterCfg;
+        public IDrawingItem DrawingItem { get { return flowMeterCfg as IDrawingItem; } }
+
+        public double NominalFlow { get { return flowMeterCfg.NominalFlow; } }
+
+        public double LtrPerPulse { get { return flowMeterCfg.NominalFlow / 7200.0f; } }
+
+        public double LtrPerPulseCorrected(double flow, int rangeIx)
+        {
+            return flow;
+        }
+
+		public int Idx1 { get { return 1; } }
+
+
+		public FlowMeter()
+		{
+		}
+
+		public FlowMeter(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
+			: base(cfg)
+		{
+			flowMeterCfg = cfg as FlowMeterCfg;
+
+            log.Warn(this.ToString());
+		}
+
+
+        public double ReadFlow() { return 1.23; }
+        public double ReadFrequency() { return 1.23 * 2000.0 / (double)NominalFlow; }
+
+		/// <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);
+		}
+	}
+}

TBF/Rig/Dummy/FlowMeter/FlowMeterCfg.cs

@@ -0,0 +1,60 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System.Collections.Generic;
+using System.Xml.Serialization;
+using SchematicDrawing;
+using TBF.Rig.Generic;
+
+namespace TBF.Rig.Dummy.FlowMeter
+{
+    public class FlowMeterCfg : ComponentCfgBase, IComponentCfg, IDrawingItem
+	{
+		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(FlowMeterCfg) })[0];
+		public override XmlSerializer GetSerializer() { return Serializer; }
+
+		public IComponentCfgCtrl GetControl(IList<Config.Entities.Component> cmpntEntities) { return new FlowMeterCfgCtrl(); }
+
+		///
+		/// Serialized parameters 
+		///
+        public float NominalFlow;       /// Nominal flow in m3/h at output frequency 2000 Hz
+
+        public Shape Shape { get; set; }
+        public int X { get; set; }
+        public int Y { get; set; }
+        public Sz Sz { get; set; }
+        public Orient Orient { get; set; }
+        public bool Flip { get; set; }
+        public int LblX { get; set; }
+        public int LblY { get; set; }
+        public Orient LblOrient { get; set; }
+
+        [XmlIgnore]
+        public IList<GNode> GNodes { get; set; }
+
+		/// Private parameterless constructor invoked by all other (public) constructors
+		FlowMeterCfg()
+		{
+            GNodes = new List<GNode>();
+        }
+
+		public FlowMeterCfg(string name, IComponentFactory factory)
+            : this()
+        {
+            Shape = Shape.FlowM;
+            Sz = Sz.M;
+
+            Name = name;
+            Factory = factory;
+			NominalFlow = 1.0f;
+        }
+
+        
+
+        public string ToString(int i)
+		{
+            return string.Format("{0} {1}[{2},{3}] NominalFlow={4}", Name, Shape, X, Y, NominalFlow);
+		}
+	}
+}

TBF/Rig/Dummy/FlowMeter/FlowMeterCfgCtrl.Designer.cs

@@ -0,0 +1,109 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+namespace TBF.Rig.Dummy.FlowMeter
+{
+	partial class FlowMeterCfgCtrl
+	{
+		/// <summary> 
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary> 
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Component Designer generated code
+
+		/// <summary> 
+		/// Required method for Designer support - do not modify 
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+			this.nameTextBox = new System.Windows.Forms.TextBox();
+			this.nameLabel = new System.Windows.Forms.Label();
+			this.classNameLabel = new System.Windows.Forms.Label();
+			this.nominalFlowTextBox = new System.Windows.Forms.TextBox();
+			this.nominalFlowLabel = new System.Windows.Forms.Label();
+			this.SuspendLayout();
+			// 
+			// nameTextBox
+			// 
+			this.nameTextBox.Enabled = false;
+			this.nameTextBox.Location = new System.Drawing.Point(140, 61);
+			this.nameTextBox.Name = "nameTextBox";
+			this.nameTextBox.Size = new System.Drawing.Size(130, 20);
+			this.nameTextBox.TabIndex = 2;
+			// 
+			// nameLabel
+			// 
+			this.nameLabel.AutoSize = true;
+			this.nameLabel.Location = new System.Drawing.Point(30, 64);
+			this.nameLabel.Name = "nameLabel";
+			this.nameLabel.Size = new System.Drawing.Size(35, 13);
+			this.nameLabel.TabIndex = 1;
+			this.nameLabel.Text = "Name";
+			// 
+			// classNameLabel
+			// 
+			this.classNameLabel.AutoSize = true;
+			this.classNameLabel.Location = new System.Drawing.Point(137, 37);
+			this.classNameLabel.Name = "classNameLabel";
+			this.classNameLabel.Size = new System.Drawing.Size(83, 13);
+			this.classNameLabel.TabIndex = 0;
+			this.classNameLabel.Text = "ComonentName";
+			// 
+			// nominalFlowTextBox
+			// 
+			this.nominalFlowTextBox.Enabled = false;
+			this.nominalFlowTextBox.Location = new System.Drawing.Point(224, 87);
+			this.nominalFlowTextBox.Name = "nominalFlowTextBox";
+			this.nominalFlowTextBox.Size = new System.Drawing.Size(46, 20);
+			this.nominalFlowTextBox.TabIndex = 8;
+			// 
+			// nominalFlowLabel
+			// 
+			this.nominalFlowLabel.AutoSize = true;
+			this.nominalFlowLabel.Location = new System.Drawing.Point(30, 90);
+			this.nominalFlowLabel.Name = "nominalFlowLabel";
+			this.nominalFlowLabel.Size = new System.Drawing.Size(140, 13);
+			this.nominalFlowLabel.TabIndex = 7;
+			this.nominalFlowLabel.Text = "Nominal flow [m3/h @2kHz]";
+			// 
+			// FlowMeterCfgCtrl
+			// 
+			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+			this.Controls.Add(this.nominalFlowTextBox);
+			this.Controls.Add(this.nominalFlowLabel);
+			this.Controls.Add(this.nameTextBox);
+			this.Controls.Add(this.nameLabel);
+			this.Controls.Add(this.classNameLabel);
+			this.Name = "FlowMeterCfgCtrl";
+			this.Size = new System.Drawing.Size(300, 200);
+			this.Load += new System.EventHandler(this.FlowMeterCfgCtrl_Load);
+			this.ResumeLayout(false);
+			this.PerformLayout();
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.TextBox nameTextBox;
+		private System.Windows.Forms.Label nameLabel;
+		private System.Windows.Forms.Label classNameLabel;
+        private System.Windows.Forms.TextBox nominalFlowTextBox;
+		private System.Windows.Forms.Label nominalFlowLabel;
+	}
+}

TBF/Rig/Dummy/FlowMeter/FlowMeterCfgCtrl.cs

@@ -0,0 +1,86 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System;
+using System.Windows.Forms;
+using Config.Entities;
+using TBF.Rig.Generic;
+using TBF.UI.Bench.Components;
+
+namespace TBF.Rig.Dummy.FlowMeter
+{
+	public partial class FlowMeterCfgCtrl : UserControl, IComponentCfgCtrl
+	{
+		ComponentParametersDlg parent;
+
+		public bool ShowMore { get { return false; } }
+
+		FlowMeterCfg config;
+		public IComponentCfg Config
+		{
+			get { return config as IComponentCfg; }
+			set
+			{
+				config = value as FlowMeterCfg;
+				Redraw();
+			}
+		}
+
+		public FlowMeterCfgCtrl()
+		{
+			InitializeComponent();
+		}
+
+		private void FlowMeterCfgCtrl_Load(object sender, EventArgs e)
+		{
+			parent = ParentForm as ComponentParametersDlg;
+			if (parent == null) return;
+
+			Redraw();
+		}
+
+		public void Closing()
+		{
+		}
+
+		void Redraw()
+		{
+			if (config == null) return;			/// Control was not loaded, settings were not changed
+												
+			classNameLabel.Text = config.Factory.ClassName;
+			nameTextBox.Text = config.Name;
+            nominalFlowTextBox.Text = config.NominalFlow.ToString();
+        }
+
+		public void Unlock()
+		{
+			nameTextBox.Enabled = true;
+			nominalFlowTextBox.Enabled = true;
+		}
+
+		public CfgUpdateFlags VerifyCfg(ref string message)
+		{
+            CfgUpdateFlags flags = CfgUpdateFlags.None;
+
+			float fdummy;
+            if (!Utils.TryParseUFloat(nominalFlowTextBox.Text, out fdummy) || fdummy < 0.01 || fdummy > 1600)
+            {
+                flags |= CfgUpdateFlags.Error;
+                message += Environment.NewLine + "'Nominal flow' should be between 0.01 and 1600";
+            }
+            return flags;
+		}
+
+		public CfgUpdateFlags UpdateCfg()
+		{
+			CfgUpdateFlags flags = CfgUpdateFlags.RestartRqrd;
+
+			if (config == null) return CfgUpdateFlags.Error;	/// Control was not loaded, settings were not changed
+
+			config.Name = nameTextBox.Text;
+			Utils.TryParseUFloat(nominalFlowTextBox.Text, out config.NominalFlow);
+
+			return flags;
+		}
+	}
+}

TBF/Rig/Dummy/FlowMeter/FlowMeterCfgCtrl.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

TBF/Rig/Dummy/FlowMeter/ReadFlowOp.cs

@@ -0,0 +1,61 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System;
+using log4net;
+using TBF.Boxes;
+
+namespace TBF.Rig.Dummy.FlowMeter
+{
+	public class ReadFlowOp : IOperation
+	{
+		private static readonly ILog log = LogManager.GetLogger(typeof(ReadFlowOp));
+		public override string ToString() { return string.Format("ReadFlowOp(.,{0},{1},.)", eventDone); }
+
+		/// Set by the constructor
+        readonly FlowMeter flowMeter;
+        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>
+		public ReadFlowOp(FlowMeter flowMeter, ref DoubleBox flowBox, Event eventDone)
+        {
+			if (flowMeter == null) throw new ArgumentNullException("flowMeter");
+
+            this.flowMeter = flowMeter;
+			this.eventDone = eventDone;
+			this.flowBox = flowBox;
+
+			log.Debug(this.ToString());
+        }
+		public ReadFlowOp(FlowMeter flowMeter, ref DoubleBox flow)
+			: this(flowMeter, ref flow, Event.FlowMeasurementDone)
+		{
+		}
+
+		/// <summary>Start this operation</summary>
+		public void Start()
+        {
+		}
+
+		/// <summary>Run this operation</summary>
+		/// <returns>
+		///		Event.FlowInDone or Event.FlowOutDone
+		/// </returns>
+		public Event Run()
+		{
+            if (flowBox != null) flowBox.Val = flowMeter.ReadFlow();
+			return eventDone;
+		}
+
+		/// <summary>Stop this operation</summary>
+		public void Stop()
+		{
+		}
+	}
+}

TBF/Rig/Dummy/RegulValve/ChangeValvePositionOp.cs

@@ -0,0 +1,60 @@
+///
+/// Copyright (c) 2017-2021 Sensus Slovensko a.s.
+///
+using System;
+using log4net;
+
+namespace TBF.Rig.Dummy.RegulValve
+{
+	public class ChangeRegulValvePositionOp : IOperation
+	{
+		private static readonly ILog log = LogManager.GetLogger(typeof(ChangeRegulValvePositionOp));
+		public override string ToString()
+		{
+            return string.Format("ChangeRegulValvePositionOp({0},{1}s)", regulValve.Name, timePulseSec.ToString("F2"));
+		}
+
+		/// Set by the constructor
+		readonly RegulValve regulValve;
+        readonly double timePulseSec;
+
+		/// <summary>
+        /// Set required water flow.
+        /// Events:  FlowSet, FlowTimeOut
+		/// </summary>
+		/// <param name="controlBoard">Control board device</param>
+		/// <param name="regulValve">Regulation valve component</param>
+		/// <param name="posLoPct">Lower limit of the position to be achieved</param>
+		/// <param name="posHiPct">Upper limit of the position to be achieved</param>
+		/// <param name="timeout">Timeout in sec. for setting the flow</param>
+		/// <remarks>Only Elde.Valve flow are used, other flow on the lists are ignored</remarks>
+        public ChangeRegulValvePositionOp(RegulValve regulValve, double timePulseSec)
+        {
+            this.regulValve = regulValve as RegulValve;
+			if (this.regulValve == null) throw new ArgumentNullException("regValve is null or not Elde");
+
+            this.timePulseSec = timePulseSec;
+			
+			log.Debug(this.ToString());
+        }
+
+		/// <summary>Start this operation</summary>
+		public void Start()
+        {
+        }
+
+		/// <summary>Run this operation</summary>
+		/// <returns>
+		///		Event.SetFlowDone
+		/// </returns>
+		public Event Run()
+		{
+            return Event.PositionReached;
+        }
+
+        /// <summary>Stop this operation</summary>
+        public void Stop()
+		{
+        }
+	}
+}

TBF/Rig/Dummy/RegulValve/Factory.cs

@@ -0,0 +1,27 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System.Collections.Generic;
+using TBF.Rig.Generic;
+
+namespace TBF.Rig.Dummy.RegulValve
+{
+	public class Factory : IComponentFactory
+	{
+		public string ClassName { get { return this.GetType().Namespace.Substring(8); } }
+        public override string ToString() { return ClassName; }
+
+		public void ResetStaticProperties() { RegulValve.ResetStaticProperties(); }
+
+		public IComponent DummyComponent() { return new RegulValve(); }
+
+		public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new RegulValve(cfg, components); }
+
+		public IComponentCfg DefaultConfig() { return new RegulValveCfg(this.GetType().Namespace.Substring(14), this); }
+
+        public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
+        {
+            return ComponentCfgBase.CreateFromDbEntity(RegulValveCfg.Serializer, component, this);
+        }
+	}
+}

TBF/Rig/Dummy/RegulValve/RegulValve.cs

@@ -0,0 +1,99 @@
+///
+/// Copyright (c) 2017-2020 Sensus Slovensko a.s.
+///
+using System.Collections.Generic;
+using log4net;
+using TBF.Rig.Generic;
+using TBF.Boxes;
+
+namespace TBF.Rig.Dummy.RegulValve
+{
+    public class RegulValve : ComponentBase, IDevice, GenericDevices.IRegValve, SchematicDrawing.IDrawingItCmpnt
+	{
+		private static readonly ILog log = LogManager.GetLogger(typeof(RegulValve));
+        public override string ToString() { return string.Format("RegulValve({0})", Cfg.ToString(1)); }
+
+		public readonly RegulValveCfg RegulValveCfg;
+        public SchematicDrawing.IDrawingItem DrawingItem { get { return RegulValveCfg as SchematicDrawing.IDrawingItem; } }
+
+        public ValveCategory Category { get { return RegulValveCfg.Category; } }
+		///
+		public bool IsCoax { get { return false; } }
+
+		public double Position { get { return 50.0; } }
+
+
+        IDictionary<double, double> dict;
+        public IDictionary<double, double> Dict { get { return dict; } }
+
+
+		public RegulValve()
+		{
+		}
+
+		public RegulValve(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
+            : base(cfg)
+		{
+			RegulValveCfg = cfg as RegulValveCfg;
+            dict = new Dictionary<double, double>();
+
+            log.Warn(this.ToString());
+		}
+
+        public void Initialize()      { }
+        public void RunDeviceBefore() { }
+        public void RunDeviceAfter()  { }
+        public void StopDevice()      { }
+		public void StopDevice2()	  { }
+
+
+        /// <summary>
+        /// Operation to set the water flow within tolerances
+        /// Events: Event.None, Event.FlowReached, Event.FlowTimeOut
+        /// </summary>
+        /// <param name="flowMeter">Flowmeter component</param>
+        /// <param name="requiredFlowLo">Lower limit of the required flow [m3/h]</param>
+        /// <param name="requiredFlowHi">Higher limit of the required flow [m3/h]</param>
+		/// <param name="measuredFlow">Measured flow [m3/h]</param>
+        /// <param name="timeout">Timeout in [s]</param>
+        /// <returns>SetFlowOp instance</returns>
+        public IOperation SetFlowOp(GenericDevices.IFlowMeter flowMeter, double requiredFlowLo, double requiredFlowHi,
+                                    DoubleBox measuredFlow, int timeout)
+        {
+			return new SetFlowOp(this, flowMeter, requiredFlowLo, requiredFlowHi, measuredFlow, timeout);
+        }
+
+		/// <summary>
+		/// Operation to set the water flow within tolerances. Leave the measurement running.
+		/// Events: Event.None, Event.FlowReached, Event.FlowTimeOut
+		/// </summary>
+		/// <param name="flowMeter">Flowmeter component</param>
+		/// <param name="requiredFlowLo">Lower limit of the required flow [m3/h]</param>
+		/// <param name="requiredFlowHi">Higher limit of the required flow [m3/h]</param>
+		/// <param name="measuredFlow">Measured flow [m3/h]</param>
+		/// <param name="timeout">Timeout in [s]</param>
+		/// <returns>SetFlowOp instance</returns>
+        public IOperation SetFlowAndMeasureOp(GenericDevices.IFlowMeter flowMeter, double requiredFlowLo, double requiredFlowHi,
+                                              DoubleBox measuredFlow, int timeout, float filterConstant)
+		{
+			return new SetFlowOp(this, flowMeter, requiredFlowLo, requiredFlowHi, measuredFlow, timeout, true);
+		}
+
+        /// <summary>
+        /// Operation to set the regulation valve to a required position
+        /// Events: Event.None
+        /// </summary>
+        /// <param name="flowLo">Lower limit of the required valve position in [%]</param>
+        /// <param name="flowLo">Higher limit of the required valve position in [%]</param>
+        /// <returns>SetPositionOp instance</returns>
+        public IOperation SetRegulValvePositionOp(double pctLo, double pctHi, int timeoutMs)
+        {
+            return new SetRegulValvePositionOp(this, pctLo, pctHi, timeoutMs);
+        }
+
+        public IOperation ChangeRegulValvePositionOp(double timePulseSec)
+        {
+            return new ChangeRegulValvePositionOp(this, timePulseSec);
+        }
+    }
+}

TBF/Rig/Dummy/RegulValve/RegulValveCfg.cs

@@ -0,0 +1,60 @@
+///
+/// Copyright (c) 2017-2020 Sensus Slovensko a.s.
+///
+using System.Collections.Generic;
+using System.Xml.Serialization;
+using SchematicDrawing;
+using TBF.Rig.Generic;
+
+namespace TBF.Rig.Dummy.RegulValve
+{
+    public class RegulValveCfg : ComponentCfgBase, IComponentCfg, IDrawingItem
+	{
+		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(RegulValveCfg) })[0];
+		public override XmlSerializer GetSerializer() { return Serializer; }
+
+		public IComponentCfgCtrl GetControl(IList<Config.Entities.Component> cmpntEntities) { return new RegulValveCfgCtrl(); }
+
+		///
+		/// Serialized parameters 
+		///
+        public ValveCategory Category;      /// Feeding, Output or All
+
+        public Shape Shape { get; set; }
+        public int X { get; set; }
+        public int Y { get; set; }
+        public Sz Sz { get; set; }
+        public Orient Orient { get; set; }
+        public bool Flip { get; set; }
+        public int LblX { get; set; }
+        public int LblY { get; set; }
+        public Orient LblOrient { get; set; }
+
+        [XmlIgnore]
+        public IList<GNode> GNodes { get; set; }
+
+
+		/// Private parameterless constructor invoked by all other (public) constructors
+		RegulValveCfg()
+		{
+            GNodes = new List<GNode>();
+        }
+
+        public RegulValveCfg(string name, IComponentFactory factory)
+            : this()
+        {
+            Name = name;
+            Factory = factory;
+            Category = ValveCategory.Output;
+            Shape = Shape.RegV;
+            Sz = Sz.M;
+        }
+
+        
+
+        public string ToString(int i)
+		{
+            return string.Format("{0} {1}[{2},{3}]", Name, Shape, X, Y);
+		}
+	}
+}

TBF/Rig/Dummy/RegulValve/RegulValveCfgCtrl.Designer.cs

@@ -0,0 +1,110 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+namespace TBF.Rig.Dummy.RegulValve
+{
+	partial class RegulValveCfgCtrl
+	{
+		/// <summary> 
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary> 
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Component Designer generated code
+
+		/// <summary> 
+		/// Required method for Designer support - do not modify 
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+			this.nameTextBox = new System.Windows.Forms.TextBox();
+			this.nameLabel = new System.Windows.Forms.Label();
+			this.classNameLabel = new System.Windows.Forms.Label();
+			this.categoryComboBox = new System.Windows.Forms.ComboBox();
+			this.categoryLabel = new System.Windows.Forms.Label();
+			this.SuspendLayout();
+			// 
+			// nameTextBox
+			// 
+			this.nameTextBox.Enabled = false;
+			this.nameTextBox.Location = new System.Drawing.Point(138, 41);
+			this.nameTextBox.Name = "nameTextBox";
+			this.nameTextBox.Size = new System.Drawing.Size(130, 20);
+			this.nameTextBox.TabIndex = 2;
+			// 
+			// nameLabel
+			// 
+			this.nameLabel.AutoSize = true;
+			this.nameLabel.Location = new System.Drawing.Point(28, 44);
+			this.nameLabel.Name = "nameLabel";
+			this.nameLabel.Size = new System.Drawing.Size(35, 13);
+			this.nameLabel.TabIndex = 1;
+			this.nameLabel.Text = "Name";
+			// 
+			// classNameLabel
+			// 
+			this.classNameLabel.AutoSize = true;
+			this.classNameLabel.Location = new System.Drawing.Point(135, 14);
+			this.classNameLabel.Name = "classNameLabel";
+			this.classNameLabel.Size = new System.Drawing.Size(89, 13);
+			this.classNameLabel.TabIndex = 0;
+			this.classNameLabel.Text = "ComponentName";
+			// 
+			// categoryComboBox
+			// 
+			this.categoryComboBox.Enabled = false;
+			this.categoryComboBox.FormattingEnabled = true;
+			this.categoryComboBox.Location = new System.Drawing.Point(138, 65);
+			this.categoryComboBox.Name = "categoryComboBox";
+			this.categoryComboBox.Size = new System.Drawing.Size(130, 21);
+			this.categoryComboBox.TabIndex = 6;
+			// 
+			// categoryLabel
+			// 
+			this.categoryLabel.AutoSize = true;
+			this.categoryLabel.Location = new System.Drawing.Point(28, 68);
+			this.categoryLabel.Name = "categoryLabel";
+			this.categoryLabel.Size = new System.Drawing.Size(49, 13);
+			this.categoryLabel.TabIndex = 5;
+			this.categoryLabel.Text = "Category";
+			// 
+			// RegulValveCfgCtrl
+			// 
+			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+			this.Controls.Add(this.categoryComboBox);
+			this.Controls.Add(this.categoryLabel);
+			this.Controls.Add(this.nameTextBox);
+			this.Controls.Add(this.nameLabel);
+			this.Controls.Add(this.classNameLabel);
+			this.Name = "RegulValveCfgCtrl";
+			this.Size = new System.Drawing.Size(423, 292);
+			this.Load += new System.EventHandler(this.RegulationValveCfgCtrl_Load);
+			this.ResumeLayout(false);
+			this.PerformLayout();
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.TextBox nameTextBox;
+		private System.Windows.Forms.Label nameLabel;
+		private System.Windows.Forms.Label classNameLabel;
+        private System.Windows.Forms.ComboBox categoryComboBox;
+		private System.Windows.Forms.Label categoryLabel;
+	}
+}

TBF/Rig/Dummy/RegulValve/RegulValveCfgCtrl.cs

@@ -0,0 +1,100 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System;
+using System.Windows.Forms;
+using Config.Entities;
+using TBF.Rig.Generic;
+using TBF.UI.Bench.Components;
+
+namespace TBF.Rig.Dummy.RegulValve
+{
+	public partial class RegulValveCfgCtrl : UserControl, IComponentCfgCtrl
+	{
+		ComponentParametersDlg parent;
+
+		public bool ShowMore { get { return true; } }
+
+		RegulValveCfg config;
+		public IComponentCfg Config
+		{
+			get { return config as IComponentCfg; }
+			set
+			{
+				config = value as RegulValveCfg;
+				Redraw();
+			}
+		}
+
+		public RegulValveCfgCtrl()
+		{
+			InitializeComponent();
+		}
+
+		private void RegulationValveCfgCtrl_Load(object sender, EventArgs e)
+		{
+            categoryComboBox.Items.Add(ValveCategory.Feeding.ToString());
+            categoryComboBox.Items.Add(ValveCategory.Output.ToString());
+
+			Redraw();
+		}
+
+		public void Closing()
+		{
+		}
+
+		void Redraw()
+		{
+			if (config == null) return;			/// Control was not loaded, settings were not changed
+												
+			classNameLabel.Text = config.Factory.ClassName;
+			nameTextBox.Text = config.Name;
+            categoryComboBox.Text = config.Category.ToString();
+		}
+
+		public void Unlock()
+		{
+			nameTextBox.Enabled = true;
+            categoryComboBox.Enabled = true;
+        }
+
+		public CfgUpdateFlags VerifyCfg(ref string message)
+		{
+            CfgUpdateFlags flags = CfgUpdateFlags.None;
+
+            if (!categoryComboBox.Text.Equals(ValveCategory.Feeding.ToString()) &&
+                !categoryComboBox.Text.Equals(ValveCategory.Output.ToString()))
+            {
+				flags |= CfgUpdateFlags.Error;
+				message += Environment.NewLine + "Invalid 'Category'";
+            }
+
+			return flags;
+		}
+
+		public CfgUpdateFlags UpdateCfg()
+		{
+			CfgUpdateFlags flags = CfgUpdateFlags.None;
+
+			if (config == null) return CfgUpdateFlags.Error;	/// Control was not loaded, settings were not changed
+												/// 
+			if (!config.Name.Equals(nameTextBox.Text))
+			{
+				config.Name = nameTextBox.Text;
+				flags |= CfgUpdateFlags.RestartRqrd;
+			}
+
+            ValveCategory newCategory;
+            if (categoryComboBox.Text.Equals(ValveCategory.Feeding.ToString()))      newCategory = ValveCategory.Feeding;
+            else if (categoryComboBox.Text.Equals(ValveCategory.Output.ToString()))  newCategory = ValveCategory.Output;
+            else                                                                     newCategory = ValveCategory.None;
+            if (newCategory != config.Category)
+            {
+                config.Category = newCategory;
+                flags |= CfgUpdateFlags.RestartRqrd;
+            }
+
+			return flags;
+		}
+	}
+}

TBF/Rig/Dummy/RegulValve/RegulValveCfgCtrl.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

TBF/Rig/Dummy/RegulValve/SetFlowOp.cs

@@ -0,0 +1,111 @@
+///
+/// Copyright (c) 2017-2019 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using log4net;
+using TBF.Rig.GenericDevices;
+using TBF.Boxes;
+
+namespace TBF.Rig.Dummy.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})", regulValve.Name, reqFlowLo, reqFlowHi);
+		}
+
+		const int CoaxValveNr = 7;			/// Coax. valve has number 7
+
+
+		/// Set by the constructor
+        readonly RegulValve regulValve;
+        readonly double reqFlowLo;
+        readonly double reqFlowHi;
+        readonly double reqFlowAve;
+		readonly int timeout;
+        readonly bool leaveMeasurementRunning;
+
+        readonly double nominalFlow;
+        readonly double maximalFlow;
+
+        int expireTime;
+		DoubleBox measuredFlow;
+
+		
+		/// <summary>
+        /// Set required water flow. Conditionally leave the measurement running.
+        /// Events:  FlowSet, FlowTimeOut
+		/// </summary>
+		/// <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(IRegValve regulValve, IFlowMeter flowMeter, double requiredFlowLo, double requiredFlowHi,
+                         DoubleBox measuredFlow, int timeout, bool leaveMeasurementRunning)
+        {
+            this.regulValve = regulValve as RegulValve;
+            if (this.regulValve == null) throw new ArgumentNullException("regValve is null or not Dummy.RegulValve");
+
+            nominalFlow = flowMeter.NominalFlow;
+            maximalFlow = nominalFlow * 1.25;
+
+            this.reqFlowLo = requiredFlowLo;
+            this.reqFlowHi = requiredFlowHi;
+			this.reqFlowAve = (reqFlowLo + reqFlowHi) / 2.0;
+			this.measuredFlow = measuredFlow;
+
+            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(IRegValve regValve, IFlowMeter flowMeter, double requiredFlowLo, double requiredFlowHi, DoubleBox measuredFlow, int timeout)
+            : this(regValve, flowMeter, requiredFlowLo, requiredFlowHi, measuredFlow, timeout, false)
+        {
+        }
+
+        /// <summary>
+        /// Set required water flow - No timeout.
+        /// Events:  FlowSet
+        /// </summary>
+        public SetFlowOp(IRegValve regValve, IFlowMeter flowMeter, double requiredFlowLo, double requiredFlowHi, DoubleBox measuredFlow)
+			: this(regValve, flowMeter, requiredFlowLo, requiredFlowHi, measuredFlow, int.MaxValue, false)
+        {
+        }
+
+		/// <summary>Start this operation</summary>
+		public void Start()
+        {
+            expireTime = StateMachine.Time + timeout;
+            if (expireTime < 0) expireTime = int.MaxValue;
+		}
+
+		/// <summary>Run this operation</summary>
+		/// <returns>
+		///		Event.None, Event.FlowReached, Event.RegulValveTimeOut, Event.OpArgumentError
+		/// </returns>
+		public Event Run()
+		{
+			measuredFlow.Val = reqFlowAve;
+			return Event.FlowReached;
+		}
+
+        /// <summary>Start this operation</summary>
+        public void Stop()
+		{
+        }
+	}
+}

TBF/Rig/Dummy/RegulValve/SetRegulValvePositionOp.cs

@@ -0,0 +1,118 @@
+///
+/// Copyright (c) 2017 Sensus Metering Systems
+///
+using System;
+using System.Collections.Generic;
+using log4net;
+using TBF.Rig.GenericDevices;
+
+namespace TBF.Rig.Dummy.RegulValve
+{
+	public class SetRegulValvePositionOp : IOperation
+	{
+		private static readonly ILog log = LogManager.GetLogger(typeof(SetRegulValvePositionOp));
+		public override string ToString()
+		{
+            return string.Format("SetRegulValvePositionOp({0},{1},{2})", regulValve.Name, posLoPct, posHiPct);
+		}
+
+		///
+		///  Internal states of this operation
+		///
+		enum OpState
+		{
+			Idle = 0,
+			MoveToPosition,		/// Send commend to move to position
+			CheckState,			/// Check RV state by reading statos word
+			MovingToPosition,	/// Command passed OK, RV is moving to a position
+		}
+		OpState opState;
+
+		/// Set by the constructor
+		readonly RegulValve regulValve;
+        readonly double posLoPct;
+        readonly double posHiPct;
+        readonly int timeout;
+
+        ///  Process values
+        bool firstRun;
+        int expireTime;
+		bool positionReached;
+
+		/// <summary>
+        /// Set required water flow.
+        /// Events:  FlowSet, FlowTimeOut
+		/// </summary>
+		/// <param name="controlBoard">Control board device</param>
+		/// <param name="_regulValve">Regulation valve component</param>
+		/// <param name="posLoPct">Lower limit of the position to be achieved</param>
+		/// <param name="posHiPct">Upper limit of the position to be achieved</param>
+		/// <param name="timeout">Timeout in sec. for setting the flow</param>
+		/// <remarks>Only Elde.Valve flow are used, other flow on the lists are ignored</remarks>
+		public SetRegulValvePositionOp(RegulValve regulValve, double posLoPct, double posHiPct, int timeout)
+        {
+            this.regulValve = regulValve as RegulValve;
+            if (regulValve == null) throw new ArgumentNullException("regValve is null or not Elde");
+
+			this.posLoPct = posLoPct;
+            this.posHiPct = posHiPct;
+
+            this.timeout = timeout;
+			
+			log.Debug(this.ToString());
+        }
+
+        /// <summary>
+        /// Set required water flow - no timeout.
+        /// Events:  FlowSet
+        /// </summary>
+        public SetRegulValvePositionOp(RegulValve regValve, double posLoPct, double posHiPct)
+            : this(regValve, posLoPct, posHiPct, int.MaxValue)
+        {
+        }
+
+		/// <summary>Start this operation</summary>
+		public void Start()
+        {
+            firstRun = true;
+            positionReached = false;
+            expireTime = StateMachine.Time + timeout;
+            log.InfoFormat("Start(): RV#={0}, reqPosLo={1}%, reqPosHi={2}%", posLoPct.ToString("F1"), posHiPct.ToString("F1"));
+			opState = OpState.MoveToPosition;
+        }
+
+		/// <summary>Run this operation</summary>
+		/// <returns>
+		///		Event.None  . . . . . . . busy adjusting position
+		///		Event.PositionReached . . position reached
+		///		Event.OpArgumentError . . invalid required position
+		/// </returns>
+		public Event Run()
+		{
+			if (opState == OpState.MoveToPosition)
+            {
+				opState = OpState.CheckState;
+                return Event.None;
+            }
+
+			if (positionReached) return Event.PositionReached;
+
+			if (opState == OpState.CheckState)
+			{
+				opState = OpState.MovingToPosition;
+				return Event.None;
+			}
+			else if (opState == OpState.MovingToPosition)
+			{
+				positionReached = true;
+				return Event.PositionReached;
+			}
+			return Event.None;
+		}
+
+        /// <summary>Stop this operation</summary>
+        public void Stop()
+		{
+        }
+	}
+}

TBF/Rig/Dummy/Valve/Component.cs

@@ -0,0 +1,40 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System;
+using System.Collections.Generic;
+using log4net;
+using Config.Entities;
+using TBF.Rig.GenericDevices;
+
+namespace TBF.Rig.Dummy.Valve
+{
+    public class Component : ComponentBase, IValve
+    {
+        private static readonly ILog log = LogManager.GetLogger(typeof(Component));
+        public override string ToString()
+        {
+            return string.Format("{0}({1})", this.GetType().Namespace.Substring(8), Cfg.ToString(1));
+        }
+
+        public Component()
+        {
+        }
+
+        public Component(Generic.IComponentCfg cfg)
+            : base(cfg)
+        {
+            log.Warn(this.ToString());
+        }
+
+		bool state;
+
+		public bool State { get { return state; } }
+		public ValveCategory Category { get { return ValveCategory.None; } }
+		public int Delay { get { return 1; } }
+		public IValve CoupledTo { get { return null; } }
+		public bool InvertCouple { get { return false; } }
+		public int LagOpening { get { return 0; } }
+		public int LagClosing { get { return 0; } }
+	}
+}

TBF/Rig/Dummy/Valve/Factory.cs

@@ -0,0 +1,28 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System.Collections.Generic;
+using TBF.Rig.Generic;
+using TBF.Rig.Configs.NameOnly;
+
+namespace TBF.Rig.Dummy.Valve
+{
+    public class Factory : IComponentFactory
+    {
+        public string ClassName { get { return this.GetType().Namespace.Substring(8); } }
+        public override string ToString() { return ClassName; }
+
+        public void ResetStaticProperties() { }
+
+        public IComponent DummyComponent() { return new Component(); }
+
+        public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new Component(cfg); }
+
+        public IComponentCfg DefaultConfig() { return new TestMethodCfg(this.GetType().Namespace.Substring(14), this); }
+
+        public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
+        {
+            return ComponentCfgBase.CreateFromDbEntity(TestMethodCfg.Serializer, component, this);
+        }
+    }
+}