Reconfigured for iPerl

RegulValve.adcChannel and Diverter.flowMtrNr4Cmd for GELSENWASSER

.gitignore

@@ -1,5 +1,13 @@
+Common/bin/
+Common/obj/
 Config/bin/
 Config/obj/
+DataStreamInterface/bin/
+DataStreamInterface/obj/
+DataStreamInterfaceTest/bin/
+DataStreamInterfaceTest/obj/
+DataStreamMeter/bin/
+DataStreamMeter/obj/
 Decrypt/bin/
 Decrypt/obj/
 DeviceTest/bin/
@@ -8,12 +16,26 @@ Dirichlet.Numerics/bin
 Dirichlet.Numerics/obj
 Encrypt/bin/
 Encrypt/obj/
+EventViewer/bin/
+EventViewer/obj/
+Events/bin/
+Events/obj/
+FeatureVectorCalculator/bin/
+FeatureVectorCalculator/obj/
 GemCard/bin
 GemCard/obj
+GenCode128/bin
+GenCode128/obj
 GraphLib/bin
 GraphLib/obj
+MergeResultsDBs/bin
+MergeResultsDBs/obj
 TracingDB/bin
 TracingDB/obj
+ResetBatchNr/bin
+ResetBatchNr/obj
+RestClient/bin
+RestClient/obj
 Results/bin/
 Results/obj/
 ResultsBrowser/bin/
@@ -22,13 +44,14 @@ Statistics/bin/
 Statistics/obj/
 TBF/bin/
 TBF/obj/
-TBFSetup/Debug/
-TBFSetup/Release/
+ToFirstMonitor/bin/
+ToFirstMonitor/obj/
+ToSecondMonitor/bin/
+ToSecondMonitor/obj/
 Users/bin/
 Users/obj/
 UserManagement/bin/
 UserManagement/obj/
-Doc/
 .vs/
 *.suo
 *.bak

Common/BackgroundBeep.cs

@@ -0,0 +1,37 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Threading;
+
+namespace Common
+{
+    public class BackgroundBeep
+    {
+        static Thread beepThread;
+        static AutoResetEvent signalBeep;
+
+        static BackgroundBeep()
+        {
+            signalBeep = new AutoResetEvent(false);
+            beepThread = new Thread(() =>
+            {
+                while (true)
+                {
+                    signalBeep.WaitOne();       /// waits for an event
+                    Console.Beep(500, 400);     /// frequency (Hz), duration (ms)
+                }
+            }, 1);
+            beepThread.IsBackground = true;
+            beepThread.Start();
+        }
+
+        /// <summary>
+        /// Invokes one beep in a separate thread (non-blocking function)
+        /// </summary>
+        public static void Beep()
+        {
+            signalBeep.Set();
+        }
+    }
+}

Common/Common.csproj

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{C8939821-BA5C-4988-A3D0-BF53B74865C7}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Common</RootNamespace>
+    <AssemblyName>Common</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="BackgroundBeep.cs" />
+    <Compile Include="Iperl\OptoTelegramRaw.cs" />
+    <Compile Include="SerializableDictionary.cs" />
+    <Compile Include="UIControls\CoolButtonCtrl.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="UIControls\CoolButtonCtrl.Designer.cs">
+      <DependentUpon>CoolButtonCtrl.cs</DependentUpon>
+    </Compile>
+    <Compile Include="UIControls\LviDateTimeColumnComparer.cs" />
+    <Compile Include="UIControls\RoundedRectangle.cs" />
+    <Compile Include="Utils.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UIControls\ListViewEx.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="UIControls\ListViewExtensions.cs" />
+    <Compile Include="UIControls\LviIntColumnComparer.cs" />
+    <Compile Include="UIControls\LviTextColumnComparer.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

Common/Iperl/OptoTelegramRaw.cs

@@ -1,12 +1,21 @@
 ///
-/// Copyright (c) 2015-2017 Sensus Metering Systems
+/// Copyright (c) 2015-2021 Sensus Metering Systems
 ///
 using System;
 using System.Globalization;
 
-namespace TBF.BenchControl.TestMethods.iPerlCommunication.iPerlHead
+namespace Common.Iperl
 {
-	public class OptoTelegramRaw
+    public enum OptoTelegramFlags : byte
+    {
+        OK = 0,
+        OK_TestStart,
+        OK_TestEnd,
+        InvalidTelegram,	/// Wrong telegram format of checksum error
+        SyncError,
+    }
+
+    public class OptoTelegramRaw
 	{
 		public static readonly int Length = 42;
 		private static CultureInfo culture;
@@ -96,16 +105,16 @@ namespace TBF.BenchControl.TestMethods.iPerlCommunication.iPerlHead
         /// </description>
         /// <param name="data">A complete byte array data</param>
         /// <returns>true = telegram OK, false = telegram NOK</returns>
-        public bool UpdateFromString(string telegram, int counter, ref Int64 volumeRawExtLast, ref Int64 timestampExtLast)
+        public bool UpdateFromString(string telegram, int counter, float refFlow, ref Int64 volumeRawExtLast, ref Int64 timestampExtLast, bool isLog = false)
 		{
 			DateTime = DateTime.Now;
 			Counter = counter;
-			RefFlow = (float)Sequences.ProcessData.RefFlow.Val;
+			RefFlow = refFlow;
 
 			if ((telegram == null) || (telegram.Length < Length) ||
 				(telegram[6]  != '\t') || (telegram[11] != '\t') || (telegram[16] != '\t') ||
 				(telegram[23] != '\t') || (telegram[28] != '\t') || (telegram[37] != '\t') ||
-                (telegram[40] != '\r') || (telegram[41] != '\n'))
+                (!isLog && (telegram[40] != '\r' || telegram[41] != '\n')))
 			{
                 Flags = OptoTelegramFlags.InvalidTelegram;
 				return false;
@@ -119,51 +128,61 @@ namespace TBF.BenchControl.TestMethods.iPerlCommunication.iPerlHead
 			bool f6 = UInt32.TryParse(telegram.Substring(29, 8), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out Timestamp);
 			bool f7 = byte.TryParse(telegram.Substring(38, 2), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out CheckSum);
 
-			bool allOk = f1 && f2 && f3 && f4 && f5 && f6 && f7;
+            byte calculatedCheckSum = 0;
+            for (int i = 0; i < Length - 4; i++)
+            {
+                calculatedCheckSum += (byte)telegram[i];
+            }
+
+            bool allOk = f1 && f2 && f3 && f4 && f5 && f6 && f7 && (calculatedCheckSum == CheckSum);
+
+            if (allOk)
+            {
+                ///
+                /// Cope with 'VolumeRaw' overflow
+                ///
+                Int64 uncorrected = (Int64)(((UInt64)volumeRawExtLast & 0xFFFFFFFFFF000000UL) | VolumeRaw);
+                if (Math.Abs(uncorrected - volumeRawExtLast) <= 0x800000L)
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected;
+                }
+                else if (Math.Abs(uncorrected + 0x1000000L - volumeRawExtLast) <= 0x800000L)
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected + 0x1000000L;
+                }
+                else if (Math.Abs(uncorrected - 0x1000000L - volumeRawExtLast) <= 0x800000L)
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected - 0x1000000L;
+                }
+                else
+                {
+                    VolumeRawExt = volumeRawExtLast = uncorrected;
+                }
+
+                ///
+                /// Cope with 'Timestamp' overflow
+                ///
+                uncorrected = (Int64)(((UInt64)timestampExtLast & 0xFFFFFFFF00000000UL) | Timestamp);
+                if (Math.Abs(uncorrected - timestampExtLast) <= 0x80000000L)
+                {
+                    TimestampExt = timestampExtLast = uncorrected;
+                }
+                else if (Math.Abs(uncorrected + 0x100000000L - timestampExtLast) <= 0x80000000L)
+                {
+                    TimestampExt = timestampExtLast = uncorrected + 0x100000000L;
+                }
+                else if (Math.Abs(uncorrected - 0x100000000L - timestampExtLast) <= 0x80000000L)
+                {
+                    TimestampExt = timestampExtLast = uncorrected - 0x100000000L;
+                }
+                else
+                {
+                    TimestampExt = timestampExtLast = uncorrected;
+                }
+            }
+
             Flags = allOk ? OptoTelegramFlags.OK : OptoTelegramFlags.InvalidTelegram;
 
-            ///
-            /// Cope with 'VolumeRaw' overflow
-            ///
-            Int64 uncorrected = (Int64)(((UInt64)volumeRawExtLast & 0xFFFFFFFFFF000000UL) | VolumeRaw);
-            if (Math.Abs(uncorrected - volumeRawExtLast) <= 0x800000L)
-            {
-                VolumeRawExt = volumeRawExtLast = uncorrected;
-            }
-            else if (Math.Abs(uncorrected + 0x1000000L - volumeRawExtLast) <= 0x800000L)
-            {
-                VolumeRawExt = volumeRawExtLast = uncorrected + 0x1000000L;
-            }
-            else if (Math.Abs(uncorrected - 0x1000000L - volumeRawExtLast) <= 0x800000L)
-            {
-                VolumeRawExt = volumeRawExtLast = uncorrected - 0x1000000L;
-            }
-            else
-            {
-                VolumeRawExt = volumeRawExtLast = uncorrected;
-            }
-
-            ///
-            /// Cope with 'Timestamp' overflow
-            ///
-            uncorrected = (Int64)(((UInt64)timestampExtLast & 0xFFFFFFFF00000000UL) | Timestamp);
-            if (Math.Abs(uncorrected - timestampExtLast) <= 0x80000000L)
-            {
-                TimestampExt = timestampExtLast = uncorrected;
-            }
-            else if (Math.Abs(uncorrected + 0x100000000L - timestampExtLast) <= 0x80000000L)
-            {
-                TimestampExt = timestampExtLast = uncorrected + 0x100000000L;
-            }
-            else if (Math.Abs(uncorrected - 0x100000000L - timestampExtLast) <= 0x80000000L)
-            {
-                TimestampExt = timestampExtLast = uncorrected - 0x100000000L;
-            }
-            else
-            {
-                TimestampExt = timestampExtLast = uncorrected;
-            }
-
             return allOk;
 		}
 
@@ -173,7 +192,7 @@ namespace TBF.BenchControl.TestMethods.iPerlCommunication.iPerlHead
         public bool UpdateFromStringDummy(string telegram)
         {
             DateTime = DateTime.Now;
-            RefFlow = (float)Sequences.ProcessData.RefFlow.Val;
+            RefFlow = 0;
 
             if ((telegram == null) || (telegram.Length < Length) ||
                 (telegram[6]  != '\t') || (telegram[11] != '\t') || (telegram[16] != '\t') ||
@@ -184,16 +203,19 @@ namespace TBF.BenchControl.TestMethods.iPerlCommunication.iPerlHead
                 return false;
             }
 
-			//bool f1 = UInt32.TryParse(telegram.Substring(0, 6), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out EmfRaw);
-			//bool f2 = Int16.TryParse(telegram.Substring(7, 4), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out MagneticFieldRaw);
-			//bool f3 = Int16.TryParse(telegram.Substring(12, 4), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out FlowRaw);
-			//bool f4 = UInt32.TryParse(telegram.Substring(17, 6), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out VolumeRaw);
-			//bool f5 = Int16.TryParse(telegram.Substring(24, 4), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out Impedance);
-			//bool f6 = UInt32.TryParse(telegram.Substring(29, 8), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out Timestamp);
-			//bool f7 = byte.TryParse(telegram.Substring(38, 2), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out CheckSum);
-			//return f1 && f2 && f3 && f4 && f5 && f6 && f7;
+            bool f7 = byte.TryParse(telegram.Substring(38, 2), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out CheckSum);
 
-			return true;
+            byte calculatedCheckSum = 0;
+            for (int i = 0; i < Length - 4; i++)
+            {
+                calculatedCheckSum += (byte)telegram[i];
+            }
+
+            bool allOk = f7 && (calculatedCheckSum == CheckSum);
+            
+            Flags = allOk ? OptoTelegramFlags.OK : OptoTelegramFlags.InvalidTelegram;
+
+            return allOk;
         }
 
 
@@ -241,80 +263,5 @@ namespace TBF.BenchControl.TestMethods.iPerlCommunication.iPerlHead
 									Label());
 			}
 		}
-
-		/// <summary>
-		/// Filter RefFlow data in an array of OptoTelegramRaw objects by a FIR filter:
-		/// 
-		/// kSize = 5, kSize2 = 2
-		/// 
-		///  i  k
-		///  ---------------------------------------------------------------------------
-		///  0 -5                        filtered[0] = data[0]
-		///  1 -4                        filtered[1] = data[1]
-		///  2 -3                        filtered[2] = data[0]*k[0] + ... + data[4]*k[4]
-		///  3 -2                        filtered[3] = data[1]*k[0] + ... + data[5]*k[4]
-		///  4 -1                        filtered[4] = data[2]*k[0] + ... + data[6]*k[4]
-		///  5  0 data[0] = filtered[0], filtered[0] = data[3]*k[0] + ... + data[7]*k[4]
-		///  6  1 data[1] = filtered[1], filtered[1] = data[4]*k[0] + ... + data[8]*k[4]
-		///  7    ...
-		/// </summary>
-		/// <param name="optoData">array of OptoTelegramRaw objects</param>
-        /// <param name="from">Index of the first optoData item to process</param>
-        /// <param name="to">Index of the last optoData item to process</param>
-        public static void FIRFilterFlow(OptoTelegramRaw[] optoData, int from, int to)
-		{
-			float[] kernel = new float[] { 0.1f, 0.2f, 0.4f, 0.2f, 0.1f };
-			int kSize = kernel.Length;
-			int kSize2 = kernel.Length / 2;
-
-			float[] filtered = new float[kSize];
-
-			for (int i = from; i <= to; i++)
-			{
-                if ((i < from + kSize2) || (i > to - kSize2))
-				{
-                    /// Beginning or end of optoData buffer => Just copy data (=do not filter)
-					filtered[i % kSize] = optoData[BufferIdx(i)].RefFlow;
-				}
-				else
-				{
-                    /// Make a convolution of optoData and the kernel
-					float weightedSum = 0;
-					for (int j = -kSize2; j <= kSize2; j++)
-						weightedSum += optoData[BufferIdx(i + j)].RefFlow * kernel[j + kSize2];
-
-                    filtered[i % kSize] = weightedSum;
-				}
-
-                if (i >= from + kSize)
-                {
-                    /// filtered[] buffer full => copy filtered data to optoData
-                    optoData[BufferIdx(i - kSize)].RefFlow = filtered[i % kSize];
-                }
-            }
-
-			for (int i = to - kSize + 1; i <= to; i++)
-			{
-				if (i >= 0) optoData[BufferIdx(i)].RefFlow = filtered[i % kSize];
-			}
-		}
-
-        /// <summary>
-        /// Get index to optoData buffer
-        /// </summary>
-        /// <param name="index">Original unwrapped index</param>
-        /// <returns>Index to the buffer</returns>
-        public static int BufferIdx(int index)
-        {
-            if (index < IperlHead.MaxOptoDataCount)
-            {
-                return index;
-            }
-            else
-            {
-                return IperlHead.StartOptoDataCount + (index - IperlHead.MaxOptoDataCount) % IperlHead.EndOptoDataCount;
-            }
-        }
-
 	}
 }

Common/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Common")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Common")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4e3e3538-fd80-47d5-9417-2268afa590cf")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Common/SerializableDictionary.cs

@@ -0,0 +1,72 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace Common
+{
+    [XmlRoot("dictionary")]
+    public class SerializableDictionary<TKey, TValue>
+        : Dictionary<TKey, TValue>, IXmlSerializable
+    {
+        public System.Xml.Schema.XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        public void ReadXml(System.Xml.XmlReader reader)
+        {
+            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
+            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
+
+            bool wasEmpty = reader.IsEmptyElement;
+            reader.Read();
+
+            if (wasEmpty)
+                return;
+
+            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
+            {
+                reader.ReadStartElement("item");
+
+                reader.ReadStartElement("key");
+                TKey key = (TKey)keySerializer.Deserialize(reader);
+                reader.ReadEndElement();
+
+                reader.ReadStartElement("value");
+                TValue value = (TValue)valueSerializer.Deserialize(reader);
+                reader.ReadEndElement();
+
+                this.Add(key, value);
+
+                reader.ReadEndElement();
+                reader.MoveToContent();
+            }
+            reader.ReadEndElement();
+        }
+
+        public void WriteXml(System.Xml.XmlWriter writer)
+        {
+            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
+            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
+
+            foreach (TKey key in this.Keys)
+            {
+                writer.WriteStartElement("item");
+
+                writer.WriteStartElement("key");
+                keySerializer.Serialize(writer, key);
+                writer.WriteEndElement();
+
+                writer.WriteStartElement("value");
+                TValue value = this[key];
+                valueSerializer.Serialize(writer, value);
+                writer.WriteEndElement();
+
+                writer.WriteEndElement();
+            }
+        }
+    }
+}

Common/UIControls/CoolButtonCtrl.Designer.cs

@@ -0,0 +1,54 @@
+namespace Common.UIControls
+{
+    partial class CoolButtonCtrl
+    {
+        /// <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.SuspendLayout();
+            // 
+            // CoolButton
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.BackColor = System.Drawing.Color.Transparent;
+            this.DoubleBuffered = true;
+            this.Name = "CoolButton";
+            this.Size = new System.Drawing.Size(72, 29);
+            this.Load += new System.EventHandler(this.CoolButtonLoad);
+            this.SizeChanged += new System.EventHandler(this.CoolButtonSizeChanged);
+            this.Paint += new System.Windows.Forms.PaintEventHandler(this.CoolButtonPaint);
+            this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.CoolButtonMouseDown);
+            this.MouseEnter += new System.EventHandler(this.CoolButtonMouseEnter);
+            this.MouseLeave += new System.EventHandler(this.CoolButtonMouseLeave);
+            this.MouseUp += new System.Windows.Forms.MouseEventHandler(this.CoolButtonMouseUp);
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+    }
+}

Common/UIControls/CoolButtonCtrl.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public partial class CoolButtonCtrl : UserControl
+    {
+        private Color _buttonColor;
+        private Color _textColor;
+        private Color _focusColor;
+        private Color _borderColor;
+        private Color _highlightBorderColor;
+        private Color _highlightButtonColor;
+        private Font _buttonFont;
+        private string _buttonText;
+        private bool _mouseOver;
+        private bool _mouseDown;
+
+        public delegate void ButtonClickedArgs(object sender);
+
+        public event ButtonClickedArgs ButtonClicked;
+
+        public Color FocusColor
+        {
+            get { return _focusColor; }
+            set
+            {
+                _focusColor = value;
+                Refresh();
+            }
+        }
+
+        public Color TextColor
+        {
+            get { return _textColor; }
+            set
+            {
+                _textColor = value;
+                Refresh();
+            }
+        }
+
+        public Color HighlightBorderColor
+        {
+            get { return _highlightBorderColor; }
+            set
+            {
+                _highlightBorderColor = value;
+                Refresh();
+            }
+        }
+
+        public Color HighlightButtonColor
+        {
+            get { return _highlightButtonColor; }
+            set
+            {
+                _highlightButtonColor = value;
+                Refresh();
+            }
+        }
+
+        public string ButtonText
+        {
+            get { return _buttonText; }
+            set
+            {
+                _buttonText = value;
+                Refresh();
+            }
+        }
+
+        public Font ButtonFont
+        {
+            get { return _buttonFont; }
+            set
+            {
+                _buttonFont = value;
+                Refresh();
+            }
+        }
+
+        public Color BorderColor
+        {
+            get { return _borderColor; }
+            set
+            {
+                _borderColor = value;
+                Refresh();
+            }
+        }
+
+        public Color ButtonColor
+        {
+            get { return _buttonColor; }
+            set
+            {
+                _buttonColor = value;
+                Refresh();
+            }
+        }
+
+        public CoolButtonCtrl()
+        {
+            InitializeComponent();
+
+            _buttonColor = Color.FromArgb(243, 243, 243);
+            _borderColor = Color.FromArgb(220, 220, 220);
+            _highlightBorderColor = Color.FromArgb(198, 198, 198);
+            _highlightButtonColor = Color.FromArgb(246, 246, 246);
+            _focusColor = Color.FromArgb(77, 144, 254);
+            _buttonFont = new Font("Arial", 8, FontStyle.Bold);
+            _buttonText = "button";
+            _textColor = Color.Black;
+
+            _mouseOver = false;
+            _mouseDown = false;
+
+            LostFocus += CoolButtonFocus;
+            GotFocus += CoolButtonFocus;
+        }
+
+        void CoolButtonFocus(object sender, EventArgs e)
+        {
+            Refresh();
+        }
+
+        private void CoolButtonLoad(object sender, EventArgs e)
+        {
+
+        }
+
+        private void CoolButtonPaint(object sender, PaintEventArgs e)
+        {
+            var bmp = new Bitmap(ClientSize.Width, ClientSize.Height);
+            Graphics g = Graphics.FromImage(bmp);
+
+            if (!_mouseOver)
+            {
+                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
+                GraphicsPath path = RoundedRectangle.Create(0, 0, ClientSize.Width - 4, ClientSize.Height - 4);
+                SizeF fontSize = g.MeasureString(_buttonText, _buttonFont);
+                int horWidth = ((ClientSize.Width - 4 - (int)fontSize.Width) / 2);
+                int verHeight = ((ClientSize.Height - 4 - (int)fontSize.Height) / 2);
+
+                g.FillPath(new SolidBrush(_buttonColor), path);
+                g.DrawPath(Focused ? new Pen(_focusColor) : new Pen(_borderColor), path);
+                g.DrawString(_buttonText, _buttonFont, new SolidBrush(_textColor), horWidth, verHeight);
+            }
+            else
+            {
+                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
+                GraphicsPath path = RoundedRectangle.Create(0, 0, ClientSize.Width - 4, ClientSize.Height - 4);
+                SizeF fontSize = g.MeasureString(_buttonText, _buttonFont);
+                int horWidth = ((ClientSize.Width - 4 - (int)fontSize.Width) / 2);
+                int verHeight = ((ClientSize.Height - 4 - (int)fontSize.Height) / 2);
+
+                g.FillPath(new SolidBrush(_highlightButtonColor), path);
+                g.DrawPath(ContainsFocus ? new Pen(_focusColor) : new Pen(_borderColor), path);
+                g.DrawString(_buttonText, _buttonFont, new SolidBrush(_textColor), horWidth, verHeight);
+
+                Color a1 = Color.FromArgb(255, 198, 198, 198);
+                Color a2 = Color.FromArgb(128, 198, 198, 198);
+                Color a3 = Color.FromArgb(64, 198, 198, 198);
+
+                var shadowBmp = new Bitmap(1, 3);
+                var shadowBmp2 = new Bitmap(3, 1);
+                shadowBmp.SetPixel(0, 0, a1);
+                shadowBmp.SetPixel(0, 1, a2);
+                shadowBmp.SetPixel(0, 2, a3);
+
+                shadowBmp2.SetPixel(0, 0, a1);
+                shadowBmp2.SetPixel(1, 0, a2);
+                shadowBmp2.SetPixel(2, 0, a3);
+
+                for (int z = 4; z < ClientSize.Width - 4; z++)
+                {
+                    g.DrawImage(shadowBmp, z, ClientSize.Height - 4, 1, 3);
+                }
+                for (int z = 4; z < ClientSize.Height - 4; z++)
+                {
+                    g.DrawImage(shadowBmp2, ClientSize.Width - 4, z, 3, 1);
+                }
+                g.DrawPath(Focused ? new Pen(_focusColor) : new Pen(_borderColor), path);
+            }
+
+            e.Graphics.DrawImage(bmp, 0, 0, ClientSize.Width, ClientSize.Height);
+            //bmp.Dispose();
+        }
+
+        private void CoolButtonMouseEnter(object sender, EventArgs e)
+        {
+            _mouseOver = true;
+            Refresh();
+        }
+
+        private void CoolButtonMouseLeave(object sender, EventArgs e)
+        {
+            _mouseOver = false;
+            _mouseDown = false;
+            Refresh();
+        }
+
+        private void CoolButtonSizeChanged(object sender, EventArgs e)
+        {
+            Refresh();
+        }
+
+        private void CoolButtonMouseDown(object sender, MouseEventArgs e)
+        {
+            if (e.Button == MouseButtons.Left)
+                _mouseDown = true;
+        }
+
+        private void CoolButtonMouseUp(object sender, MouseEventArgs e)
+        {
+            if (e.Button != MouseButtons.Left)
+                return;
+            if (_mouseDown)
+            {
+                if (ButtonClicked != null)
+                {
+                    ButtonClicked(this);
+                }
+            }
+            _mouseDown = false;
+        }
+    }
+}

Common/UIControls/CoolButtonCtrl.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=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

Common/UIControls/ListViewEx.cs

@@ -0,0 +1,486 @@
+///
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace Common.UIControls
+{
+	/// <summary>
+	/// Event Handler for SubItem events
+	/// </summary>
+	public delegate void SubItemEventHandler(object sender, SubItemEventArgs e);
+	/// <summary>
+	/// Event Handler for SubItemEndEditing events
+	/// </summary>
+	public delegate void SubItemEndEditingEventHandler(object sender, SubItemEndEditingEventArgs e);
+
+
+	///	<summary>
+	///	Inherited ListView to allow in-place editing of subitems
+	///	</summary>
+	public class ListViewEx	: System.Windows.Forms.ListView
+	{
+		#region Interop structs, imports and constants
+		/// <summary>
+		/// MessageHeader for WM_NOTIFY
+		/// </summary>
+		private struct NMHDR 
+		{ 
+#pragma warning disable
+			public IntPtr hwndFrom; 
+			public Int32  idFrom; 
+			public Int32  code;
+#pragma warning restore
+        }
+
+
+		[DllImport("user32.dll")]
+		private	static extern IntPtr SendMessage(IntPtr hWnd, int msg,	IntPtr wPar, IntPtr	lPar);
+		[DllImport("user32.dll", CharSet=CharSet.Ansi)]
+		private	static extern IntPtr SendMessage(IntPtr	hWnd, int msg, int len,	ref	int	[] order);
+
+		// ListView messages
+		private const int LVM_FIRST					= 0x1000;
+		private const int LVM_GETCOLUMNORDERARRAY	= (LVM_FIRST + 59);
+
+		// Windows Messages that will abort editing
+		private	const int WM_HSCROLL = 0x114;
+		private	const int WM_VSCROLL = 0x115;
+		private const int WM_SIZE	 = 0x05;
+		private const int WM_NOTIFY	 = 0x4E;
+
+		private const int HDN_FIRST = -300;
+		private const int HDN_BEGINDRAG = (HDN_FIRST-10);
+		private const int HDN_ITEMCHANGINGA = (HDN_FIRST-0);
+		private const int HDN_ITEMCHANGINGW = (HDN_FIRST-20);
+		#endregion
+
+		///	<summary>
+		///	Required designer variable.
+		///	</summary>
+		private	System.ComponentModel.Container	components = null;
+
+		public event SubItemEventHandler SubItemClicked;
+        public event SubItemEventHandler SubItemRightClicked;
+        public event SubItemEventHandler SubItemBeginEditing;
+		public event SubItemEndEditingEventHandler SubItemEndEditing;
+
+		public ListViewEx()
+		{
+			// This	call is	required by	the	Windows.Forms Form Designer.
+			InitializeComponent();
+
+			base.FullRowSelect = true;
+			base.View = View.Details;
+			base.AllowColumnReorder = true;
+		}
+
+		///	<summary>
+		///	Clean up any resources being used.
+		///	</summary>
+		protected override void	Dispose( bool disposing	)
+		{
+			if(	disposing )
+			{
+				if(	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()
+		{
+			components = new System.ComponentModel.Container();
+		}
+	  #endregion
+
+		private bool _doubleClickActivation = false;
+		/// <summary>
+		/// Is a double click required to start editing a cell?
+		/// </summary>
+		public bool DoubleClickActivation
+		{
+			get {  return _doubleClickActivation; }
+			set { _doubleClickActivation = value; }    
+		}
+
+
+		/// <summary>
+		/// Retrieve the order in which columns appear
+		/// </summary>
+		/// <returns>Current display order of column indices</returns>
+		public int[] GetColumnOrder()
+		{
+			IntPtr lPar	= Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * Columns.Count);
+
+			IntPtr res = SendMessage(Handle, LVM_GETCOLUMNORDERARRAY, new IntPtr(Columns.Count), lPar);
+			if (res.ToInt32() == 0)	// Something went wrong
+			{
+				Marshal.FreeHGlobal(lPar);
+				return null;
+			}
+
+			int	[] order = new int[Columns.Count];
+			Marshal.Copy(lPar, order, 0, Columns.Count);
+
+			Marshal.FreeHGlobal(lPar);
+
+			return order;
+		}
+
+
+		/// <summary>
+		/// Find ListViewItem and SubItem Index at position (x,y)
+		/// </summary>
+		/// <param name="x">relative to ListView</param>
+		/// <param name="y">relative to ListView</param>
+		/// <param name="item">Item at position (x,y)</param>
+		/// <returns>SubItem index</returns>
+		public int GetSubItemAt(int x, int y, out ListViewItem item)
+		{
+			item = this.GetItemAt(x, y);
+		
+			if (item !=	null)
+			{
+				int[] order = GetColumnOrder();
+				Rectangle lviBounds;
+				int	subItemX;
+
+				lviBounds =	item.GetBounds(ItemBoundsPortion.Entire);
+				subItemX = lviBounds.Left;
+				for (int i=0; i<order.Length; i++)
+				{
+					ColumnHeader h = this.Columns[order[i]];
+					if (x <	subItemX+h.Width)
+					{
+						return h.Index;
+					}
+					subItemX += h.Width;
+				}
+			}
+			
+			return -1;
+		}
+
+
+		/// <summary>
+		/// Get bounds for a SubItem
+		/// </summary>
+		/// <param name="Item">Target ListViewItem</param>
+		/// <param name="SubItem">Target SubItem index</param>
+		/// <returns>Bounds of SubItem (relative to ListView)</returns>
+		public Rectangle GetSubItemBounds(ListViewItem Item, int SubItem)
+		{
+			int[] order = GetColumnOrder();
+
+			Rectangle subItemRect = Rectangle.Empty;
+			if (SubItem >= order.Length)
+				throw new IndexOutOfRangeException("SubItem "+SubItem+" out of range");
+
+			if (Item == null)
+				throw new ArgumentNullException("Item");
+			
+			Rectangle lviBounds = Item.GetBounds(ItemBoundsPortion.Entire);
+			int	subItemX = lviBounds.Left;
+
+			ColumnHeader col;
+			int i;
+			for (i=0; i<order.Length; i++)
+			{
+				col = this.Columns[order[i]];
+				if (col.Index == SubItem)
+					break;
+				subItemX += col.Width;
+			} 
+			subItemRect	= new Rectangle(subItemX, lviBounds.Top, this.Columns[order[i]].Width, lviBounds.Height);
+			return subItemRect;
+		}
+
+
+		protected override void	WndProc(ref	Message	msg)
+		{
+			switch (msg.Msg)
+			{
+				// Look	for	WM_VSCROLL,WM_HSCROLL or WM_SIZE messages.
+				case WM_VSCROLL:
+				case WM_HSCROLL:
+				case WM_SIZE:
+					EndEditing(false);
+					break;
+				case WM_NOTIFY:
+					// Look for WM_NOTIFY of events that might also change the
+					// editor's position/size: Column reordering or resizing
+					NMHDR h = (NMHDR)Marshal.PtrToStructure(msg.LParam, typeof(NMHDR));
+					if (h.code == HDN_BEGINDRAG ||
+						h.code == HDN_ITEMCHANGINGA ||
+						h.code == HDN_ITEMCHANGINGW)
+						EndEditing(false);
+					break;
+			}
+
+			base.WndProc(ref msg);
+		}
+
+
+		#region Initialize editing depending of DoubleClickActivation property
+		protected override void OnMouseUp(System.Windows.Forms.MouseEventArgs e)
+		{
+			base.OnMouseUp(e);
+
+            MouseEventArgs me = (MouseEventArgs)e;
+            if (me.Button == MouseButtons.Right)
+            {
+                /// Right mouse button click function
+                RightClickFunctionSubitemAt(new Point(e.X, e.Y));
+            }
+            else
+            {
+                /// Normal function (=edit item)
+                if (DoubleClickActivation)
+                {
+                    return;
+                }
+
+                EditSubitemAt(new Point(e.X, e.Y));
+            }
+		}
+		
+		protected override void OnDoubleClick(EventArgs e)
+		{
+			base.OnDoubleClick (e);
+
+			if (!DoubleClickActivation)
+			{
+				return;
+			} 
+
+			Point pt = this.PointToClient(Cursor.Position);
+		
+			EditSubitemAt(pt);
+		}
+
+		///<summary>
+		/// Fire SubItemClicked
+		///</summary>
+		///<param name="p">Point of click/doubleclick</param>
+		private void EditSubitemAt(Point p)
+		{
+			ListViewItem item;
+			int idx = GetSubItemAt(p.X, p.Y, out item);
+			if (idx >= 0)
+			{
+				OnSubItemClicked(new SubItemEventArgs(item, idx));
+			}
+		}
+
+        ///<summary>
+        /// Fire SubItemRightClicked
+        ///</summary>
+        ///<param name="p">Point of click/doubleclick</param>
+        private void RightClickFunctionSubitemAt(Point p)
+        {
+            ListViewItem item;
+            int idx = GetSubItemAt(p.X, p.Y, out item);
+            if (idx >= 0)
+            {
+                OnSubItemRightClicked(new SubItemEventArgs(item, idx));
+            }
+        }
+
+		#endregion
+
+		#region In-place editing functions
+		// The control performing the actual editing
+		private Control _editingControl;
+		// The LVI being edited
+		private ListViewItem _editItem;
+		// The SubItem being edited
+		private int _editSubItem;
+
+		protected void OnSubItemBeginEditing(SubItemEventArgs e)
+		{
+			if (SubItemBeginEditing != null) SubItemBeginEditing(this, e);
+		}
+
+		protected void OnSubItemEndEditing(SubItemEndEditingEventArgs e)
+		{
+			if (SubItemEndEditing != null) SubItemEndEditing(this, e);
+		}
+
+		protected void OnSubItemClicked(SubItemEventArgs e)
+		{
+			if (SubItemClicked != null) SubItemClicked(this, e);
+		}
+
+        protected void OnSubItemRightClicked(SubItemEventArgs e)
+        {
+            if (SubItemRightClicked != null) SubItemRightClicked(this, e);
+        }
+
+
+		/// <summary>
+		/// Begin in-place editing of given cell
+		/// </summary>
+		/// <param name="c">Control used as cell editor</param>
+		/// <param name="Item">ListViewItem to edit</param>
+		/// <param name="SubItem">SubItem index to edit</param>
+		public void StartEditing(Control c, ListViewItem Item, int SubItem)
+		{
+			OnSubItemBeginEditing(new SubItemEventArgs(Item, SubItem));
+
+			Rectangle rcSubItem = GetSubItemBounds(Item, SubItem);
+
+			if (rcSubItem.X < 0)
+			{
+				// Left edge of SubItem not visible - adjust rectangle position and width
+				rcSubItem.Width += rcSubItem.X;
+				rcSubItem.X=0;
+			}
+			if (rcSubItem.X+rcSubItem.Width > this.Width)
+			{
+				// Right edge of SubItem not visible - adjust rectangle width
+				rcSubItem.Width = this.Width-rcSubItem.Left;
+			}
+
+			// Subitem bounds are relative to the location of the ListView!
+			rcSubItem.Offset(Left, Top);
+
+			// In case the editing control and the listview are on different parents,
+			// account for different origins
+			Point origin = new Point(0,0);
+			Point lvOrigin  = this.Parent.PointToScreen(origin);
+			Point ctlOrigin  = c.Parent.PointToScreen(origin);
+
+			rcSubItem.Offset(lvOrigin.X-ctlOrigin.X, lvOrigin.Y-ctlOrigin.Y);
+
+			// Position and show editor
+			c.Bounds = rcSubItem;
+			c.Text = Item.SubItems[SubItem].Text;
+			c.Visible = true;
+			c.BringToFront();
+			c.Focus();
+
+			_editingControl = c;
+			_editingControl.Leave += new EventHandler(_editControl_Leave);
+			_editingControl.KeyPress += new KeyPressEventHandler(_editControl_KeyPress);
+
+			_editItem = Item;
+			_editSubItem = SubItem;
+		}
+
+
+		private void _editControl_Leave(object sender, EventArgs e)
+		{
+			// cell editor losing focus
+			EndEditing(true);
+		}
+
+		private void _editControl_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
+		{
+			switch (e.KeyChar)
+			{
+				case (char)(int)Keys.Escape:
+				{
+					EndEditing(false);
+					break;
+				}
+
+				case (char)(int)Keys.Enter:
+				{  
+					EndEditing(true);
+					break;
+				}
+			}
+		}
+
+		/// <summary>
+		/// Accept or discard current value of cell editor control
+		/// </summary>
+		/// <param name="AcceptChanges">Use the _editingControl's Text as new SubItem text or discard changes?</param>
+		public void EndEditing(bool AcceptChanges)
+		{
+			if (_editingControl == null)
+				return;
+
+			SubItemEndEditingEventArgs e = new SubItemEndEditingEventArgs(
+				_editItem,		// The item being edited
+				_editSubItem,	// The subitem index being edited
+				AcceptChanges ?
+					_editingControl.Text :	// Use editControl text if changes are accepted
+					_editItem.SubItems[_editSubItem].Text,	// or the original subitem's text, if changes are discarded
+				!AcceptChanges	// Cancel?
+			);
+
+			OnSubItemEndEditing(e);
+
+			_editItem.SubItems[_editSubItem].Text = e.DisplayText;
+
+			_editingControl.Leave -= new EventHandler(_editControl_Leave);
+			_editingControl.KeyPress -= new KeyPressEventHandler(_editControl_KeyPress);
+
+			_editingControl.Visible = false;
+
+			_editingControl = null;
+			_editItem = null;
+			_editSubItem = -1;
+		}
+		#endregion
+	}
+
+	
+	/// <summary>
+	/// Event Args for SubItemClicked event
+	/// </summary>
+	public class SubItemEventArgs : EventArgs
+	{
+        int subItem = -1;     /// Sub-item index
+        ListViewItem item = null;
+
+        public int SubItem { get { return subItem; } }
+        public ListViewItem Item { get { return item; } }
+
+        public SubItemEventArgs(ListViewItem item, int subItem)
+		{
+			this.subItem = subItem;
+			this.item = item;
+		}
+	}
+
+
+	/// <summary>
+	/// Event Args for SubItemEndEditingClicked event
+	/// </summary>
+	public class SubItemEndEditingEventArgs : SubItemEventArgs
+	{
+		string displayText = string.Empty;
+		bool cancel = true;
+
+		public SubItemEndEditingEventArgs(ListViewItem item, int subItem, string displayText, bool cancel) :
+			base(item, subItem)
+		{
+			this.displayText = displayText;
+			this.cancel = cancel;
+		}
+		public string DisplayText
+		{
+			get { return displayText; }
+			set { displayText = value; }
+		}
+		public bool Cancel
+		{
+			get { return cancel; }
+			set { cancel = value; }
+		}
+	}
+}

Common/UIControls/ListViewEx.resx

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<root>
+	<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+		<xsd:element name="root" msdata:IsDataSet="true">
+			<xsd:complexType>
+				<xsd:choice maxOccurs="unbounded">
+					<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" />
+							<xsd:attribute name="type" type="xsd:string" />
+							<xsd:attribute name="mimetype" type="xsd:string" />
+						</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>1.0.0.0</value>
+	</resheader>
+	<resheader name="Reader">
+		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+	<resheader name="Writer">
+		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+</root>

Common/UIControls/ListViewExtensions.cs

@@ -0,0 +1,107 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static class ListViewExtensions
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        public struct HDITEM
+        {
+            public Mask mask;
+            public int cxy;
+            [MarshalAs(UnmanagedType.LPTStr)]
+            public string pszText;
+            public IntPtr hbm;
+            public int cchTextMax;
+            public Format fmt;
+            public IntPtr lParam;
+            // _WIN32_IE >= 0x0300 
+            public int iImage;
+            public int iOrder;
+            // _WIN32_IE >= 0x0500
+            public uint type;
+            public IntPtr pvFilter;
+            // _WIN32_WINNT >= 0x0600
+            public uint state;
+
+            [Flags]
+            public enum Mask
+            {
+                Format = 0x4,       // HDI_FORMAT
+            };
+
+            [Flags]
+            public enum Format
+            {
+                SortDown = 0x200,   // HDF_SORTDOWN
+                SortUp = 0x400,     // HDF_SORTUP
+            };
+        };
+
+        public const int LVM_FIRST = 0x1000;
+        public const int LVM_GETHEADER = LVM_FIRST + 31;
+
+        public const int HDM_FIRST = 0x1200;
+        public const int HDM_GETITEM = HDM_FIRST + 11;
+        public const int HDM_SETITEM = HDM_FIRST + 12;
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr SendMessage(IntPtr hWnd, UInt32 msg, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        public static extern IntPtr SendMessage(IntPtr hWnd, UInt32 msg, IntPtr wParam, ref HDITEM lParam);
+
+        public static void SetSortIcon(this ListViewEx listViewControl, int columnIndex, SortOrder order)
+        {
+            IntPtr columnHeader = SendMessage(listViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
+            for (int columnNumber = 0; columnNumber <= listViewControl.Columns.Count - 1; columnNumber++)
+            {
+                var columnPtr = new IntPtr(columnNumber);
+                var item = new HDITEM
+                {
+                    mask = HDITEM.Mask.Format
+                };
+
+                if (SendMessage(columnHeader, HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
+                {
+                    throw new Win32Exception();
+                }
+
+                if (order != SortOrder.None && columnNumber == columnIndex)
+                {
+                    switch (order)
+                    {
+                        case SortOrder.Ascending:
+                            item.fmt &= ~HDITEM.Format.SortDown;
+                            item.fmt |= HDITEM.Format.SortUp;
+                            break;
+
+                        case SortOrder.Descending:
+                            item.fmt &= ~HDITEM.Format.SortUp;
+                            item.fmt |= HDITEM.Format.SortDown;
+                            break;
+
+                        default:
+                            break;
+                    }
+                }
+                else
+                {
+                    item.fmt &= ~HDITEM.Format.SortDown & ~HDITEM.Format.SortUp;
+                }
+
+                if (SendMessage(columnHeader, HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
+                {
+                    throw new Win32Exception();
+                }
+            }
+        }
+    }
+}

Common/UIControls/LviDateTimeColumnComparer.cs

@@ -0,0 +1,46 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public class LviDateTimeColumnComparer : IComparer
+    {
+        int column;
+        SortOrder order;
+
+        public LviDateTimeColumnComparer()
+        {
+            column = 0;
+            order = SortOrder.Ascending;
+        }
+
+        public LviDateTimeColumnComparer(int column, SortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            DateTime valX = DateTime.Parse(((ListViewItem)x).SubItems[column].Text);
+            DateTime valY = DateTime.Parse(((ListViewItem)y).SubItems[column].Text);
+
+            if (valX == valY)
+            {
+                return 0;
+            }
+            else if (order == SortOrder.Ascending)
+            {
+                return (valX > valY) ? 1 : -1;
+            }
+            else
+            {
+                return (valY > valX) ? 1 : -1;
+            }
+        }
+    }
+}

Common/UIControls/LviIntColumnComparer.cs

@@ -0,0 +1,34 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public class LviIntColumnComparer : IComparer
+    {
+        int column;
+        SortOrder order;
+
+        public LviIntColumnComparer()
+        {
+            column = 0;
+            order = SortOrder.Ascending;
+        }
+
+        public LviIntColumnComparer(int column, SortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            int valX = int.Parse(((ListViewItem)x).SubItems[column].Text);
+            int valY = int.Parse(((ListViewItem)y).SubItems[column].Text);
+            return (order == SortOrder.Descending) ? (valY - valX) : (valX - valY);
+        }
+    }
+}

Common/UIControls/LviTextColumnComparer.cs

@@ -0,0 +1,34 @@
+///
+/// Copyright (c) 2019-2020 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace Common.UIControls
+{
+    public class LviTextColumnComparer : IComparer
+    {
+        private int column;
+        SortOrder order;
+
+        public LviTextColumnComparer()
+        {
+            column = 0;
+            order = SortOrder.Ascending;
+        }
+
+        public LviTextColumnComparer(int column, SortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            string txtX = ((ListViewItem)x).SubItems[column].Text;
+            string txtY = ((ListViewItem)y).SubItems[column].Text;
+            return (order == SortOrder.Descending) ? String.Compare(txtY, txtX) : String.Compare(txtX, txtY);
+        }
+    }
+}

Common/UIControls/RoundedRectangle.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+
+namespace Common.UIControls
+{
+    public abstract class RoundedRectangle
+    {
+        [Flags]
+        public enum RectangleCorners
+        {
+            None = 0, TopLeft = 1, TopRight = 2, BottomLeft = 4, BottomRight = 8,
+            All = TopLeft | TopRight | BottomLeft | BottomRight
+        }
+
+        public static GraphicsPath Create(int x, int y, int width, int height,
+                                          int radius, RectangleCorners corners)
+        {
+            int xw = x + width;
+            int yh = y + height;
+            int xwr = xw - radius;
+            int yhr = yh - radius;
+            int xr = x + radius;
+            int yr = y + radius;
+            int r2 = radius * 2;
+            int xwr2 = xw - r2;
+            int yhr2 = yh - r2;
+
+            var p = new GraphicsPath();
+            p.StartFigure();
+
+            //Top Left Corner
+            if ((RectangleCorners.TopLeft & corners) == RectangleCorners.TopLeft)
+            {
+                p.AddArc(x, y, r2, r2, 180, 90);
+            }
+            else
+            {
+                p.AddLine(x, yr, x, y);
+                p.AddLine(x, y, xr, y);
+            }
+
+            //Top Edge
+            p.AddLine(xr, y, xwr, y);
+
+            //Top Right Corner
+            if ((RectangleCorners.TopRight & corners) == RectangleCorners.TopRight)
+            {
+                p.AddArc(xwr2, y, r2, r2, 270, 90);
+            }
+            else
+            {
+                p.AddLine(xwr, y, xw, y);
+                p.AddLine(xw, y, xw, yr);
+            }
+
+            //Right Edge
+            p.AddLine(xw, yr, xw, yhr);
+
+            //Bottom Right Corner
+            if ((RectangleCorners.BottomRight & corners) == RectangleCorners.BottomRight)
+            {
+                p.AddArc(xwr2, yhr2, r2, r2, 0, 90);
+            }
+            else
+            {
+                p.AddLine(xw, yhr, xw, yh);
+                p.AddLine(xw, yh, xwr, yh);
+            }
+
+            //Bottom Edge
+            p.AddLine(xwr, yh, xr, yh);
+
+            //Bottom Left Corner
+            if ((RectangleCorners.BottomLeft & corners) == RectangleCorners.BottomLeft)
+            {
+                p.AddArc(x, yhr2, r2, r2, 90, 90);
+            }
+            else
+            {
+                p.AddLine(xr, yh, x, yh);
+                p.AddLine(x, yh, x, yhr);
+            }
+
+            //Left Edge
+            p.AddLine(x, yhr, x, yr);
+
+            p.CloseFigure();
+            return p;
+        }
+
+        public static GraphicsPath Create(Rectangle rect, int radius, RectangleCorners c)
+        { return Create(rect.X, rect.Y, rect.Width, rect.Height, radius, c); }
+
+        public static GraphicsPath Create(int x, int y, int width, int height, int radius)
+        { return Create(x, y, width, height, radius, RectangleCorners.All); }
+
+        public static GraphicsPath Create(Rectangle rect, int radius)
+        { return Create(rect.X, rect.Y, rect.Width, rect.Height, radius); }
+
+        public static GraphicsPath Create(int x, int y, int width, int height)
+        { return Create(x, y, width, height, 5); }
+
+        public static GraphicsPath Create(Rectangle rect)
+        { return Create(rect.X, rect.Y, rect.Width, rect.Height); }
+    }
+}

Common/Utils.cs

@@ -0,0 +1,62 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Common
+{
+    public class Utils
+    {
+        public static string GetTestName(string name, int repeats, int repetitionNr)
+        {
+            if (name == null) return null;
+            if (repeats == 1) return name;
+            return string.Format("{0} ({1}/{2})", name, repetitionNr, repeats);
+        }
+
+        public static void CalculateFeatureVector(Iperl.OptoTelegramRaw[] optoData, int optoDataCount, int startIx, int endIx, ref float[] x)
+        {
+            if (startIx < 0 || endIx >= optoDataCount || startIx >= endIx) return;
+
+            int n = 0;
+            Int64 sumFlow = 0;
+            Int64 sumFlow2 = 0;
+            Int64 sumEmf = 0;
+            Int64 sumEmf2 = 0;
+            Int64 sumMagF = 0;
+            Int64 sumMagF2 = 0;
+            Int64 sumImp = 0;
+            Int64 sumImp2 = 0;
+
+            for (int ix = startIx; ix <= endIx; ix++)
+            {
+                if (optoData[ix].Flags == Iperl.OptoTelegramFlags.OK ||
+                    optoData[ix].Flags == Iperl.OptoTelegramFlags.OK_TestStart ||
+                    optoData[ix].Flags == Iperl.OptoTelegramFlags.OK_TestEnd)
+                {
+                    n++;
+                    sumFlow += optoData[ix].FlowRaw;
+                    sumFlow2 += ((int)optoData[ix].FlowRaw * (int)optoData[ix].FlowRaw);
+                    sumEmf += (int)optoData[ix].EmfRaw;
+                    sumEmf2 += ((Int64)optoData[ix].EmfRaw * (Int64)optoData[ix].EmfRaw);
+                    sumMagF += optoData[ix].MagneticFieldRaw;
+                    sumMagF2 += ((int)optoData[ix].MagneticFieldRaw * (int)optoData[ix].MagneticFieldRaw);
+                    sumImp += optoData[ix].Impedance;
+                    sumImp2 += ((int)optoData[ix].Impedance * (int)optoData[ix].Impedance);
+                }
+            }
+
+            if (n >= 2)
+            {
+                if (x.Length > 0) x[0] = ((float)sumFlow2 - (float)sumFlow * (float)sumFlow / n) / (n - 1);
+                if (x.Length > 1) x[1] = ((float)sumEmf2  - (float)sumEmf  * (float)sumEmf  / n) / (n - 1);
+                if (x.Length > 2) x[2] = ((float)sumMagF2 - (float)sumMagF * (float)sumMagF / n) / (n - 1);
+                if (x.Length > 3) x[3] = ((float)sumImp2  - (float)sumImp  * (float)sumImp  / n) / (n - 1);
+            }
+        }
+    }
+}

Config/CalendarEvent/ICalendarEvent.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Drawing;
+
+namespace Config.CalendarEvent
+{
+    /// <summary>
+    /// An interface for creating event types
+    /// </summary>
+    public interface ICalendarEvent
+    {
+        DateTime Date { get; set; }                 /// The Date that the event occurs
+        Frequency Frequency { get; set; }           /// A value indicating how often the event occurs
+        bool AllDay { get; set; }                   /// True if the time component of DateTime value can be ignored
+        bool TriggerOnExactDayOnly { get; set; }    /// If this is a recurring event, set this to true to make the event show up only from the day specified forward
+        string Source { get; set; }                 /// Source of this calendar event (becomes the source of the triggered event)
+        string Title { get; set; }                  /// The name of the event (becomes the text of the triggered event)
+        AutoAction AutoAction { get; set; }         /// Automated action to be done or event to be triggered (triggered event Severity)
+        string Parameters { get; set; }             /// Automated action parameters (e.g. name of a procedure to start)
+        int Rank { get; set; }                      /// The ranking of the event that determines the order in which it is displayed on a particular day
+        bool Hidden { get; set; }                   /// True if the event is hidden/invisible, otherwise false
+        bool ReadOnly { get; set; }                 /// True if the event details cannot be modified
+        int BackColor { get; set; }                 /// The color that the event show up in on the calendar
+        int TextColor { get; set; }                 /// The text color of the event
+        bool TooltipEnabled { get; set; }           /// True if a tooltip should be displayed when hovering over the event
+
+        /// <summary>
+        /// Set this to a custom function that will automatically determine if the event should be rendered on a given day.
+        /// This is only executed if <see cref="Frequency"/> is set to custom.
+        /// </summary>
+        CustomRecurringFrequenciesHandler CustomRecurringFunction { get; set; }
+
+        /// <summary>
+        /// A function for cloning an event instance
+        /// </summary>
+        /// <returns>A cloned <see cref="ICalendarEvent"/></returns>
+        ICalendarEvent Clone();
+    }
+
+    /// <summary>
+    /// A delegate for creating custom recurring frequencies
+    /// </summary>
+    /// <param name="evnt">The <see cref="ICalendarEvent"/> in question</param>
+    /// <param name="day">The day in question</param>
+    /// <returns>Should return a boolean value that indicates if the event should be rendered on the day passed in</returns>
+    public delegate bool CustomRecurringFrequenciesHandler(ICalendarEvent evnt, DateTime day);
+}

Config/CalendarEvent/Utils.cs

@@ -0,0 +1,226 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+using Config.Resources;
+
+namespace Config.CalendarEvent
+{
+    /// <summary>
+    /// Enumeration of calendar event actions
+    /// </summary>
+    public enum AutoAction
+    {
+        Undefined,
+        None,               /// No action at all
+        Notification,       /// Trigger a notification event
+        Warning,            /// Trigger a warning event
+        Error,              /// Trigger an error event and stop test bench function
+        FatalErr,           /// Trigger a fatal error and stop test bench function
+        InvokeBeforeCycle,  /// Invoke a maintenance procedure before a cycle after entering order number
+        InvokeInsideCycle,  /// Invoke conditional tests inside a cycle (if any)
+        InvokeAfterCycle,   /// Invoke a maintenance procedure after a cycle after saving results
+        BackupData,
+        Count,
+    }
+
+
+    /// <summary>
+    /// Enumeration of built-in recurring event frequencies
+    /// </summary>
+    public enum Frequency
+    {
+        Undefined,
+        Once,               /// Indicates that the event is non recurring will occur only one time
+        Yearly,             /// Indicates that the event will occur once a year, on the month and day specified
+        Monthly,            /// Indicates that the event will occur every month
+        Weekly,             /// Indicates that the event will occur every week
+        EveryTuTh,          /// Indicates that the event will occur every Tuesday and Thursday
+        EveryMoWeFr,        /// Indicates that the event will occur every Mon, Wed and Fri
+        EveryWkday,         /// Indicates that the event will occur every week day (Mon - Fri)
+        Daily,              /// Indicates that the event will occur every day
+        EveryShift,
+        Custom,             /// Indicates that the recuring schedule of this event is unique
+        Count
+    }
+
+    public class Utils
+    {
+        public static string Action2String(AutoAction action)
+        {
+            return action.ToString();
+        }
+
+        public static AutoAction String2Action(string astr)
+        {
+            for (AutoAction a = AutoAction.None; a < AutoAction.Count; a++)
+            {
+                if (Action2String(a) == astr) return a;
+            }
+            return AutoAction.Undefined;
+        }
+
+        public static string Freq2String(Frequency f)
+        {
+            switch (f)
+            {
+                case Frequency.Custom:      return Strings.Custom;
+                case Frequency.Daily:       return Strings.Daily;
+                case Frequency.EveryMoWeFr: return Strings.Every_Mon_Wed_and_Fri;
+                case Frequency.EveryTuTh:   return Strings.Every_Tue_and_Thu;
+                case Frequency.EveryWkday:  return Strings.Every_Week_Day;
+                case Frequency.EveryShift:  return Strings.Every_shift;
+                case Frequency.Monthly:     return Strings.Every_Month;
+                case Frequency.Once:        return Strings.Once;
+                case Frequency.Weekly:      return Strings.Every_week;
+                case Frequency.Yearly:      return Strings.Every_year;
+                default:                    return string.Empty;
+            }
+        }
+
+        public static Frequency String2Freq(string fstr)
+        {
+            for (Frequency f = Frequency.Once; f < Frequency.Count; f++)
+            {
+                if (Freq2String(f) == fstr) return f;
+            }
+            return Frequency.Undefined;
+        }
+
+
+        /// <summary>
+        /// Determine whether an event date matches given day and time (dt)
+        /// (whether an event needs to be rendered on a specific day).
+        /// </summary>
+        /// <param name="evnt">Calendar event</param>
+        /// <param name="dt">Day and time</param>
+        /// <returns>true = needs to be rendered</returns>
+        public static bool DayMatchesExactly(ICalendarEvent evnt, DateTime dt)
+        {
+            DayOfWeek dow = dt.DayOfWeek;
+
+            switch (evnt.Frequency)
+            {
+                case Frequency.EveryShift:  return (dow == DayOfWeek.Sunday && evnt.Date.Hour >= 22) ||
+                                                   dow == DayOfWeek.Monday ||
+                                                   dow == DayOfWeek.Tuesday ||
+                                                   dow == DayOfWeek.Wednesday ||
+                                                   dow == DayOfWeek.Thursday ||
+                                                   (dow == DayOfWeek.Friday && evnt.Date.Hour < 22);
+
+                case Frequency.Daily:       return true;
+                case Frequency.EveryMoWeFr: return (dow == DayOfWeek.Monday) || (dow == DayOfWeek.Wednesday) || (dow == DayOfWeek.Friday);
+                case Frequency.EveryTuTh:   return (dow == DayOfWeek.Tuesday) || (dow == DayOfWeek.Thursday);
+                case Frequency.EveryWkday:  return (dow != DayOfWeek.Sunday) && (dow != DayOfWeek.Saturday);
+                case Frequency.Weekly:      return evnt.Date.DayOfWeek == dow;
+                case Frequency.Monthly:     return evnt.Date.Day == dt.Day;
+                case Frequency.Yearly:      return evnt.Date.Month == dt.Month && evnt.Date.Day == dt.Day;
+                case Frequency.Once:        return evnt.Date.Year == dt.Year && evnt.Date.Month == dt.Month && evnt.Date.Day == dt.Day;
+                case Frequency.Custom:      return (evnt.CustomRecurringFunction != null) && evnt.CustomRecurringFunction(evnt, dt);
+                default:                    return false;
+            }
+        }
+
+
+        public static bool IsCalendarEventTrigerred(ICalendarEvent evnt, DateTime currentDate)
+        {
+            DateTime evntDT = evnt.AllDay
+                            ? new DateTime(evnt.Date.Year, evnt.Date.Month, evnt.Date.Day, 0, 0, 0)
+                            : evnt.Date;
+
+            if (evnt.Frequency == Frequency.EveryShift)
+            {
+                DateTime dt1 = evntDT;
+                DateTime dt2 = evntDT + new TimeSpan(8, 0, 0);
+                DateTime dt3 = evntDT + new TimeSpan(16, 0, 0);
+                return (currentDate >= dt1) || (currentDate >= dt1) || (currentDate >= dt3);
+            }
+            else if (!evnt.TriggerOnExactDayOnly)
+            {
+                /// Trigger after event expires
+                return (currentDate >= evntDT);
+            }
+            else
+            {
+                /// Trigger event on exact date only
+                return (currentDate >= evntDT) && DayMatchesExactly(evnt, currentDate);
+            }
+        }
+
+
+        /// <summary>
+        /// Called to update event.Date after an event was trigerred and a required action was done.
+        /// </summary>
+        /// <param name="evnt">Calendar event</param>
+        /// <param name="currentDate">Current date and time which triggered the event</param>
+        /// <returns>true when event.Date was updated</returns>
+        public static bool UpdateRecurringDate(ICalendarEvent evnt, DateTime currentDate)
+        {
+            switch (evnt.Frequency)
+            {
+                case Frequency.Yearly:
+                    do {
+                        evnt.Date = evnt.Date.AddYears(1);
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.Monthly:
+                    do {
+                        evnt.Date = evnt.Date.AddMonths(1);
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.Weekly:
+                    do {
+                        evnt.Date += new TimeSpan(7, 0, 0, 0);  /// add one week
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.EveryTuTh:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while ((evnt.Date <= currentDate) || ((evnt.Date.DayOfWeek != DayOfWeek.Tuesday) &&
+                                                          (evnt.Date.DayOfWeek != DayOfWeek.Thursday)));
+                    return true;
+
+                case Frequency.EveryMoWeFr:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while ((evnt.Date <= currentDate) || ((currentDate.DayOfWeek != DayOfWeek.Monday) &&
+                                                          (currentDate.DayOfWeek != DayOfWeek.Wednesday) &&
+                                                          (currentDate.DayOfWeek != DayOfWeek.Friday)));
+                    return true;
+
+                case Frequency.EveryWkday:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while ((evnt.Date <= currentDate) || (currentDate.DayOfWeek == DayOfWeek.Saturday) || (currentDate.DayOfWeek == DayOfWeek.Sunday));
+                    return true;
+
+                case Frequency.Daily:
+                    do {
+                        evnt.Date += new TimeSpan(1, 0, 0, 0);  /// add one day
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                case Frequency.EveryShift:
+                    do {
+                        evnt.Date += new TimeSpan(8, 0, 0);     /// add eight hours
+                    }
+                    while (evnt.Date <= currentDate);
+                    return true;
+
+                default:
+                    /// This is not a recurring calendar event, 'Date' was not updated
+                    return false;
+            }
+        }
+    }
+}

Config/Config.csproj

@@ -10,27 +10,30 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Config</RootNamespace>
     <AssemblyName>Config</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
     <PlatformTarget>x86</PlatformTarget>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="FluentNHibernate">
@@ -64,9 +67,11 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CalendarEvent\ICalendarEvent.cs" />
     <Compile Include="Data.cs" />
     <Compile Include="DatabaseSettings.cs" />
     <Compile Include="Entities\BenchPath.cs" />
+    <Compile Include="Entities\CustomEvent.cs" />
     <Compile Include="Entities\Component.cs" />
     <Compile Include="Entities\ComponentProcedure.cs" />
     <Compile Include="Entities\ComponentTest.cs" />
@@ -83,24 +88,24 @@
     <Compile Include="Entities\MetersPath.cs" />
     <Compile Include="Entities\OutputPath.cs" />
     <Compile Include="Entities\Procedure.cs" />
-    <Compile Include="Entities\ProcedureHistory.cs" />
     <Compile Include="Entities\Profile.cs" />
     <Compile Include="Entities\PTest.cs" />
     <Compile Include="Entities\Test.cs" />
+    <Compile Include="Entities\TestInstance.cs" />
     <Compile Include="Entities\TransitionSequence.cs" />
     <Compile Include="Entities\TransitionStep.cs" />
     <Compile Include="Entities\Uncertainty.cs" />
     <Compile Include="Entities\User.cs" />
     <Compile Include="Entities\VirtualBenchSequence.cs" />
     <Compile Include="Entities\VirtualBenchStep.cs" />
-    <Compile Include="Entities\Watermeter.cs" />
-    <Compile Include="Entities\WMType.cs" />
+    <Compile Include="CalendarEvent\Utils.cs" />
     <Compile Include="FluentCommon.cs" />
     <Compile Include="Formulas.cs" />
     <Compile Include="Mappings\BenchPathMap.cs" />
     <Compile Include="Mappings\ComponentMap.cs" />
     <Compile Include="Mappings\ComponentProcedureMap.cs" />
     <Compile Include="Mappings\ComponentTestMap.cs" />
+    <Compile Include="Mappings\CustomEventMap.cs" />
     <Compile Include="Mappings\FeedingPathMap.cs" />
     <Compile Include="Mappings\GroupMap.cs" />
     <Compile Include="Mappings\HeatMetersPathMap.cs" />
@@ -115,10 +120,6 @@
     <Compile Include="Mappings\TransitionStepMap.cs" />
     <Compile Include="Mappings\UncertaintyMap.cs" />
     <Compile Include="Mappings\UserMap.cs" />
-    <Compile Include="Mappings\VirtualBenchSequenceMap.cs" />
-    <Compile Include="Mappings\VirtualBenchStepMap.cs" />
-    <Compile Include="Mappings\WatermeterMap.cs" />
-    <Compile Include="Mappings\WMTypeMap.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Resources\Strings.Designer.cs">
       <AutoGen>True</AutoGen>
@@ -141,6 +142,10 @@
     <EmbeddedResource Include="Resources\Strings.zh-CN.resx" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\Common\Common.csproj">
+      <Project>{c8939821-ba5c-4988-a3d0-bf53b74865c7}</Project>
+      <Name>Common</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Users\Users.csproj">
       <Project>{6E5CB0E9-E1B6-4E5D-AC6E-B1049E180F2B}</Project>
       <Name>Users</Name>

Config/Data.cs

@@ -8,31 +8,43 @@ namespace Config
 		public const string AdminPassword = "staratura";
 		public const string SQLiteDbFName = "SQLite.db";
 
-#if MUNICH
+#if DN100 || BADGER_STREDNA_TRAT || BADGER_VELKA_TRAT || CEVAK_200
+		public const int WMsCount = 3;
+		public const int LineSize = 3;
+		public const int CompoundWMsCount = 1;
+		public const int HeatMetersCount = 0;
+        public const int MaxPartNr = 1;
+#elif MUNICH
 		public const int WMsCount = 3;
 		public const int LineSize = 3;
 		public const int CompoundWMsCount = 3;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 3;
-#elif DN100 || BADGER_STREDNA_TRAT || BADGER_VELKA_TRAT || CEVAK_200
-		public const int WMsCount = 3;
-		public const int LineSize = 3;
-		public const int CompoundWMsCount = 1;
-		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = WMsCount / LineSize;
-#elif FUZHOU_300 || FUZHOU_150 || IZRAEL_200 || GENESIS || SLM_150 || PETERSBURG_200
+#elif MALTA_WSD25
 		public const int WMsCount = 6;
 		public const int LineSize = 6;
-		public const int CompoundWMsCount = 1;
+		public const int CompoundWMsCount = 0;
 		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = 3;
+        public const int MaxPartNr = 1;
+#elif BADGER_MALA_TRAT || BERLIN || FUZHOU_150 || FUZHOU_300 || GELSENWASSER || GENESIS || IZRAEL_200 || PETERSBURG_200 || SENTEC || SLM_150 || TORINO_50 || TURA_SPECIAL
+        public const int WMsCount = 6;
+        public const int LineSize = 6;
+        public const int CompoundWMsCount = 1;
+        public const int HeatMetersCount = 0;
+        public const int MaxPartNr = 1;
 #elif PUCHONG_200
 		public const int WMsCount = 6;
 		public const int LineSize = 6;
 		public const int CompoundWMsCount = 3;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 3;
-#elif DEWA_300 || ROMA_200
+#elif RUM_MOB
+        public const int WMsCount = 8;
+		public const int LineSize = 8;
+		public const int CompoundWMsCount = 1;
+		public const int HeatMetersCount = 0;
+        public const int MaxPartNr = WMsCount / LineSize;
+#elif DEWA_300 || FUZHOU_100 || ROMA_200 || LUXEMBURG_40
         public const int WMsCount = 10;
         public const int LineSize = 10;
         public const int CompoundWMsCount = 1;
@@ -44,63 +56,33 @@ namespace Config
 		public const int CompoundWMsCount = 0;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif IZRAEL_50
-		public const int WMsCount = 40;
-		public const int LineSize = 10;
-		public const int CompoundWMsCount = 0;
-		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = WMsCount / LineSize;
-#elif FUZHOU_100
-		public const int WMsCount = 10;
-		public const int LineSize = 10;
+#elif SLM_END || WARSAW_END
+        public const int WMsCount = 10;
+		public const int LineSize = 5;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = WMsCount / LineSize;
-#elif TORINO_50 || BADGER_MALA_TRAT || BERLIN
-		public const int WMsCount = 6;
-		public const int LineSize = 6;
+        public const int MaxPartNr = 4;
+#elif SLM_50
+		public const int WMsCount = 12;
+		public const int LineSize = 12;
 		public const int CompoundWMsCount = 1;
-		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = 1;
-#elif TORUN_50 || CEVAK_40 || MURES_40 || FUZHOU_50 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50 || JUZNA_AFRIKA_50 || IZRAEL_25 || ZAMBIA || ZODINO || FEWA_50 || FILIPINY_50 || ALZIR_25
+		public const int HeatMetersCount = 6;
+        public const int MaxPartNr = WMsCount / LineSize;
+#elif ALZIR_25 || BAHRAIN_50 || CEVAK_40 || FEWA_50 || FILIPINY_50 || FUZHOU_50 || HONGKONG_50 || IZRAEL_25 || JUZNA_AFRIKA_50 || KEMPNO_50 || KRAKOW_50 || MILWAUKEE || MURES_40 || PETERSBURG_50 || TORUN_50 || WARSAW_50 || ZAMBIA || ZODINO
         public const int WMsCount = 20;
 		public const int LineSize = 10;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif RUM_MOB
-        public const int WMsCount = 8;
-		public const int LineSize = 8;
-		public const int CompoundWMsCount = 1;
-		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = WMsCount / LineSize;
 #elif TURA_IPERL || TURA_IPERL_NEW
 		public const int WMsCount = 40;
 		public const int LineSize = 20;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif TURA_SPECIAL || SENTEC
-        public const int WMsCount = 6;
-		public const int LineSize = 6;
-		public const int CompoundWMsCount = 1;
-		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = WMsCount / LineSize;
-#elif SLM_50
-		public const int WMsCount = 12;
-		public const int LineSize = 12;
-		public const int CompoundWMsCount = 1;
-		public const int HeatMetersCount = 6;
-        public const int MaxPartNr = WMsCount / LineSize;
-#elif SLM_END || WARSAW_END
-        public const int WMsCount = 10;
-		public const int LineSize = 5;
-		public const int CompoundWMsCount = 1;
-		public const int HeatMetersCount = 0;
-        public const int MaxPartNr = 4;
-#elif MALTA_WSD25
-		public const int WMsCount = 6;
-		public const int LineSize = 6;
+#elif IZRAEL_50
+		public const int WMsCount = 40;
+		public const int LineSize = 10;
 		public const int CompoundWMsCount = 0;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;

Config/DatabaseSettings.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using System;
 using System.Text;
@@ -10,14 +10,15 @@ namespace Config
     /// <summary>
     /// Test bench database settings, contains bench name and settings od several databases
     /// </summary>
-    public class DatabaseSettings : ICloneable
+    public class DatabaseSettings : ICloneable, IComparable
     {
         // Public fields
         public string BenchName;
         public bool IsRealBench;
-        public Users.DBSettings ProceduresDBSettings;		/// Config database settings
+        public Users.DBSettings ProceduresDBSettings;	/// Configuration database settings
 		public Users.DBSettings WaterMetersDBSettings;	/// Results database settings
-		public Users.DBSettings UsersDBSettings;		    /// Users database settings
+        public Users.DBSettings EventsDBSettings;	    /// Events database settings
+        public Users.DBSettings UsersDBSettings;		/// Shared configuration database settings
 
         // Constructor
         public DatabaseSettings()
@@ -26,6 +27,7 @@ namespace Config
             IsRealBench = false;
 			ProceduresDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
 			WaterMetersDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
+            EventsDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
 			UsersDBSettings = new Users.DBSettings(Users.Entities.DBType.MySql, string.Empty);
         }
 
@@ -37,17 +39,25 @@ namespace Config
             result.IsRealBench  = IsRealBench;
 			result.ProceduresDBSettings = (Users.DBSettings)ProceduresDBSettings.Clone();
 			result.WaterMetersDBSettings = (Users.DBSettings)WaterMetersDBSettings.Clone();
+            result.EventsDBSettings = (Users.DBSettings)EventsDBSettings.Clone();
             result.UsersDBSettings = (Users.DBSettings)UsersDBSettings.Clone();
 
             return result;
         }
 
+        public int CompareTo(object dbs2)
+        {
+            if (!(dbs2 is DatabaseSettings)) return 0;
+            return String.Compare(BenchName, (dbs2 as DatabaseSettings).BenchName);
+        }
+
 		public override string ToString()
 		{
-            return string.Format("{0} config={1} results={2} users={3}",
+            return string.Format("{0} config={1} results={2} events={3} users={4}",
                                  BenchName,
                                  ProceduresDBSettings.ConnectionString,
                                  WaterMetersDBSettings.ConnectionString,
+                                 EventsDBSettings.ConnectionString,
                                  UsersDBSettings.ConnectionString);
 		}
     }

Config/Entities/BenchPath.cs

@@ -14,6 +14,7 @@ namespace Config.Entities
         public virtual string OriName { get; set; }         /// Not mapped to database
         public virtual float  Qfrom { get; set; }           /// Water flow in [m3/h]
         public virtual float  Qto { get; set; }             /// Water flow in [m3/h]
+        public virtual string Selector { get; set; }
         public virtual string TempMtrUp { get; set; }
         public virtual string TempMtrDown { get; set; }
         public virtual string PressMtrUp { get; set; }
@@ -46,7 +47,8 @@ namespace Config.Entities
 
 			result.Qfrom         = Qfrom;
             result.Qto           = Qto;
-			result.TempMtrUp     = TempMtrUp;
+            result.Selector      = Selector;
+            result.TempMtrUp     = TempMtrUp;
 			result.TempMtrDown   = TempMtrDown;
 			result.PressMtrUp    = PressMtrUp;
 			result.PressMtrDown  = PressMtrDown;

Config/Entities/CustomEvent.cs

@@ -0,0 +1,93 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+using Config.CalendarEvent;
+
+namespace Config.Entities
+{
+    public class CustomEvent : Config.CalendarEvent.ICalendarEvent
+    {
+        public virtual int Id { get; protected set; }
+        public virtual DateTime Date { get; set; }               /// The Date that the event occurs
+        public virtual Frequency Frequency { get; set; }         /// A value indicating how often the event occurs
+        public virtual bool AllDay { get; set; }                 /// True if the time component of the date can be ignored
+        public virtual bool TriggerOnExactDayOnly { get; set; }  /// If this is a recurring event, set this to true to make the event show up only from the day specified forward
+        public virtual string Source { get; set; }               /// Source of this calendar event (becomes the source of the triggered event)
+        public virtual string Title { get; set; }                /// The name of the event (becomes the text of the triggered event)
+        public virtual AutoAction AutoAction { get; set; }       /// Automated action to be done or event to be triggered
+        public virtual string Parameters { get; set; }           /// Automated action parameters (e.g. name of a procedure to start)
+        public virtual int Rank { get; set; }                    /// The ranking of the event that determines the order in which it is displayed on a particular day
+        public virtual bool Hidden { get; set; }                 /// True if the event is enabled, otherwise false
+        public virtual bool ReadOnly { get; set; }               /// True if the event details cannot be modified
+        public virtual int BackColor { get; set; }               /// The color that the event show up in on the calendar: (MSB)AARRGGBB(LSB)
+        public virtual int TextColor { get; set; }               /// The text color of the event: (MSB)AARRGGBB(LSB)
+        public virtual bool TooltipEnabled { get; set; }         /// True if a tooltip should be displayed when hovering over the event
+        public virtual CustomRecurringFrequenciesHandler
+                           CustomRecurringFunction { get; set; } /// Not mapped to DB, always null
+
+        /// <summary>
+        /// CustomEvent Constructor
+        /// </summary>
+        public CustomEvent()
+        {
+        }
+
+        public CustomEvent(DateTime dateTime, string text)
+        {
+            Date = dateTime;
+            Frequency = Config.CalendarEvent.Frequency.Once;
+            AllDay = false;
+            TriggerOnExactDayOnly = false;
+            Source = "Calendar";
+            Title = text;
+            AutoAction = AutoAction.None;
+            Parameters = string.Empty;
+            Rank = 2;
+            Hidden = false;
+            ReadOnly = false;
+            BackColor = unchecked((int)0xFFFF5050);
+            TextColor = unchecked((int)0xFFFFFFFF);
+            TooltipEnabled = true;
+            CustomRecurringFunction = null;
+        }
+
+        public virtual Config.CalendarEvent.ICalendarEvent Clone()
+        {
+            return new CustomEvent
+            {
+                Date = this.Date,
+                Frequency = this.Frequency,
+                AllDay = this.AllDay,
+                TriggerOnExactDayOnly = this.TriggerOnExactDayOnly,
+                Source = this.Source,
+                Title = this.Title,
+                AutoAction = this.AutoAction,
+                Parameters = this.Parameters,
+                Rank = this.Rank,
+                Hidden = this.Hidden,
+                ReadOnly = this.ReadOnly,
+                BackColor = this.BackColor,
+                TextColor = this.TextColor,
+                TooltipEnabled = this.TooltipEnabled,
+                CustomRecurringFunction = this.CustomRecurringFunction,
+            };
+        }
+
+        /// <summary>
+        /// Returns true when updated
+        /// </summary>
+        /// <param name="currentDate">Current date and time</param>
+        /// <returns>true when the entity was updated</returns>
+        public virtual bool UpdateRecurringDate(DateTime currentDate)
+        {
+            return Config.CalendarEvent.Utils.UpdateRecurringDate(this, currentDate);
+        }
+
+
+        public override string ToString()
+        {
+            return Title;
+        }
+    }
+}

Config/Entities/Enums.cs

@@ -67,12 +67,12 @@ namespace Config.Entities
     public class ProcedureInfo
     {
         public readonly string Name;
-        public readonly Users.Entities.DBKind DBKind;
+        public readonly bool IsRemote;
 
-        public ProcedureInfo(string name, Users.Entities.DBKind dbKind)
+        public ProcedureInfo(string name, bool isRemote)
         {
             Name = name;
-            DBKind = dbKind;
+            IsRemote = isRemote;
         }
     }
 
@@ -327,6 +327,27 @@ namespace Config.Entities
         Count
 	}
 
+    /// <summary>
+    /// Three state test results and/or water meter result (Algeria PT25 requirement).
+    /// NearlyOK means error is within error limits not narrowed by uncertainty
+    ///   OK:                   Uncertainty + ErrLimLo <= error <= ErrLimHi - Uncertainty
+    ///   NearlyOK:  not OK but stil          ErrLimLo <= error <= ErrLimHi
+    ///   Nok:       otherwise
+    /// </summary>
+    public enum ThreeState
+    {
+#if LANG_FR
+        [Description("NC")]         Nok,        /// Totally failed: not OK and not NearlyOK
+        [Description("2e/Ff")]      NearlyOK,   /// Nearly OK, not OK but not totally failed 
+        [Description("***")]        OK,         /// OK
+#else
+        [Description("NOK")]        Nok,        /// Totally failed: not OK and not NearlyOK
+        [Description("Nearly OK")]  NearlyOK,   /// Nearly OK, not OK but not totally failed 
+        [Description("OK")]         OK,         /// OK
+#endif
+        Count
+    }
+
     public enum TestProfile
     {
         UserDefined,
@@ -530,162 +551,101 @@ namespace Config.Entities
 		[Description("aus")]		Off,
 		[Description("info")]		Info,
 		[Description("ein")]		On,
+		[Description("stopp")]		Stop,
 #elif LANG_FR
         [Description("éteindre")]   Off,
         [Description("info")]       Info,
         [Description("allumé")]     On,
+        [Description("arrêter")]    Stop,
 #elif LANG_CS
 		[Description("vypnuto")]	Off,
 		[Description("info")]		Info,
 		[Description("zapnuto")]	On,
+		[Description("stop")]	    Stop,
 #elif LANG_RU
         [Description("выкл")]       Off,
         [Description("инфо")]       Info,
         [Description("вкл")]        On,
+        [Description("останов")]    Stop,
 #elif LANG_PL
 		[Description("nie")]		Off,
 		[Description("info")]		Info,
 		[Description("tak")]		On,
+		[Description("przestać")]	Stop,
 #else // LANG_EN
         [Description("off")]		Off,
 		[Description("info")]		Info,
 		[Description("on")]			On,
+        [Description("stop")]       Stop,
 #endif
         Count
 	}
 
 
-    public enum ErrorFlagShift
-    {
-        E1 = 0,
-        E2,
-        E3,
-        E4,
-        E5,
-        E6,
-        E7,
-        E8,
-        E9,
-        E10,
-        E11,
-        E12,
-        E13,
-        E14,
-        E15,
-        E16,
-        E17,
-        E18,
-        E19,
-        E20,
-        E21,
-        E22,
-        E23,
-        E24,
-        E25,
-        E26,
-        E27,
-        E28,
-        E29,
-        E30,
-        E31,
-        E32,
-        E33,
-        E34,
-        E35,
-        E36,
-        E37,
-        E38,
-        E39,
-        E40,
-        E41,
-        E42,
-        E43,
-        E44,
-        E45,
-        E46,
-        E47,
-        E48,
-        E49,
-        E50,
-        E51,
-        E52,
-        E53,
-        E54,
-        E55,
-        E56,
-        E57,
-        E58,
-        E59,
-        E60,
-        E61,
-        E62,
-        E63,
-    }
-
     public enum ErrorFlagMask : long
     {
-        E1 = (1 << (int)ErrorFlagShift.E1),
-        E2 = (1 << (int)ErrorFlagShift.E2),
-        E3 = (1 << (int)ErrorFlagShift.E3),
-        E4 = (1 << (int)ErrorFlagShift.E4),
-        E5 = (1 << (int)ErrorFlagShift.E5),
-        E6 = (1 << (int)ErrorFlagShift.E6),
-        E7 = (1 << (int)ErrorFlagShift.E7),
-        E8 = (1 << (int)ErrorFlagShift.E8),
-        E9 = (1 << (int)ErrorFlagShift.E9),
-        E10 = (1 << (int)ErrorFlagShift.E10),
-        E11 = (1 << (int)ErrorFlagShift.E11),
-        E12 = (1 << (int)ErrorFlagShift.E12),
-        E13 = (1 << (int)ErrorFlagShift.E13),
-        E14 = (1 << (int)ErrorFlagShift.E14),
-        E15 = (1 << (int)ErrorFlagShift.E15),
-        E16 = (1 << (int)ErrorFlagShift.E16),
-        E17 = (1 << (int)ErrorFlagShift.E17),
-        E18 = (1 << (int)ErrorFlagShift.E18),
-        E19 = (1 << (int)ErrorFlagShift.E19),
-        E20 = (1 << (int)ErrorFlagShift.E20),
-        E21 = (1 << (int)ErrorFlagShift.E21),
-        E22 = (1 << (int)ErrorFlagShift.E22),
-        E23 = (1 << (int)ErrorFlagShift.E23),
-        E24 = (1 << (int)ErrorFlagShift.E24),
-        E25 = (1 << (int)ErrorFlagShift.E25),
-        E26 = (1 << (int)ErrorFlagShift.E26),
-        E27 = (1 << (int)ErrorFlagShift.E27),
-        E28 = (1 << (int)ErrorFlagShift.E28),
-        E29 = (1 << (int)ErrorFlagShift.E29),
-        E30 = (1 << (int)ErrorFlagShift.E30),
-        E31 = (1 << (int)ErrorFlagShift.E31),
-        E32 = (1 << (int)ErrorFlagShift.E32),
-        E33 = (1 << (int)ErrorFlagShift.E33),
-        E34 = (1 << (int)ErrorFlagShift.E34),
-        E35 = (1 << (int)ErrorFlagShift.E35),
-        E36 = (1 << (int)ErrorFlagShift.E36),
-        E37 = (1 << (int)ErrorFlagShift.E37),
-        E38 = (1 << (int)ErrorFlagShift.E38),
-        E39 = (1 << (int)ErrorFlagShift.E39),
-        E40 = (1 << (int)ErrorFlagShift.E40),
-        E41 = (1 << (int)ErrorFlagShift.E41),
-        E42 = (1 << (int)ErrorFlagShift.E42),
-        E43 = (1 << (int)ErrorFlagShift.E43),
-        E44 = (1 << (int)ErrorFlagShift.E44),
-        E45 = (1 << (int)ErrorFlagShift.E45),
-        E46 = (1 << (int)ErrorFlagShift.E46),
-        E47 = (1 << (int)ErrorFlagShift.E47),
-        E48 = (1 << (int)ErrorFlagShift.E48),
-        E49 = (1 << (int)ErrorFlagShift.E49),
-        E50 = (1 << (int)ErrorFlagShift.E50),
-        E51 = (1 << (int)ErrorFlagShift.E51),
-        E52 = (1 << (int)ErrorFlagShift.E52),
-        E53 = (1 << (int)ErrorFlagShift.E53),
-        E54 = (1 << (int)ErrorFlagShift.E54),
-        E55 = (1 << (int)ErrorFlagShift.E55),
-        E56 = (1 << (int)ErrorFlagShift.E56),
-        E57 = (1 << (int)ErrorFlagShift.E57),
-        E58 = (1 << (int)ErrorFlagShift.E58),
-        E59 = (1 << (int)ErrorFlagShift.E59),
-        E60 = (1 << (int)ErrorFlagShift.E60),
-        E61 = (1 << (int)ErrorFlagShift.E61),
-        E62 = (1 << (int)ErrorFlagShift.E62),
-        E63 = (1 << (int)ErrorFlagShift.E63),
+        E1 = (1L << 0),    /// shift = 0, E1 = 1L
+        E2 = (1L << 1),
+        E3 = (1L << 2),
+        E4 = (1L << 3),
+        E5 = (1L << 4),
+        E6 = (1L << 5),
+        E7 = (1L << 6),
+        E8 = (1L << 7),
+        E9 = (1L << 8),
+        E10 = (1L << 9),
+        E11 = (1L << 10),
+        E12 = (1L << 11),
+        E13 = (1L << 12),
+        E14 = (1L << 13),
+        E15 = (1L << 14),
+        E16 = (1L << 15),
+        E17 = (1L << 16),
+        E18 = (1L << 17),
+        E19 = (1L << 18),
+        E20 = (1L << 19),
+        E21 = (1L << 20),
+        E22 = (1L << 21),
+        E23 = (1L << 22),
+        E24 = (1L << 23),
+        E25 = (1L << 24),
+        E26 = (1L << 25),       /// iPERL: Invalid Q2 correction factors, mismatch between factors in the water meter and in DB
+        E27 = (1L << 26),       /// iPERL: Wrong counting direction
+        E28 = (1L << 27),       /// iPERL: Missing workflow step (assembly or test)
+        E29 = (1L << 28),
+        E30 = (1L << 29),
+        E31 = (1L << 30),
+        E32 = (1L << 31),
+        E33 = (1L << 32),
+        E34 = (1L << 33),
+        E35 = (1L << 34),
+        E36 = (1L << 35),
+        E37 = (1L << 36),
+        E38 = (1L << 37),
+        E39 = (1L << 38),
+        E40 = (1L << 39),
+        E41 = (1L << 40),
+        E42 = (1L << 41),
+        E43 = (1L << 42),
+        E44 = (1L << 43),
+        E45 = (1L << 44),
+        E46 = (1L << 45),
+        E47 = (1L << 46),
+        E48 = (1L << 47),
+        E49 = (1L << 48),
+        E50 = (1L << 49),
+        E51 = (1L << 50),
+        E52 = (1L << 51),
+        E53 = (1L << 52),
+        E54 = (1L << 53),
+        E55 = (1L << 54),
+        E56 = (1L << 55),
+        E57 = (1L << 56),
+        E58 = (1L << 57),
+        E59 = (1L << 58),
+        E60 = (1L << 59),
+        E61 = (1L << 60),
+        E62 = (1L << 61),
+        E63 = (1L << 62),
     }
 }

Config/Entities/FeedingPath.cs

@@ -14,6 +14,7 @@ namespace Config.Entities
         public virtual string OriName { get; set; }         /// Not mapped to database
         public virtual float Qfrom { get; set; }            /// Water flow in [m3/h]
         public virtual float Qto { get; set; }              /// Water flow in [m3/h]
+        public virtual string Selector { get; set; }
 		public virtual string Pump { get; set; }
         public virtual string RegulValvesPct { get; set; }	/// Positions of regulation valves in % separated by ';'
 
@@ -40,12 +41,14 @@ namespace Config.Entities
         {
 			FeedingPath result = new FeedingPath(name, itemNr);
 
-			result.Qfrom = Qfrom;
-            result.Qto = Qto;
-			result.Pump = Pump;
+			result.Qfrom         = Qfrom;
+            result.Qto           = Qto;
+            result.Selector      = Selector;
+			result.Pump          = Pump;
             result.RegulValvesPct = RegulValvesPct;
-            result.ValvesOpen = ValvesOpen;
-			result.ValvesClose = ValvesClose;
+            result.ValvesOpen    = ValvesOpen;
+			result.ValvesClose   = ValvesClose;
+
 
             return result;
         }

Config/Entities/Group.cs

@@ -1,7 +1,8 @@
 ///
-/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using System;
+using System.Collections.Generic;
 
 namespace Config.Entities
 {
@@ -9,14 +10,18 @@ namespace Config.Entities
     {
         public virtual int Id { get; protected set; }
         public virtual Users.Entities.GID GID { get; set; }
+        public virtual long AccessFlags { get; set; }		/// Bitfield of access flags: bit0 .. bit62
+        public virtual IList<User> Users { get; set; }      /// Group can be a member of a list of users
 
 		public Group()
 		{
+            Users = new List<User>();
 		}
 
         public Group(Users.Entities.GID gid)
-		{
+            : this()
+        {
 			GID = gid;
 		}
-	}
+    }
 }

Config/Entities/IParamsProvider.cs

@@ -31,7 +31,7 @@ namespace Config.Entities
         /// Returns a list of possible values of one parameter (ComboBox when editing) or null (Textbox when editing).
         /// </summary>
         /// <param name="ix">Zero based index of the parameter</param>
-        IList<string> ParamValues(int ix);
+        ICollection<string> ParamValues(int ix);
 
 		/// <summary>
 		/// Returns a parameter value in the string form

Config/Entities/OutputPath.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -14,6 +14,7 @@ namespace Config.Entities
         public virtual string OriName { get; set; }         /// Not mapped to database
         public virtual float Qfrom { get; set; }			/// Water flow in [m3/h]
         public virtual float Qto { get; set; }				/// Water flow in [m3/h]
+        public virtual string Selector { get; set; }
         public virtual string RegulValve { get; set; }
 		public virtual string FlowMeter { get; set; }
 		public virtual float PidCoef { get; set; }			/// PID coefficient for the regulation path
@@ -21,7 +22,7 @@ namespace Config.Entities
         public virtual string Diverter { get; set; }
 		public virtual string TempDiv { get; set; }
 		public virtual string Scale { get; set; }
-		public virtual string EmptyTankValve { get; set; }	/// Not used anywhere
+        public virtual string RegulValvesPct { get; set; }	/// Positions of regulation valves in % separated by ';'
 
         /// Valves		
 		public virtual string ValvesOpen { get; set; }
@@ -46,18 +47,19 @@ namespace Config.Entities
         {
 			OutputPath result = new OutputPath(name, itemNr);
 
-			result.Name = Name;
-			result.Qfrom = Qfrom;
-            result.Qto = Qto;
-			result.RegulValve = RegulValve;
-			result.FlowMeter = FlowMeter;
-			result.PidCoef = PidCoef;
-            result.StartValve = StartValve;
-			result.Diverter = Diverter;
-			result.TempDiv = TempDiv;
-			result.Scale = Scale;
-			result.EmptyTankValve = EmptyTankValve;
-			result.ValvesOpen = ValvesOpen;
+			result.Name        = Name;
+			result.Qfrom       = Qfrom;
+            result.Qto         = Qto;
+            result.Selector    = Selector;
+			result.RegulValve  = RegulValve;
+			result.FlowMeter   = FlowMeter;
+			result.PidCoef     = PidCoef;
+            result.StartValve  = StartValve;
+			result.Diverter    = Diverter;
+			result.TempDiv     = TempDiv;
+			result.Scale       = Scale;
+            result.RegulValvesPct = RegulValvesPct;
+			result.ValvesOpen  = ValvesOpen;
 			result.ValvesClose = ValvesClose;
 
             return result;

Config/Entities/PTest.cs

@@ -24,6 +24,8 @@ namespace Config.Entities
         public virtual double TempLimHi { get; set; }		    /// Upper limit for the controlled temperature
         public virtual double PressLimLo { get; set; }          /// [bar] min. water pressure                                            
         public virtual double PressLimHi { get; set; }          /// [bar] max. water pressure                                            
+        public virtual sbyte Publish { get; set; }			    /// 0=no, 1=in all protocols, 2=on screen, 3=internal
+        public virtual bool Evaluate { get; set; }
 
         public virtual sbyte E1 { get; set; }                   ///
         public virtual sbyte E2 { get; set; }                   ///
@@ -76,24 +78,26 @@ namespace Config.Entities
             TempLimHi = 25.0;	    /// [°C]
             PressLimLo = 0;	        /// [bar]
             PressLimHi = 16.0;	    /// [bar]
+            Publish = (sbyte)Config.Entities.Publish.Always;
+            Evaluate = true;
 
-            E1 = 1;
-            E2 = 1;
-            E3 = 1;
-            E4 = 1;
-            E5 = 1;
-            E6 = 1;
-            E7 = 1;
-            E8 = 1;
-            E9 = 1;
-            E10 = 1;
-            E11 = 1;
-            E12 = 1;
-            E13 = 1;
-            E14 = 1;
-            E15 = 1;
-            E16 = 1;
-            E21 = 1;
+            E1 = (sbyte)ErrorFlagsMode.On;
+            E2 = (sbyte)ErrorFlagsMode.On;
+            E3 = (sbyte)ErrorFlagsMode.On;
+            E4 = (sbyte)ErrorFlagsMode.On;
+            E5 = (sbyte)ErrorFlagsMode.On;
+            E6 = (sbyte)ErrorFlagsMode.On;
+            E7 = (sbyte)ErrorFlagsMode.On;
+            E8 = (sbyte)ErrorFlagsMode.On;
+            E9 = (sbyte)ErrorFlagsMode.On;
+            E10 = (sbyte)ErrorFlagsMode.On;
+            E11 = (sbyte)ErrorFlagsMode.On;
+            E12 = (sbyte)ErrorFlagsMode.On;
+            E13 = (sbyte)ErrorFlagsMode.On;
+            E14 = (sbyte)ErrorFlagsMode.On;
+            E15 = (sbyte)ErrorFlagsMode.On;
+            E16 = (sbyte)ErrorFlagsMode.Off;
+            E21 = (sbyte)ErrorFlagsMode.Off;
 
             Delta_Q_pct = 5.0;		/// [%]
             Delta_T = 10.0;		    /// [°C]
@@ -133,6 +137,8 @@ namespace Config.Entities
 			result.TempLimHi = TempLimHi;
             result.PressLimLo = PressLimLo;
             result.PressLimHi = PressLimHi;
+            result.Publish = Publish;
+            result.Evaluate = Evaluate;
 
             result.E1 = E1;
             result.E2 = E2;
@@ -184,6 +190,8 @@ namespace Config.Entities
 			output.WriteLine(TempLimHi.ToString(ci));
             output.WriteLine(PressLimLo.ToString(ci));
             output.WriteLine(PressLimHi.ToString(ci));
+            output.WriteLine(Publish.ToString());
+            output.WriteLine(Evaluate.ToString());
 
             output.WriteLine(E1.ToString());
             output.WriteLine(E2.ToString());
@@ -238,6 +246,8 @@ namespace Config.Entities
 			tst.ErrLimHi = double.Parse(input.ReadLine(), ci);
 			tst.TempLimLo = double.Parse(input.ReadLine(), ci);
 			tst.TempLimHi = double.Parse(input.ReadLine(), ci);
+            tst.Publish = sbyte.Parse(input.ReadLine());
+            tst.Evaluate = bool.Parse(input.ReadLine());
 
             /// TODO (E1 .. E21)
 
@@ -278,8 +288,10 @@ namespace Config.Entities
             ln = inp.ReadLine(); if (ln != ErrLimHi.ToString(ci))     { diff.AppendFormat(fmt, "ErrLimHi", ErrLimHi.ToString(ci), ln); };
             ln = inp.ReadLine(); if (ln != TempLimLo.ToString(ci))    { diff.AppendFormat(fmt, "TempLimLo", TempLimLo.ToString(ci), ln); };
             ln = inp.ReadLine(); if (ln != TempLimHi.ToString(ci))    { diff.AppendFormat(fmt, "TempLimHi", TempLimHi.ToString(ci), ln); };
-            ln = inp.ReadLine(); if (ln != PressLimLo.ToString(ci)) { diff.AppendFormat(fmt, "Pressure_min", TempLimLo.ToString(ci), ln); };
-            ln = inp.ReadLine(); if (ln != PressLimHi.ToString(ci)) { diff.AppendFormat(fmt, "Pressure_max", TempLimHi.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != PressLimLo.ToString(ci))   { diff.AppendFormat(fmt, "Pressure_min", PressLimLo.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != PressLimHi.ToString(ci))   { diff.AppendFormat(fmt, "Pressure_max", PressLimHi.ToString(ci), ln); };
+            ln = inp.ReadLine(); if (ln != Publish.ToString())        { diff.AppendFormat(fmt, "Publish", Publish.ToString(), ln); };
+            ln = inp.ReadLine(); if (ln != Evaluate.ToString())       { diff.AppendFormat(fmt, "Evaluate", Evaluate.ToString(), ln); };
 
             ln = inp.ReadLine(); if (ln != E1.ToString()) { diff.AppendFormat(fmt, "E1", E1.ToString(), ln); };
             ln = inp.ReadLine(); if (ln != E2.ToString()) { diff.AppendFormat(fmt, "E2", E2.ToString(), ln); };

Config/Entities/Procedure.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -11,7 +11,7 @@ namespace Config.Entities
     /// <summary>
     /// Stores one test procedure, supports revisions and history log
     /// </summary>
-	public class Procedure : IHasName, IHasItemNr
+    public class Procedure : IHasName, IHasItemNr
     {
         public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
@@ -36,23 +36,40 @@ namespace Config.Entities
 		public virtual bool ManualCtrlDisabled { get; set; }	/// true = manual control of valves, etc. is disabled
 
 		public virtual string DataEntry { get; set; }			/// Component to use for data entry
-		public virtual string ResultsPrinter { get; set; }		/// Component to use for printing the results
-		public virtual string ResultsWriter { get; set; }		/// Component to use for saving the results into the file
-		public virtual string TransitionStart { get; set; }
+		public virtual string ResultsPrinter { get; set; }		/// Component for printing results
+		public virtual string ResultsWriter { get; set; }		/// Component for saving results into a file
+        public virtual string EventTriggers { get; set; }       /// Component for analysing results and triggering events
+        public virtual string TransitionStart { get; set; }
 		public virtual string TransitionEnd { get; set; }
 
         public virtual string AltProcName { get; set; }		    /// Alternative procedure name (null or string.Empty = no alt. procedure)
         public virtual int AltProcPeriod { get; set; }			/// Period of alternative procedures (0 = no alt. procedure)
 
+        public virtual float DN { get; set; }                   /// Not mapped to DB, valid in ProceduresCtrl for procedure filtering only
+        public virtual float Qn { get; set; }                   ///   - ' ' -
+        public virtual string MClass { get; set; }              ///   - ' ' -
+        public virtual string Producer { get; set; }            ///   - ' ' -
+
 		public virtual IList<ComponentProcedure> MoreParams { get; set; }
 		public virtual IList<Test> Tests { get; set; }
 
+        TestInstance[] testInstances;
+
+        /// Wrapper
+        public virtual IList<Test> RegularTests()
+        {
+            IList<Test> rslt = new List<Test>();
+            foreach (var t in Tests) if (t.IsRegular()) rslt.Add(t);
+            return rslt;
+        }
+
         /// ------------- Additional stuff not mapped into the database -------------
 
         public Procedure()
         {
 			MoreParams = new List<ComponentProcedure>();
 			Tests = new List<Test>();
+            testInstances = null;
 
 			///
 			/// Default values
@@ -65,6 +82,11 @@ namespace Config.Entities
 			Watermeters = string.Empty;
 			Description = string.Empty;
 			LongDescription = string.Empty;
+
+            DN = 0;
+            Qn = 0;
+            MClass = string.Empty;
+            Producer = string.Empty;
         }
 
 		public Procedure(string name, int itemNr)
@@ -74,6 +96,70 @@ namespace Config.Entities
 			ItemNr = itemNr;
 		}
 
+        public virtual TestInstance[] UpdateTestInstances(IList<string> loopStartNames, IList<string> loopEndNames, IList<string> autoTests = null)
+        {
+            List<TestInstance> instances = new List<TestInstance>();
+
+            if (Tests != null)
+            {
+                int i = 0;
+                while (i < Tests.Count)
+                {
+                    if (!loopStartNames.Contains(Tests[i].Method) && !loopEndNames.Contains(Tests[i].Method))   /// Loop.End is ignored outside a loop
+                    {
+                        ///
+                        /// Outside a loop
+                        ///
+                        for (int j = 1; j <= Tests[i].Repeats; j++)
+                            if (Tests[i].BelongsTo(autoTests))
+                                instances.Add(new TestInstance(Tests[i], j));
+                    }
+                    else if (loopStartNames.Contains(Tests[i].Method))
+                    {
+                        ///
+                        /// Entering a loop
+                        ///
+                        int loopsCount = Tests[i].Repeats;
+                        List<Test> testsInsideLoop = new List<Test>();
+                        i++;
+
+                        while (i < Tests.Count && !loopEndNames.Contains(Tests[i].Method))
+                        {
+                            ///
+                            /// Inside a loop
+                            ///
+                            if (Tests[i].Repeats == loopsCount && !loopStartNames.Contains(Tests[i].Method))    /// Loop.Start is ignored inside a loop
+                            {
+                                if (Tests[i].BelongsTo(autoTests))
+                                    testsInsideLoop.Add(Tests[i]);
+                            }
+
+                            i++;
+                        }
+
+                        ///
+                        /// Append instances of tests inside the last loop to the list
+                        ///
+                        for (int j = 1; j <= loopsCount; j++)
+                        {
+                            foreach (var t in testsInsideLoop)
+                                instances.Add(new TestInstance(t, j));
+                        }
+                    }
+
+                    i++;
+                }
+            }
+
+            testInstances = instances.ToArray();
+            return testInstances;
+        }
+
+        public virtual TestInstance[] GetTestInstances()
+        {
+            return testInstances;
+        }
+
         public virtual Procedure Clone()
         {
             Procedure result = new Procedure();
@@ -98,11 +184,17 @@ namespace Config.Entities
 			result.DataEntry = DataEntry;
 			result.ResultsPrinter = ResultsPrinter;
 			result.ResultsWriter = ResultsWriter;
-			result.TransitionStart = TransitionStart;
+            result.EventTriggers = EventTriggers;
+            result.TransitionStart = TransitionStart;
 			result.TransitionEnd = TransitionEnd;
             result.AltProcName = AltProcName;
             result.AltProcPeriod = AltProcPeriod;
 
+            result.DN = DN;
+            result.Qn = Qn;
+            result.MClass = MClass;
+            result.Producer = Producer;
+
 			foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone(result)); }
 			foreach (var test in Tests) { result.Tests.Add(test.Clone()); }
 
@@ -126,6 +218,7 @@ namespace Config.Entities
             output.WriteLine(DataEntry);
             output.WriteLine(ResultsPrinter);
             output.WriteLine(ResultsWriter);
+            output.WriteLine(EventTriggers);
             output.WriteLine(TransitionStart); 
             output.WriteLine(TransitionEnd);
 
@@ -158,6 +251,7 @@ namespace Config.Entities
             result.DataEntry = input.ReadLine();
             result.ResultsPrinter = input.ReadLine();
             result.ResultsWriter = input.ReadLine();
+            result.EventTriggers = input.ReadLine();
             result.TransitionStart = input.ReadLine();
             result.TransitionEnd = input.ReadLine();
 
@@ -204,6 +298,7 @@ namespace Config.Entities
             ln = inp.ReadLine(); if (ln != DataEntry)                     { diff.AppendFormat(fmt, "DataEntry", DataEntry, ln); };
             ln = inp.ReadLine(); if (ln != ResultsPrinter)                { diff.AppendFormat(fmt, "ResultsPrinter", ResultsPrinter, ln); };
             ln = inp.ReadLine(); if (ln != ResultsWriter)                 { diff.AppendFormat(fmt, "ResultsWriter", ResultsWriter, ln); };
+            ln = inp.ReadLine(); if (ln != EventTriggers)                 { diff.AppendFormat(fmt, "EventTriggers", EventTriggers, ln); };
             ln = inp.ReadLine(); if (ln != TransitionStart)               { diff.AppendFormat(fmt, "TransitionStart", TransitionStart, ln); };
             ln = inp.ReadLine(); if (ln != TransitionEnd)                 { diff.AppendFormat(fmt, "TransitionEnd", TransitionEnd, ln); };
 

Config/Entities/ProcedureHistory.cs

@@ -1,31 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-
-namespace Config.Entities
-{
-    public class ProcedureHistory
-    {
-        public virtual int Id { get; protected set; }
-        public virtual Procedure Current { get; set; }
-        public virtual IList<Procedure> OldProcedures { get; set; }
-
-        /// ------------- Additional stuff not mapped into the database -------------
-
-        public ProcedureHistory()
-        {
-            Current = new Procedure();
-            OldProcedures = new List<Procedure>();
-        }
-
-        public virtual ProcedureHistory Clone()
-        {
-            ProcedureHistory result = new ProcedureHistory();
-            result.Current = Current.Clone();
-            foreach (Procedure p in OldProcedures) result.OldProcedures.Add(p.Clone());
-            return result;
-        }
-    }
-}

Config/Entities/Test.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -108,6 +108,22 @@ namespace Config.Entities
 			Procedure = procedure;
 		}
 
+        public virtual bool IsRegular()
+        {
+            /// Irregular / event triggered test names have form "[event] TestName"
+            return (Name.Length > 0 && Name[0] != '[') || !Name.Contains("]");
+        }
+
+        public virtual bool BelongsTo(IList<string> autoTests)
+        {
+            if (IsRegular()) return true;
+
+            if (autoTests == null) return false;
+
+            string action = Name.Substring(1, Name.IndexOf(']') - 1);
+            return autoTests.Contains(action);
+        }
+
         // Makes a new copy of this object (not just a reference)
         public virtual Test Clone()
         {

Config/Entities/TestInstance.cs

@@ -0,0 +1,32 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Config.Entities
+{
+    public class TestInstance
+    {
+        public Test Test;
+        public int Repetition;
+
+        public string Name
+        {
+            get
+            {
+                return (Test != null) ? Common.Utils.GetTestName(Test.Name, Test.Repeats, Repetition) : string.Empty;
+            }
+        }
+
+        public TestInstance(Test test, int repetition)
+        {
+            Test = test;
+            Repetition = repetition;
+        }
+
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+}

Config/Entities/WMType.cs

@@ -1,78 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-/// This class holds the watermeter type specific data 
-/// that have all watermaters of the same type in common
-
-namespace Config.Entities
-{
-    public class WMType
-    {
-        // mapped
-        public virtual int Id { get; protected set; }           /// primary key
-        public virtual DateTime CreateTime { get; set; }        /// Date and time of the creation or change
-        public virtual string CreateUserName { get; set; }      /// Name of the user who has created or changed this procedure
-        public virtual string CreateDescription { get; set; }   /// Description\
-         
-        public virtual string Name { get; set; }                /// type name
-        public virtual float PulseRate { get; set; }            /// Pulses per Liter
-
-        // not yet mapped
-        public virtual int IdentNr { get; protected set; }      /// identification number of watermeter tzpe
-        public virtual int Diameter { get; set; }               /// nominal diameter
-        public virtual int Pressure { get; set; }               /// nominal pressure
-        public virtual int Length { get; set; }                 /// construction length
-        public virtual int Temperatur { get; set; }             /// nominal temperature in C
-        public virtual float NominalFlow { get; set; }          /// nominal flow Qn
-       
-        /// ------------- Additional stuff not mapped into the database -------------
-
-        public WMType()
-        {
-        }
-
-        public static WMType DefaultWMType()
-        {
-            WMType procedure = new WMType()
-            {
-                CreateTime = DateTime.Now,
-				CreateUserName = Users.GlobalData.CurrentUser.UserName,
-                CreateDescription = "A default water meter created.",
-                Name = "Watermeter",
-                PulseRate = 1000,
-            };
-            return procedure;
-        }
-
-        public virtual WMType Clone()
-        {
-            WMType result = new WMType();
-
-            result.CreateTime = CreateTime;
-            result.CreateUserName = CreateUserName;
-            result.CreateDescription = CreateDescription;
-            result.Name = Name;
-            result.PulseRate = PulseRate;
-
-            return result;
-        }
-
-        public override string ToString()
-        {
-            string result = "";
-            result += "WMTpe: " + Environment.NewLine;
-            result += "    Name        = " + Name + Environment.NewLine;
-            result += "    Created by  = " + CreateUserName + Environment.NewLine;
-            result += "    Created on  = " + CreateTime.ToString() + Environment.NewLine;
-            result += "    Description = " + CreateDescription + Environment.NewLine;
-            result += "    Pulse rate  = " + PulseRate.ToString() + Environment.NewLine;
-            return result;
-        }
-    }
-}
-

Config/Entities/Watermeter.cs

@@ -1,40 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-using NHibernate;
-using FluentNHibernate;
-
-namespace Config.Entities
-{
-    public class Watermeter
-    {
-        public virtual int Id { get; protected set; }           /// primary key
-
-        public virtual DateTime CreateTime { get; set; }        /// Date and time of the creation or change
-        public virtual string CreateUserName { get; set; }      /// Name of the user who has created or changed this procedure
-        public virtual string CreateDescription { get; set; }   /// Description
-
-        /// mapped
-        public virtual string Serial { get; set; }              /// serial number 
-        public virtual WMType WMType { get; set; }              /// type of watermeter                                              
-                                                                /// 
-
-		/// <summary>
-		/// Load a watermeter from the database
-		/// </summary>
-		public static Watermeter LoadBySerialnr(string SerialNr)
-        {
-            IList<Watermeter> ListOfWatermeters = FluentCommon.CreateSession(Users.Entities.DBKind.Results)
-				.CreateQuery("FROM Watermeter WHERE Serial = :SerialNrParameter")
-				.SetParameter("SerialNrParameter", SerialNr)
-				.List<Watermeter>();
-            if (ListOfWatermeters.Count > 0) return ListOfWatermeters.ElementAt(0);
-            return null;
-        }
-    }
-}

Config/FluentCommon.cs

@@ -119,10 +119,10 @@ namespace Config
 		/// Create a NHibernate session for the given database
 		public static ISession CreateSession(Users.Entities.DBKind database)
 		{
-			int ix = (int)database;
-			if (ix < 0 || ix >= (int)Users.Entities.DBKind.Count) return null;
+            if (database < 0 || database >= Users.Entities.DBKind.Count) return null;
 
-			if (SessionFactories[ix] == null) SessionFactories[ix] = CreateSessionFactory(database);
+            int ix = (int)database;
+            if (SessionFactories[ix] == null) SessionFactories[ix] = CreateSessionFactory(database);
 
 			return SessionFactories[ix].OpenSession();
 		}
@@ -145,17 +145,8 @@ namespace Config
                 using (var transaction = session.BeginTransaction())
                 {
                     ///
-                    /// Prepare all groups
+					/// Create user 'admin'
                     ///
-					var testers					= new Config.Entities.Group(Users.Entities.GID.Testers);
-					var testingSpecialists		= new Config.Entities.Group(Users.Entities.GID.TestingSpecialists);
-					var headOfLab				= new Config.Entities.Group(Users.Entities.GID.HeadOfLab);
-					var maintenanceSpecialists	= new Config.Entities.Group(Users.Entities.GID.MaintenanceSpecialists);
-					var metrologists			= new Config.Entities.Group(Users.Entities.GID.Metrologists);
-					var calibrationSpecialists	= new Config.Entities.Group(Users.Entities.GID.CalibrationSpecialists);
-					var administrators			= new Config.Entities.Group(Users.Entities.GID.Administrators);
-
-					/// Create the user 'admin' add his groups
                     var admin = new Config.Entities.User
                     {
 						UserName = Data.AdminUsername,
@@ -163,20 +154,35 @@ namespace Config
                         LastPwChange = DateTime.Now
                     };
 					admin.SetPassword(Data.AdminPassword);
-                    admin.AddGroup(testers);
-                    admin.AddGroup(testingSpecialists);
-                    admin.AddGroup(headOfLab);
-                    admin.AddGroup(maintenanceSpecialists);
-                    admin.AddGroup(metrologists);
-                    admin.AddGroup(calibrationSpecialists);
-                    admin.AddGroup(administrators);
 
-                    session.SaveOrUpdate(admin);
-
-					///// Create the control board component
-					//var cmpnt = (new BenchControl.Elde.ControlBoardCfg(new BenchControl.Elde.ControlBoardFactory())).CreateDbEntity();
-					//session.SaveOrUpdate(cmpnt);
+                    ///
+                    /// Prepare all groups, add some of them to admin
+                    ///
+                    for (Users.Entities.GID gid = 0; gid < Users.Entities.GID.NrOfGroups; gid++)
+                    {
+                        Config.Entities.Group group = new Config.Entities.Group(gid);
+                        switch (gid)
+                        {
+                            case Users.Entities.GID.Testers:
+                            case Users.Entities.GID.TestingSpecialists:
+                            case Users.Entities.GID.HeadOfLab:
+                            case Users.Entities.GID.MaintenanceSpecialists:
+                            case Users.Entities.GID.Metrologists:
+                            case Users.Entities.GID.CalibrationSpecialists:
+                            case Users.Entities.GID.Administrators:
+#if TURA_IPERL || TURA_IPERL_NEW || TURA_SPECIAL
+                            case Users.Entities.GID.TraceabilityManagement:
+#elif KEMPNO_50 || KRAKOW_50 || TORUN_50 || WARSAW_END
+                            case Users.Entities.GID.MetrologicalAuthority:
+                            case Users.Entities.GID.WaterMeterAuthority:
+#endif
+                                admin.AddGroup(group);
+                                session.SaveOrUpdate(group);    /// Save this group
+                                break;
+                        }
+                    }
 
+                    session.SaveOrUpdate(admin);                /// Save user 'admin'
                     transaction.Commit();
                 }
             }

Config/Mappings/CustomEventMap.cs

@@ -0,0 +1,30 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using FluentNHibernate.Mapping;
+using Config.Entities;
+
+namespace Config.Mappings
+{
+    class CustomEventMap : ClassMap<CustomEvent>
+    {
+        public CustomEventMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.Date);
+            Map(x => x.Frequency);
+            Map(x => x.AllDay);
+            Map(x => x.TriggerOnExactDayOnly);
+            Map(x => x.Source);
+            Map(x => x.Title);
+            Map(x => x.AutoAction);
+            Map(x => x.Parameters);
+            Map(x => x.Rank);
+            Map(x => x.Hidden);
+            Map(x => x.ReadOnly);
+            Map(x => x.BackColor);
+            Map(x => x.TextColor);
+            Map(x => x.TooltipEnabled);
+        }
+    }
+}

Config/Mappings/GroupMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 
@@ -7,10 +7,18 @@ namespace Config.Mappings
 {
     class GroupMap : ClassMap<Entities.Group>
     {
+        /// <seealso>
+        ///  https://stackoverflow.com/questions/9108083/fluent-nhibernate-many-to-many-mapping-way/9125059
+        /// </seealso>
         public GroupMap()
         {
             Id(x => x.Id);
-            Map(x => x.GID).Column("Name"); ;
+            Map(x => x.GID).Column("Name");
+            Map(x => x.AccessFlags);
+            HasManyToMany(x => x.Users)
+                .Cascade.SaveUpdate()
+                .Inverse()
+                .Table("UsersGroups");
         }
     }
 }

Config/Mappings/OutputPathMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -23,7 +23,8 @@ namespace Config.Mappings
 			Map(x => x.TempDiv);
 			Map(x => x.Scale)
 				.Column("Balance");
-			Map(x => x.EmptyTankValve);
+            Map(x => x.RegulValvesPct)
+                .Column("EmptyTankValve");
 			Map(x => x.ValvesOpen)
 				.CustomType("StringClob")
 				.CustomSqlType("varchar(8000)");

Config/Mappings/PTestMap.cs

@@ -22,6 +22,8 @@ namespace Config.Mappings
 			Map(x => x.TempLimHi);
             Map(x => x.PressLimLo);
             Map(x => x.PressLimHi);
+            Map(x => x.Publish);
+            Map(x => x.Evaluate);
             Map(x => x.E1);
             Map(x => x.E2);
             Map(x => x.E3);

Config/Mappings/ProcedureMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -35,6 +35,7 @@ namespace Config.Mappings
             Map(x => x.DataEntry);
 			Map(x => x.ResultsPrinter);
 			Map(x => x.ResultsWriter);
+            Map(x => x.EventTriggers);
 			Map(x => x.TransitionStart);
 			Map(x => x.TransitionEnd);
 

Config/Mappings/TestMap.cs

@@ -18,9 +18,7 @@ namespace Config.Mappings
             Map(x => x.Publish);
 			Map(x => x.DoEvaluate)
 				.Column("Evaluate");
-#if TEST_PROFILES
             Map(x => x.Qtg);
-#endif
             Map(x => x.Qfrom);
 			Map(x => x.Qto);
 			Map(x => x.Volume);

Config/Mappings/UserMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2016-2019 Sensus Slovensko a.s.
+/// Copyright (c) 2016-2020 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 
@@ -19,8 +19,9 @@ namespace Config.Mappings
             Map(x => x.Password4);
             Map(x => x.FullName).Column("Description");
             Map(x => x.LastPwChange);
-            HasMany(x => x.Groups)
-                .Cascade.All();
+            HasManyToMany(x => x.Groups)
+                .Cascade.SaveUpdate()
+                .Table("UsersGroups");
         }
     }
 }

Config/Mappings/VirtualBenchSequenceMap.cs

@@ -1,22 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-using Config.Entities;
-
-namespace Config.Mappings
-{
-	class VirtualBenchSequenceMap : ClassMap<VirtualBenchSequence>
-	{
-		public VirtualBenchSequenceMap()
-        {   
-            Id(x => x.Id);
-			Map(x => x.ItemNr);
-			Map(x => x.Name);
-			Map(x => x.Description);
-			HasMany(x => x.VirtualBenchSteps)
-				.OrderBy("ItemNr")
-				.Cascade.All();
-        }
-	}
-}

Config/Mappings/VirtualBenchStepMap.cs

@@ -1,20 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-using Config.Entities;
-
-namespace Config.Mappings
-{
-	class VirtualBenchStepMap : ClassMap<VirtualBenchStep>
-	{
-		public VirtualBenchStepMap()
-        {
-            Id(x => x.Id);
-            Map(x => x.ItemNr);
-            Map(x => x.Duration);
-
-			References(x => x.VirtualBenchSequence);
-		}
-	}
-}

Config/Mappings/WMTypeMap.cs

@@ -1,20 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-
-namespace Config.Mappings
-{
-	class WMTypeMap : ClassMap<Entities.WMType>
-    {
-        public WMTypeMap()
-        {
-            Id(x => x.Id);
-            Map(x => x.CreateTime);
-            Map(x => x.CreateUserName);
-            Map(x => x.CreateDescription);
-            Map(x => x.Name);
-            Map(x => x.PulseRate);
-        }
-    }
-}

Config/Mappings/WatermeterMap.cs

@@ -1,19 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using FluentNHibernate.Mapping;
-
-namespace Config.Mappings
-{
-	class WatermeterMap : ClassMap<Entities.Watermeter>
-    {
-        public WatermeterMap()
-        {
-            Id(x => x.Id);
-            Map(x => x.Serial);
-            // HasOne(x => x.WMType)
-            //    .Cascade.All();
-            References(x => x.WMType);
-        }
-    }
-}

Config/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.24.1382.0")]
-[assembly: AssemblyFileVersion("2.24.1382.0")]
+[assembly: AssemblyVersion("2.26.1519.0")]
+[assembly: AssemblyFileVersion("2.26.1519.0")]

Config/Resources/Strings.Designer.cs

@@ -60,24 +60,6 @@ namespace Config.Resources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Administrator.
-        /// </summary>
-        internal static string Administrator {
-            get {
-                return ResourceManager.GetString("Administrator", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Calibration Specialist.
-        /// </summary>
-        internal static string Calibration_Specialist {
-            get {
-                return ResourceManager.GetString("Calibration_Specialist", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Cannot open DB Cause 0.
         /// </summary>
@@ -92,8 +74,7 @@ namespace Config.Resources {
 		/// </summary>
 		internal static string Error
 		{
-			get
-			{
+			get {
 				return ResourceManager.GetString("Error", resourceCulture);
 			}
 		}
@@ -107,33 +88,6 @@ namespace Config.Resources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Head of Lab.
-        /// </summary>
-        internal static string Head_of_Lab {
-            get {
-                return ResourceManager.GetString("Head_of_Lab", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Maintenance Specialist.
-        /// </summary>
-        internal static string Maintenance_Specialist {
-            get {
-                return ResourceManager.GetString("Maintenance_Specialist", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Metrologist.
-        /// </summary>
-        internal static string Metrologist {
-            get {
-                return ResourceManager.GetString("Metrologist", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Passed.
         /// </summary>
@@ -142,22 +96,114 @@ namespace Config.Resources {
                 return ResourceManager.GetString("Passed", resourceCulture);
             }
         }
-        
+
         /// <summary>
-        ///   Looks up a localized string similar to Tester.
+        ///   Looks up a localized string similar to Once.
         /// </summary>
-        internal static string Tester {
+        internal static string Once
+        {
             get {
-                return ResourceManager.GetString("Tester", resourceCulture);
+                return ResourceManager.GetString("Once", resourceCulture);
             }
         }
-        
+
         /// <summary>
-        ///   Looks up a localized string similar to Testing Specialist.
+        ///   Looks up a localized string similar to Every year.
         /// </summary>
-        internal static string Testing_Specialist {
+        internal static string Every_year
+        {
             get {
-                return ResourceManager.GetString("Testing_Specialist", resourceCulture);
+                return ResourceManager.GetString("Every_year", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Month.
+        /// </summary>
+        internal static string Every_Month
+        {
+            get {
+                return ResourceManager.GetString("Every_Month", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every week.
+        /// </summary>
+        internal static string Every_week
+        {
+            get {
+                return ResourceManager.GetString("Every_week", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Daily.
+        /// </summary>
+        internal static string Daily
+        {
+            get {
+                return ResourceManager.GetString("Daily", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every shift.
+        /// </summary>
+        internal static string Every_shift
+        {
+            get {
+                return ResourceManager.GetString("Every_shift", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Monday, Wednesday and Friday.
+        /// </summary>
+        internal static string Every_Mon_Wed_and_Fri
+        {
+            get {
+                return ResourceManager.GetString("Every_Mon_Wed_and_Fri", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Tuesday and Thursday.
+        /// </summary>
+        internal static string Every_Tue_and_Thu
+        {
+            get {
+                return ResourceManager.GetString("Every_Tue_and_Thu", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Every Week Day (Mon - Fri).
+        /// </summary>
+        internal static string Every_Week_Day
+        {
+            get {
+                return ResourceManager.GetString("Every_Week_Day", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Custom.
+        /// </summary>
+        internal static string Custom
+        {
+            get {
+                return ResourceManager.GetString("Custom", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Administrator.
+        /// </summary>
+        internal static string Administrator
+        {
+            get {
+                return ResourceManager.GetString("Administrator", resourceCulture);
             }
         }
     }

Config/Resources/Strings.cs.resx

@@ -117,7 +117,40 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="Custom" xml:space="preserve">
+    <value>Volitelně</value>
+  </data>
+  <data name="Daily" xml:space="preserve">
+    <value>Každý den</value>
+  </data>
   <data name="Error" xml:space="preserve">
     <value>Chyba</value>
   </data>
+  <data name="Every_Month" xml:space="preserve">
+    <value>Každý měsíc</value>
+  </data>
+  <data name="Every_Mon_Wed_and_Fri" xml:space="preserve">
+    <value>Každý pondělí, středu a pátek</value>
+  </data>
+  <data name="Every_shift" xml:space="preserve">
+    <value>Každou směnu</value>
+  </data>
+  <data name="Every_Tue_and_Thu" xml:space="preserve">
+    <value>Každý úterí a čtvrtek</value>
+  </data>
+  <data name="Every_week" xml:space="preserve">
+    <value>Každý týden</value>
+  </data>
+  <data name="Every_Week_Day" xml:space="preserve">
+    <value>Každý pracovní den (pon. - pá.)</value>
+  </data>
+  <data name="Every_year" xml:space="preserve">
+    <value>Každý rok</value>
+  </data>
+  <data name="Once" xml:space="preserve">
+    <value>Jednou</value>
+  </data>
+  <data name="Administrator" xml:space="preserve">
+    <value>Správce</value>
+  </data>
 </root>

Config/Resources/Strings.de.resx

@@ -118,15 +118,15 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <data name="Failed" xml:space="preserve">
-    <value>NiO</value>
+    <value>Nicht OK</value>
   </data>
   <data name="Passed" xml:space="preserve">
-    <value>iO</value>
+    <value>OK</value>
   </data>
   <data name="Error" xml:space="preserve">
     <value>Fehler</value>
   </data>
   <data name="Cannot_open_DB_Cause_0" xml:space="preserve">
-    <value>Datenbank kann nicht geöffnet.\\r\\nUrsache:\\r\\n{0}</value>
+    <value>Datenbank kann nicht geöffnet werden.\\r\\nUrsache:\\r\\n{0}</value>
   </data>
 </root>

Config/Resources/Strings.resx

@@ -129,4 +129,37 @@
   <data name="Error" xml:space="preserve">
     <value>Error</value>
   </data>
+  <data name="Custom" xml:space="preserve">
+    <value>Custom</value>
+  </data>
+  <data name="Daily" xml:space="preserve">
+    <value>Daily</value>
+  </data>
+  <data name="Every_Month" xml:space="preserve">
+    <value>Every Month</value>
+  </data>
+  <data name="Every_Mon_Wed_and_Fri" xml:space="preserve">
+    <value>Every Monday, Wednesday and Friday</value>
+  </data>
+  <data name="Every_shift" xml:space="preserve">
+    <value>Every shift</value>
+  </data>
+  <data name="Every_Tue_and_Thu" xml:space="preserve">
+    <value>Every Tuesday and Thursday</value>
+  </data>
+  <data name="Every_week" xml:space="preserve">
+    <value>Every week</value>
+  </data>
+  <data name="Every_Week_Day" xml:space="preserve">
+    <value>Every Week Day (Mon - Fri)</value>
+  </data>
+  <data name="Every_year" xml:space="preserve">
+    <value>Every year</value>
+  </data>
+  <data name="Once" xml:space="preserve">
+    <value>Once</value>
+  </data>
+  <data name="Administrator" xml:space="preserve">
+    <value>Administrator</value>
+  </data>
 </root>

Config/Units.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2016-2018 Sensus Slovensko a.s.
+/// Copyright (c) 2016-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Reflection;
@@ -17,24 +17,34 @@ namespace Config
 #else
         [Description("degree")]     degree,
 #endif
+        [Description("ml")]         ml,         ///   1 ml = 0.001 l
         [Description("l")]          l,          /// * 1 liter
-        [Description("dm3")]        dm3,        ///   1 dm3 = 1 liter
-        [Description("m3")]         m3,         ///   1000 l
-        [Description("gal(UK)")]    gal_UK,     ///   1 gal(UK) = 4.54609 l
-        [Description("gal(US)")]    gal_US,     ///   1 gal(US) = 3.78541178 l
+        [Description("dm3")]        dm3,        ///   1 dm3 = 1 l
+        [Description("US gal")]     USgal,      ///   1 US gallon = 3.78541178 l
+        [Description("imper.gal")]  UKgal,      ///   1 imperial gallon = 4.54609 l
+        [Description("cf")]         cf,         ///   1 cubic foot = 28.316846592 l
+        [Description("m3")]         m3,         ///   1 m3 = 1000 l
 
-        [Description("l/h")]        lph,        ///   1 liter/h
-        [Description("m3/h")]       m3ph,       /// * 1 m3/h = 1000 l/h
+        [Description("l/h")]        lph,        ///   1 l/h = 0.001 m3/h
+        [Description("cf/h")]       cfph,       ///   1 cf/h = 0.028316846592 m3/h
+        [Description("l/m")]        lpm,        ///   1 l/m = 60 l/h = 0.06 m3/h
+        [Description("US gal/m")]   USgalpm,    ///   1 US gallon per minute = 0.2271247068 m3/h
+        [Description("m3/h")]       m3ph,       /// * 1 m3/h
+        [Description("l/s")]        lps,        ///   1 liter/s = 3.6 m3/h
+        [Description("US gal/s")]   USgalps,    ///   1 US gallon per second = 13.627482408 m3/h
+        [Description("m3/m")]       m3pm,       ///   1 m3/m = 60 m3/h
+        [Description("cf/s")]       cfs,        ///   1 cubic foot per second = 101.9406477312 m3/h
 
         [Description("g")]          g,          ///   0.001 kg
+        [Description("oz")]         oz,         ///   0.0283495231 kg
+        [Description("lb")]         lb,         ///   0.45359237 kg
         [Description("kg")]         kg,         /// * 1 kilogram
         [Description("t")]          t,          ///   1000 kg
-        [Description("lb")]         lb,         ///   0.45359237 kg
 
+        [Description("ms")]         ms,         ///   1 ms = 0.001 s
         [Description("s")]          s,          /// * 1 second
         [Description("min")]        min,        ///   1 min = 60 s
         [Description("hr")]         hour,       ///   1 hour = 60 min = 3600 s
-        [Description("ms")]         ms,         ///   1 ms = 0.001 s
 
 		[Description("°C")]         C,          /// * degree Celsius (°C)
         [Description("°F")]         F,          ///   degree Fahrenheit
@@ -42,21 +52,25 @@ namespace Config
 
         [Description("Pa")]         Pa,         ///   1 Pa = 0.01 hPa
         [Description("hPa")]        hPa,        ///   1 hPa = 100 Pa
-        [Description("kPa")]        kPa,        ///   1 kPa = 10 HPa
-        [Description("MPa")]        MPa,        ///   1 MPa = 10000 hPa
         [Description("mbar")]       mbar,       ///   1 mbar = 1 hPa = 100 Pa
-        [Description("bar")]        bar,        /// * 1 Bar = 1000 mbar = 0.1 MPa = 100000 Pa
+        [Description("kPa")]        kPa,        ///   1 kPa = 10 hPa = 1000 Pa
         [Description("inHg")]       inHg,       ///   1 inHg = 33.864 hPa
+        [Description("psi")]        psi,        ///   1 psi = 0.0689475729 bar
+        [Description("bar")]        bar,        /// * 1 Bar = 1000 mbar = 0.1 MPa = 100000 Pa
+        [Description("MPa")]        MPa,        ///   1 MPa = 10000 hPa
 
         [Description("R%")]         RPct,       /// * 1 R%
 
-        [Description("%")]          Pct,        /// * 1 %
         [Description("promile")]    Promile,    ///   1 promile = 0.1 %
+        [Description("%")]          Pct,        /// * 1 %
 
         [Description("mm")]         mm,         /// * 1 millimeter
         [Description("cm")]         cm,         ///   1 cm = 10 mm
-        [Description("m")]          m,          ///   1 m = 1000 mm
         [Description("in")]         inch,       ///   1 inch = 25.4 mm
+        [Description("dm")]         dm,         ///   1 dm = 100 mm
+        [Description("ft")]         foot,       ///   1 foot = 304.8 mm
+        [Description("yd")]         yard,       ///   1 yard = 914.4 mm
+        [Description("m")]          m,          ///   1 m = 1000 mm
 
         [Description("kg/m3")]      kgpm3,		/// * 1 kg/m3 = 0.001 kg/l
         [Description("kg/l")]       kgpl,		///   1 kg/l = 1000 kg/m3
@@ -68,6 +82,9 @@ namespace Config
         [Description("kWh")]        kWh,		///   1 kWh = 3600000 J
         [Description("MWh")]        MWh,		///   1 MWh = 3600000000 J
 
+        [Description("uS/cm")]      uSpcm,      /// * 1 uS/cm
+        [Description("mS/m")]       mSpm,       ///   1 mS/m = 10 uS/cm
+
 #if LANG_PL
         [Description("imp/l")]       ppl,		/// * 1 pulse/l
         [Description("imp/dm3")]     ppdm3,		/// * 1 pulse/dm3
@@ -79,17 +96,17 @@ namespace Config
         [Description("dm3/stopień")] dm3pdeg,	/// * 1 dm3/degree
 #else
         [Description("pulse/l")]    ppl,		/// * 1 pulse/l
-        [Description("pulse/dm3")]  ppdm3,		/// * 1 pulse/dm3
-        [Description("degree/l")]   degpl,		/// * 1 degree/l
-        [Description("degree/dm3")] degpdm3,	/// * 1 degree/dm3
-        [Description("l/pulse")]    lpp,		/// * 1 l/pulse
-        [Description("dm3/pulse")]  dm3pp,		/// * 1 dm3/pulse
-        [Description("l/degree")]   lpdeg,		/// * 1 l/degree
-        [Description("dm3/degree")] dm3pdeg,	/// * 1 dm3/degree
+        [Description("pulse/dm3")]  ppdm3,		///   1 pulse/dm3
+        [Description("degree/l")]   degpl,		///   1 degree/l
+        [Description("degree/dm3")] degpdm3,	///   1 degree/dm3
+        [Description("l/pulse")]    lpp,		///   1 l/pulse
+        [Description("dm3/pulse")]  dm3pp,		///   1 dm3/pulse
+        [Description("l/degree")]   lpdeg,		///   1 l/degree
+        [Description("dm3/degree")] dm3pdeg,	///   1 dm3/degree
 #endif
         /// 
         [Description("pulse/kWh")]  ppkWh,		/// * 1 pulse/kWh
-        [Description("kWh/pulse")]  kWhpp,		/// * 1 kWh/pulse
+        [Description("kWh/pulse")]  kWhpp,		///   1 kWh/pulse
                                                 
         Count
     }
@@ -112,12 +129,14 @@ namespace Config
 		[Description("Impulse")]			Pulses,
         [Description("Impulse/l")]			PulsePerLtr,
         [Description("Impulse/kWh")]		PulsePerKWh,
+        [Description("Leitfähigkeit")]      Conductivity,
 
         /// Quantities without units and conversions
         [Description("Nummer")]				Number,
         [Description("Text")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Datum und Uhrzeit")]  DateTime,
+        [Description("Aufgezählt")]         Enumerated,
 #elif LANG_PL
         [Description("Objętość")]			Volume,
 		[Description("Przepływ")]           Flow,
@@ -133,12 +152,14 @@ namespace Config
         [Description("Impulsy")]            Pulses,
         [Description("Impulsy/litr")]       PulsePerLtr,
         [Description("Impulsy/kWh")]		PulsePerKWh,
+        [Description("Przewodność")]        Conductivity,
 
         /// Quantities without units and conversions
         [Description("Numer")]				Number,
         [Description("Tekst")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Data i czas")]		DateTime,
+        [Description("Wyliczone")]          Enumerated,
 #elif LANG_CS
 		[Description("Objem")]				Volume,
 		[Description("Průtok")]				Flow,
@@ -154,12 +175,14 @@ namespace Config
 		[Description("Pulzy")]				Pulses,
         [Description("Pulzy/litr")]			PulsePerLtr,
         [Description("Pulzy/kWh")]			PulsePerKWh,
+        [Description("Vodivost")]           Conductivity,
 
         /// Quantities without units and conversions
         [Description("Počet")]				Number,
         [Description("Text")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Datum a čas")]		DateTime,
+        [Description("Vyjmenované")]        Enumerated,
 #elif LANG_IT
 		[Description("Volume")]				Volume,
 		[Description("Flusso")]				Flow,
@@ -175,12 +198,14 @@ namespace Config
 		[Description("Impulso")]			Pulses,
         [Description("Impulso/litro")]		PulsePerLtr,
         [Description("Impulso/kWh")]		PulsePerKWh,
+        [Description("Conduttività")]       Conductivity,
 
         /// Quantities without units and conversions
         [Description("Numero")]				Number,
         [Description("Stringa")]			String,
         [Description("Boolean")]			Boolean,
         [Description("Data e ora")]		    DateTime,
+        [Description("Enumerato")]          Enumerated,
 #else
         [Description("Volume")]				Volume,
 		[Description("Flow")]				Flow,
@@ -196,12 +221,14 @@ namespace Config
 		[Description("Pulses")]				Pulses,
         [Description("Pulses/liter")]		PulsePerLtr,
         [Description("Pulses/kWh")]			PulsePerKWh,
+        [Description("Conductivity")]       Conductivity,
 
         /// Quantities without units and conversions
         [Description("Number")]				Number,
         [Description("String")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Date and time")]		DateTime,
+        [Description("Enumerated")]         Enumerated,
 #endif
         Count,
 	}
@@ -215,8 +242,9 @@ namespace Config
 
         public static bool IsDefaultUnit(Unit unit)
         {
-            return unit == Unit.l || unit == Unit.m3ph || unit == Unit.kg || unit == Unit.s || unit == Unit.C || unit == Unit.bar || unit == Unit.RPct ||
-                   unit == Unit.Pct || unit == Unit.mm || unit == Unit.kgpm3 || unit == Unit.J || unit == Unit.ppl || unit == Unit.ppkWh;
+            return unit == Unit.l || unit == Unit.m3ph || unit == Unit.kg || unit == Unit.s || unit == Unit.C ||
+                   unit == Unit.bar || unit == Unit.RPct || unit == Unit.Pct || unit == Unit.mm || unit == Unit.kgpm3 ||
+                   unit == Unit.J || unit == Unit.uSpcm || unit == Unit.ppl || unit == Unit.ppkWh;
         }
 
         public static bool IsQuantity(Unit units, Quantity quantity)
@@ -230,61 +258,75 @@ namespace Config
             {
                 case Unit.pulse:
                 case Unit.degree:
-                    return Config.Quantity.Pulses;
+                    return Quantity.Pulses;
 
+                case Unit.ml:
                 case Unit.l:
                 case Unit.dm3:
+                case Unit.USgal:
+                case Unit.UKgal:
+                case Unit.cf:
                 case Unit.m3:
-                case Unit.gal_UK:
-                case Unit.gal_US:
-					return Config.Quantity.Volume;
+					return Quantity.Volume;
 
                 case Unit.lph:
+                case Unit.cfph:
+                case Unit.lpm:
+                case Unit.USgalpm:
                 case Unit.m3ph:
-					return Config.Quantity.Flow;
+                case Unit.lps:
+                case Unit.USgalps:
+                case Unit.m3pm:
+                case Unit.cfs:
+                    return Quantity.Flow;
 
                 case Unit.g:
+                case Unit.oz:
+                case Unit.lb:
                 case Unit.kg:
                 case Unit.t:
-                case Unit.lb:
-					return Config.Quantity.Mass;
+					return Quantity.Mass;
 
+                case Unit.ms:
                 case Unit.s:
                 case Unit.min:
                 case Unit.hour:
-                case Unit.ms:
-                    return Config.Quantity.Time;
+                    return Quantity.Time;
 
                 case Unit.C:
                 case Unit.F:
                 case Unit.K:
-					return Config.Quantity.Temperature;
+					return Quantity.Temperature;
 
                 case Unit.Pa:
                 case Unit.hPa:
                 case Unit.mbar:
                 case Unit.kPa:
+                case Unit.inHg:
+                case Unit.psi:
                 case Unit.bar:
                 case Unit.MPa:
-                case Unit.inHg:
-					return Config.Quantity.Pressure;
+                    return Quantity.Pressure;
 
                 case Unit.RPct:
-                    return Config.Quantity.Humidity;
+                    return Quantity.Humidity;
 
-                case Unit.Pct:
                 case Unit.Promile:
-					return Config.Quantity.Error;
+                case Unit.Pct:
+					return Quantity.Error;
 
                 case Unit.mm:
                 case Unit.cm:
-                case Unit.m:
                 case Unit.inch:
-					return Config.Quantity.Length;
+                case Unit.dm:
+                case Unit.foot:
+                case Unit.yard:
+                case Unit.m:
+					return Quantity.Length;
 
 				case Unit.kgpm3:
 				case Unit.kgpl:
-					return Config.Quantity.Density;
+					return Quantity.Density;
 
 				case Unit.J:
 				case Unit.kJ:
@@ -292,7 +334,11 @@ namespace Config
                 case Unit.Wh:
 				case Unit.kWh:
                 case Unit.MWh:
-                    return Config.Quantity.Energy;
+                    return Quantity.Energy;
+
+                case Unit.uSpcm:
+                case Unit.mSpm:
+                    return Quantity.Conductivity;
 
                 case Unit.ppl:
                 case Unit.ppdm3:
@@ -302,14 +348,14 @@ namespace Config
                 case Unit.dm3pp:
                 case Unit.lpdeg:
                 case Unit.dm3pdeg:
-                    return Config.Quantity.PulsePerLtr;
+                    return Quantity.PulsePerLtr;
 
                 case Unit.ppkWh:
                 case Unit.kWhpp:
-                    return Config.Quantity.PulsePerKWh;
+                    return Quantity.PulsePerKWh;
 
                 default:
-					return Config.Quantity.Number;
+					return Quantity.Number;
             }
 		}
 
@@ -327,6 +373,7 @@ namespace Config
         public static bool IsPulses(Unit units) { return IsQuantity(units, Config.Quantity.Pulses); }
         public static bool IsPulsePerLtr(Unit units) { return IsQuantity(units, Config.Quantity.PulsePerLtr); }
         public static bool IsPulsePerKWh(Unit units) { return IsQuantity(units, Config.Quantity.PulsePerKWh); }
+        public static bool IsConductivity(Unit units) { return IsQuantity(units, Config.Quantity.Conductivity); }
 
 
 		public static double ConvertTo(Unit units, double v)
@@ -334,71 +381,78 @@ namespace Config
             switch (units)
             {
                 /// Volume: internal representation in l
-                case Unit.dm3:
-                case Unit.l:        return v;               /// 1 liter
-                case Unit.m3:       return 0.001 * v;       /// 1 m3 = 1000 l
-                case Unit.gal_UK:   return 0.21996925 * v;  /// 1 gal(UK) = 4.54609 l
-                case Unit.gal_US:   return 0.26417205 * v;  /// 1 gal(US) = 3.78541178 l
+                case Unit.ml:       return 1000 * v;            /// 1 ml = 0.001 l
+                case Unit.USgal:    return 0.26417205 * v;      /// 1 gal(US) = 3.78541178 l
+                case Unit.UKgal:    return 0.21996925 * v;      /// 1 gal(UK) = 4.54609 l
+                case Unit.cf:       return 0.0353146667215 * v; /// 1 cubic foot = 28.316846592 l
+                case Unit.m3:       return 0.001 * v;           /// 1 m3 = 1000 l
 
                 /// Flow: internal representation in m3/h
-                case Unit.lph:      return 1000 * v;        /// 1 liter/h
-                case Unit.m3ph:     return v;               /// 1 m3/h = 1000 l/h
+                case Unit.lph:      return 1000 * v;            /// 1 l/h
+                case Unit.cfph:     return 35.3146667214886 * v;/// 1 cf/h
+                case Unit.lpm:      return v / 0.06;            /// 1 l/m
+                case Unit.USgalpm:  return 4.40286754395493 * v;/// 1 US gallon per minute
+                case Unit.lps:      return v / 3.6;             /// 1 l/s
+                case Unit.USgalps:  return 0.0733811257326 * v; /// 1 US gallon per second
+                case Unit.m3pm:     return v / 60;              /// 1 m3/m
+                case Unit.cfs:      return 0.009809629644858 * v; /// 1 cubic foot per second
 
                 /// Mass: internal representation in kg
-                case Unit.g:        return 1000 * v;        /// 1 g = 0.001 kg
-                case Unit.kg:       return v;               /// 1 kilogram
-                case Unit.t:        return 0.001 * v;       /// 1 t = 1000 kg
-                case Unit.lb:       return 2.2046226 * v;   /// 1 lb = 0.45359237 kg
+                case Unit.g:        return 1000 * v;            /// 1 g = 0.001 kg
+                case Unit.oz:       return 35.273962 * v;       /// 1 oz = 0.0283495231 kg
+                case Unit.lb:       return 2.2046226 * v;       /// 1 lb = 0.45359237 kg
+                case Unit.t:        return 0.001 * v;           /// 1 t = 1000 kg
 
                 /// Time or duration: internal representation in seconds [s] 
-                case Unit.s:        return v;
+                case Unit.ms:       return 1000 * v;
                 case Unit.min:      return v / 60;
                 case Unit.hour:     return v / 3600;
-                case Unit.ms:       return 1000 * v;
 
 				/// Temperature: internal representation in °C
-				case Unit.C:        return v;               /// degree Celsius (°C)
-                case Unit.F:        return 1.8 * v + 32;    /// degree Fahrenheit
-                case Unit.K:        return v + 273.15;      /// degree Kelvin
+                case Unit.F:        return 1.8 * v + 32;        /// degree Fahrenheit
+                case Unit.K:        return v + 273.15;          /// degree Kelvin
 
                 /// Pressure: internal representation in  bar = 0.1 MPa
-                case Unit.Pa:       return 100000 * v;      /// 1 hPa = 100 Pa
-                case Unit.hPa:      return 1000 * v;        /// 1 hPa = 100 Pa
-                case Unit.mbar:     return 1000 * v;        /// 1 mbar = 1 hPa = 100 Pa
-                case Unit.kPa:      return 100 * v;         /// 1 kPa = 10 HPa
-                case Unit.bar:      return v;               /// 1 bar = 1000 mbar = 100000 Pa
-                case Unit.MPa:      return 0.1 * v;         /// 1 MPa = 10000 hPa
-                case Unit.inHg:     return 29.53 * v;       /// 1 inHg = 33.864 hPa
+                case Unit.Pa:       return 100000 * v;          /// 1 hPa = 100 Pa
+                case Unit.hPa:      return 1000 * v;            /// 1 hPa = 100 Pa
+                case Unit.mbar:     return 1000 * v;            /// 1 mbar = 1 hPa = 100 Pa
+                case Unit.kPa:      return 100 * v;             /// 1 kPa = 10 HPa
+                case Unit.inHg:     return 29.53 * v;           /// 1 inHg =
+                case Unit.psi:      return 14.5037738 * v;      /// 1 psi =
+                case Unit.MPa:      return 0.1 * v;             /// 1 MPa = 10000 hPa
 
-                /// Error: internal representation in %
-                case Unit.Pct:      return v;               /// 1 %
-                case Unit.Promile:  return 10 * v;          /// 1 promile = 0.1 %
+                /// Relative error: internal representation in %
+                case Unit.Promile:  return 10 * v;              /// 1 promile = 0.1 %
 
                 /// Diameter, length: internal representation in mm
-                case Unit.mm:       return v;               /// 1 mm
-                case Unit.cm:       return 0.1 * v;         /// 1 cm = 10 mm
-                case Unit.m:        return 0.001 * v;       /// 1 m = 1000 mm
-                case Unit.inch:     return v / 25.4;        /// 1 inch = 25.4 mm
-
+                case Unit.cm:       return 0.1 * v;             /// 1 cm = 10 mm
+                case Unit.inch:     return v / 25.4;            /// 1 inch = 25.4 mm
+                case Unit.dm:       return 0.01 * v;            /// 1 dm = 100 mm
+                case Unit.foot:     return v / 304.8;           /// 1 foot = 304.8 mm
+                case Unit.yard:     return v / 914.4;           /// 1 yard = 914,4 mm
+                case Unit.m:        return 0.001 * v;           /// 1 m = 1000 mm
+                                                                
 				/// Density: internal representation in kg/m3
-				case Unit.kgpm3:    return v;
 				case Unit.kgpl:     return 0.001 * v;
 
 				/// Energy, internal representation in Joul
-				case Unit.J:        return v;               /// 1 Joul
-				case Unit.kJ:       return 0.001 * v;       /// 1 kJ = 1000 J
-                case Unit.MJ:       return 0.000001 * v;    /// 1 kJ = 1000000 J
-                case Unit.Wh:       return v / 3600.0;      /// 1 Wh = 3600 J
-				case Unit.kWh:      return v / 3600000.0;   /// 1 kWh = 3600000 J
-                case Unit.MWh:      return v / 3600000000.0;/// 1 MWh = 3600000000 J
+				case Unit.kJ:       return 0.001 * v;           /// 1 kJ = 1000 J
+                case Unit.MJ:       return 0.000001 * v;        /// 1 kJ = 1000000 J
+                case Unit.Wh:       return v / 3600.0;          /// 1 Wh = 3600 J
+				case Unit.kWh:      return v / 3600000.0;       /// 1 kWh = 3600000 J
+                case Unit.MWh:      return v / 3600000000.0;    /// 1 MWh = 3600000000 J
 
+                /// Electrical conductivity
+                case Unit.mSpm:     return 0.1 * v;
+
+                /// Invert pulses
                 case Unit.kWhpp:
                 case Unit.lpp:
                 case Unit.dm3pp:
                 case Unit.lpdeg:
-                case Unit.dm3pdeg:  return ((v <= float.Epsilon) ? 0 : 1 / v);
+                case Unit.dm3pdeg:  return (v <= float.Epsilon) ? 0 : 1/v;
 
-                default:            return v;
+                default:            return v;                   /// Do not convert
             }
         }
 
@@ -407,71 +461,78 @@ namespace Config
             switch (units)
             {
                 /// Volume: internal representation in l
-                case Unit.dm3:
-                case Unit.l:        return v;               /// 1 liter
-                case Unit.m3:       return 1000 * v;        /// 1000 l
-                case Unit.gal_UK:   return 4.54609 * v;     /// 1 gal(UK) = 4.54609 l
-                case Unit.gal_US:   return 3.78541178 * v;  /// 1 gal(US) = 3.78541178 l
+                case Unit.ml:       return 0.001 * v;           /// 0.001 l
+                case Unit.USgal:    return 3.78541178 * v;      /// 1 gal(US) = 3.78541178 l
+                case Unit.UKgal:    return 4.54609 * v;         /// 1 gal(UK) = 4.54609 l
+                case Unit.cf:       return 28.316846592 * v;    /// 1 cubic foot = 28.316846592 l
+                case Unit.m3:       return 1000 * v;            /// 1000 l
 
                 /// Flow: internal representation in m3/h
-                case Unit.lph:      return 0.001 * v;       /// 1 liter/h
-                case Unit.m3ph:     return v;               /// 1 m3/h = 1000 l/h
+                case Unit.lph:      return 0.001 * v;           /// 1 l/h
+                case Unit.cfph:     return 0.028316846592 * v;  /// 1 cf/h
+                case Unit.lpm:      return 0.06 * v;            /// 1 l/m
+                case Unit.USgalpm:  return 0.2271247068 * v;    /// 1 US gallon per minute
+                case Unit.lps:      return 3.6 * v;             /// 1 l/s
+                case Unit.USgalps:  return 13.627482408 * v;    /// 1 US gallon per second
+                case Unit.m3pm:     return 60 * v;              /// 1 m3/m
+                case Unit.cfs:      return 101.9406477312 * v;  /// 1 cubic foot per second
 
                 /// Mass: internal representation in kg
-                case Unit.g:        return 0.001 * v;       /// 1 g = 0.001 kg
-                case Unit.kg:       return v;               /// 1 kilogram
-                case Unit.t:        return 1000 * v;        /// 1 t = 1000 kg
-                case Unit.lb:       return 0.45359237 * v;  /// 1 lb = 0.45359237 kg
+                case Unit.g:        return 0.001 * v;           /// 1 g = 0.001 kg
+                case Unit.oz:       return 0.0283495231 * v;    /// 1 oz = 0.0283495231 kg
+                case Unit.lb:       return 0.45359237 * v;      /// 1 lb = 0.45359237 kg
+                case Unit.t:        return 1000 * v;            /// 1 t = 1000 kg
 
                 /// Time or duration: internal representation in seconds [s] 
-                case Unit.s:        return v;
+                case Unit.ms:       return 0.001 * v;
                 case Unit.min:      return 60 * v;
                 case Unit.hour:     return 3600 * v;
-                case Unit.ms:       return v / 1000;
 
 				/// Temperature: internal representation in °C
-				case Unit.C:        return v;               /// degree Celsius (°C)
-                case Unit.F:        return 5 * (v-32) / 9;  /// degree Fahrenheit
-                case Unit.K:        return v - 273.15;      /// degree Kelvin
+                case Unit.F:        return 5 * (v - 32) / 9;    /// degree Fahrenheit
+                case Unit.K:        return v - 273.15;          /// degree Kelvin
 
                 /// Pressure: internal representation in  bar = 0.1 MPa
-                case Unit.Pa:       return 0.00001 * v;     /// 1 hPa = 100 Pa
-                case Unit.hPa:      return 0.001 * v;       /// 1 hPa = 100 Pa
-                case Unit.mbar:     return 0.001 * v;       /// 1 mbar = 1 hPa = 100 Pa
-                case Unit.kPa:      return 0.01 * v;        /// 1 kPa = 10 HPa
-                case Unit.bar:      return v;               /// 1 bar = 1000 mbar = 100000 Pa
-                case Unit.MPa:      return 10 * v;          /// 1 MPa = 10000 hPa
-                case Unit.inHg:     return 0.033864 * v;    /// 1 inHg = 33.864 hPa
+                case Unit.Pa:       return 0.00001 * v;         /// 1 hPa = 100 Pa
+                case Unit.hPa:      return 0.001 * v;           /// 1 hPa = 100 Pa
+                case Unit.mbar:     return 0.001 * v;           /// 1 mbar = 1 hPa = 100 Pa
+                case Unit.kPa:      return 0.01 * v;            /// 1 kPa = 10 HPa
+                case Unit.inHg:     return 0.033864 * v;        /// 1 inHg = 33.864 hPa
+                case Unit.psi:      return 0.0689475729 * v;    /// 1 psi = 0.0689475729 bar
+                case Unit.MPa:      return 10 * v;              /// 1 MPa = 10000 hPa
 
-                /// Error: internal representation in %
-                case Unit.Pct:      return v;               /// 1 %
-                case Unit.Promile:  return 0.1 * v;         /// 1 promile = 0.1 %
+                /// Relative error: internal representation in %
+                case Unit.Promile:  return 0.1 * v;             /// 1 promile = 0.1 %
 
                 /// Diameter, length: internal representation in mm
-                case Unit.mm:       return v;               /// 1 mm
-                case Unit.cm:       return 10 * v;          /// 1 cm = 10 mm
-                case Unit.m:        return 1000 * v;        /// 1 m = 1000 mm
-                case Unit.inch:     return 25.4 * v;        /// 1 inch = 25.4 mm
+                case Unit.cm:       return 10 * v;              /// 1 cm = 10 mm
+                case Unit.inch:     return 25.4 * v;            /// 1 inch = 25.4 mm
+                case Unit.dm:       return 100 * v;             /// 1 dm = 100 mm
+                case Unit.foot:     return 304.8 * v;           /// 1 foot = 304.8 mm
+                case Unit.yard:     return 914.4 * v;           /// 1 yard = 914,4 mm
+                case Unit.m:        return 1000 * v;            /// 1 m = 1000 mm
 
 				/// Density: internal representation in kg/m3
-				case Unit.kgpm3:    return v;
 				case Unit.kgpl:     return 1000 * v;
 
 				/// Energy, internal representation in Joul
-				case Unit.J:		return v;               /// 1 Joul
-				case Unit.kJ:		return 1000 * v;        /// 1 kJ = 1000 J
-                case Unit.MJ:       return 1000000 * v;     /// 1 kJ = 1000000 J
-                case Unit.Wh:       return 3600 * v;        /// 1 Wh = 3600 J
-				case Unit.kWh:		return 3600000 * v;     /// 1 kWh = 3600000 J
-                case Unit.MWh:      return 3600000000 * v;  /// 1 kWh = 3600000000 J
+				case Unit.kJ:		return 1000 * v;            /// 1 kJ = 1000 J
+                case Unit.MJ:       return 1000000 * v;         /// 1 kJ = 1000000 J
+                case Unit.Wh:       return 3600 * v;            /// 1 Wh = 3600 J
+				case Unit.kWh:		return 3600000 * v;         /// 1 kWh = 3600000 J
+                case Unit.MWh:      return 3600000000 * v;      /// 1 kWh = 3600000000 J
 
+                /// Electrical conductivity
+                case Unit.mSpm:     return 10 * v;
+
+                /// Invert
                 case Unit.kWhpp:
                 case Unit.lpp:
                 case Unit.dm3pp:
                 case Unit.lpdeg:
-                case Unit.dm3pdeg:  return ((v == 0) ? 0 : 1 / v);
+                case Unit.dm3pdeg:  return (v <= float.Epsilon) ? 0 : 1/v;
 
-                default:            return v;
+                default:            return v;                   /// Do not convert
             }
         }
 	}

DataStreamInterface/DataFrame.cs

@@ -0,0 +1,23 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+
+namespace DataStreamInterface
+{
+    public class DataFrame
+    {
+        public readonly Int64 ID;          /// Frame ID
+        public readonly double Time;        /// Time stamp in units of time
+        public readonly double Volume;      /// Volume in units of volume
+        public readonly double[] Quantity;  /// An array of optional quantities in their respective units
+
+        public DataFrame(Int64 id, double time, double volume, double[] quantity)
+        {
+            ID = id;
+            Time = time;
+            Volume = volume;
+            Quantity = quantity;
+        }
+    }
+}

DataStreamInterface/DataStreamInterface.csproj

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{7EBEEA14-91C4-48D7-AF0A-7A4BC3FF9A28}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>DataStreamInterface</RootNamespace>
+    <AssemblyName>DataStreamInterface</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.ComponentModel.Composition" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="DataFrame.cs" />
+    <Compile Include="Enums.cs" />
+    <Compile Include="IDataStreamMeter.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Doc\Software interface for datastream water meters.docx">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

DataStreamInterface/Enums.cs

@@ -0,0 +1,401 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+
+namespace DataStreamInterface
+{
+    public enum Unit
+    {
+        None,
+
+        pulse,
+        degree,
+
+        /// Volume
+        ml,         ///   1 ml = 0.001 l
+        l,          /// * 1 liter
+        dm3,        ///   1 dm3 = 1 l
+        USgal,      ///   1 US gallon = 3.78541178 l
+        UKgal,      ///   1 imperial gallon = 4.54609 l
+        cf,         ///   1 cubic foot = 28.316846592 l
+        m3,         ///   1 m3 = 1000 l
+
+        /// Flow
+        lph,        ///   1 l/h = 0.001 m3/h
+        lpm,        ///   1 l/m = 60 l/h = 0.06 m3/h
+        m3ph,       /// * 1 m3/h
+        lps,        ///   1 liter/s = 3.6 m3/h
+        USgalps,    ///   1 US gallon per second = 13.627482408 m3/h
+        m3pm,       ///   1 m3/m = 60 m3/h
+        cfs,        ///   1 cubic foot per second = 101.9406477312 m3/h
+
+        /// Mass
+        g,          ///   0.001 kg
+        lb,         ///   0.45359237 kg
+        kg,         /// * 1 kilogram
+        t,          ///   1000 kg
+
+        /// Time
+        ms,         ///   1 ms = 0.001 s
+        s,          /// * 1 second = 1 s
+        min,        ///   1 min = 60 s
+        hour,       ///   1 hour = 60 min = 3600 s
+
+        /// Temperature
+        C,          /// * degree Celsius (°C)
+        F,          ///   degree Fahrenheit
+        K,          ///   degree Kelvin
+
+        /// Pressure
+        Pa,         ///   1 Pa = 0.01 hPa
+        hPa,        ///   1 hPa = 100 Pa
+        mbar,       ///   1 mbar = 1 hPa = 100 Pa
+        kPa,        ///   1 kPa = 10 HPa
+        inHg,       ///   1 inHg = 33.864 hPa
+        psi,        ///   1 psi = 0.0689475729 bar
+        bar,        /// * 1 Bar = 1000 mbar = 0.1 MPa = 100000 Pa
+        MPa,        ///   1 MPa = 10000 hPa
+
+        /// Humidity
+        RPct,       /// * 1 R%
+
+        /// Relative error
+        Promile,    ///   1 promile = 0.1 %
+        Pct,        /// * 1 %
+
+        /// Length
+        mm,         /// * 1 millimeter
+        cm,         ///   1 cm = 10 mm
+        inch,       ///   1 inch = 25.4 mm
+        dm,         ///   1 dm = 100 mm
+        foot,       ///   1 foot = 304.8 mm
+        yard,       ///   1 yard = 914.4 mm
+        m,          ///   1 m = 1000 mm
+
+        /// Density
+        kgpm3,		/// * 1 kg/m3 = 0.001 kg/l
+        kgpl,		///   1 kg/l = 1000 kg/m3
+
+        /// Energy
+        J,			/// * 1 Joul
+        kJ,			///   1 kJ = 1000 J
+        MJ,         ///   1 MJ = 1000000 J
+        Wh,			///   1 Wh = 3600 J
+        kWh,		///   1 kWh = 3600000 J
+        MWh,		///   1 MWh = 3600000000 J
+
+        /// Electrical conductivity
+        uSpcm,      /// * 1 uS/cm
+        mSpm,       ///   1 mS/m = 10 uS/cm
+
+        /// Meter coefficient - volume
+        ppl,		/// * 1 pulse/l
+        ppdm3,		///   1 pulse/dm3
+        degpl,		///   1 degree/l
+        degpdm3,	///   1 degree/dm3
+        lpp,		///   1 l/pulse
+        dm3pp,		///   1 dm3/pulse
+        lpdeg,		///   1 l/degree
+        dm3pdeg,	///   1 dm3/degree
+
+        /// Meter coefficient - energy
+        ppkWh,		/// * 1 pulse/kWh
+        kWhpp,		///   1 kWh/pulse
+    }
+
+    public enum Quantity
+    {
+        /// Quantities with units and conversions (double -> double)
+        Volume,
+        Flow,
+        Mass,
+        Time,
+        Temperature,
+        Pressure,
+        Humidity,
+        Error,
+        Length,
+        Density,
+        Energy,
+        Pulses,
+        PulsePerLtr,
+        PulsePerKWh,
+        Conductivity,
+
+        /// Quantities without units and conversions
+        Number,
+        String,
+        Boolean,
+        DateTime,
+        Enumerated,
+    }
+
+    public static class Units
+    {
+        public static bool IsDefaultUnit(Unit unit)
+        {
+            return unit == Unit.l || unit == Unit.m3ph || unit == Unit.kg || unit == Unit.s || unit == Unit.C ||
+                   unit == Unit.bar || unit == Unit.RPct || unit == Unit.Pct || unit == Unit.mm || unit == Unit.kgpm3 ||
+                   unit == Unit.J || unit == Unit.uSpcm || unit == Unit.ppl || unit == Unit.ppkWh;
+        }
+
+        public static Quantity GetQuantity(Unit units)
+        {
+            switch (units)
+            {
+                case Unit.pulse:
+                case Unit.degree:
+                    return Quantity.Pulses;
+
+                case Unit.ml:
+                case Unit.l:
+                case Unit.dm3:
+                case Unit.USgal:
+                case Unit.UKgal:
+                case Unit.cf:
+                case Unit.m3:
+                    return Quantity.Volume;
+
+                case Unit.lph:
+                case Unit.lpm:
+                case Unit.m3ph:
+                case Unit.lps:
+                case Unit.USgalps:
+                case Unit.m3pm:
+                case Unit.cfs:
+                    return Quantity.Flow;
+
+                case Unit.g:
+                case Unit.lb:
+                case Unit.kg:
+                case Unit.t:
+                    return Quantity.Mass;
+
+                case Unit.ms:
+                case Unit.s:
+                case Unit.min:
+                case Unit.hour:
+                    return Quantity.Time;
+
+                case Unit.C:
+                case Unit.F:
+                case Unit.K:
+                    return Quantity.Temperature;
+
+                case Unit.Pa:
+                case Unit.hPa:
+                case Unit.mbar:
+                case Unit.kPa:
+                case Unit.inHg:
+                case Unit.psi:
+                case Unit.bar:
+                case Unit.MPa:
+                    return Quantity.Pressure;
+
+                case Unit.RPct:
+                    return Quantity.Humidity;
+
+                case Unit.Promile:
+                case Unit.Pct:
+                    return Quantity.Error;
+
+                case Unit.mm:
+                case Unit.cm:
+                case Unit.inch:
+                case Unit.dm:
+                case Unit.foot:
+                case Unit.yard:
+                case Unit.m:
+                    return Quantity.Length;
+
+                case Unit.kgpm3:
+                case Unit.kgpl:
+                    return Quantity.Density;
+
+                case Unit.J:
+                case Unit.kJ:
+                case Unit.MJ:
+                case Unit.Wh:
+                case Unit.kWh:
+                case Unit.MWh:
+                    return Quantity.Energy;
+
+                case Unit.uSpcm:
+                case Unit.mSpm:
+                    return Quantity.Conductivity;
+
+                case Unit.ppl:
+                case Unit.ppdm3:
+                case Unit.degpl:
+                case Unit.degpdm3:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:
+                    return Quantity.PulsePerLtr;
+
+                case Unit.ppkWh:
+                case Unit.kWhpp:
+                    return Quantity.PulsePerKWh;
+
+                default:
+                    return Quantity.Number;
+            }
+        }
+
+        public static double ConvertTo(Unit units, double v)
+        {
+            switch (units)
+            {
+                /// Volume: internal representation in l
+                case Unit.ml:       return 1000 * v;            /// 1 l = 1000 ml
+                case Unit.USgal:    return 0.26417205 * v;      /// 1 gal(US) = 3.78541178 l
+                case Unit.UKgal:    return 0.21996925 * v;      /// 1 gal(UK) = 4.54609 l
+                case Unit.cf:       return 0.0353146667215 * v; /// 1 cubic foot = 28.316846592 l
+                case Unit.m3:       return 0.001 * v;           /// 1 m3 = 1000 l
+
+                /// Flow: internal representation in m3/h
+                case Unit.lph:      return 1000 * v;            /// 1 l/h
+                case Unit.lpm:      return v / 0.06;            /// 1 l/m
+                case Unit.lps:      return v / 3.6;             /// 1 l/s
+                case Unit.USgalps:  return 0.0733811257326 * v; /// 1 US gallon per second
+                case Unit.m3pm:     return v / 60;              /// 1 m3/m
+                case Unit.cfs:      return 0.009809629644858 * v; /// 1 cubic foot per second
+
+                /// Mass: internal representation in kg
+                case Unit.g:        return 1000 * v;            /// 1 g = 0.001 kg
+                case Unit.lb:       return 2.2046226 * v;       /// 1 lb = 0.45359237 kg
+                case Unit.t:        return 0.001 * v;           /// 1 t = 1000 kg
+
+                /// Time or duration: internal representation in seconds [s] 
+                case Unit.ms:       return 1000 * v;
+                case Unit.min:      return v / 60;
+                case Unit.hour:     return v / 3600;
+
+                /// Temperature: internal representation in °C
+                case Unit.F:        return 1.8 * v + 32;        /// degree Fahrenheit
+                case Unit.K:        return v + 273.15;          /// degree Kelvin
+
+                /// Pressure: internal representation in  bar = 0.1 MPa
+                case Unit.Pa:       return 100000 * v;
+                case Unit.hPa:      return 1000 * v;            /// 1 hPa = 100 Pa
+                case Unit.mbar:     return 1000 * v;            /// 1 mbar = 1 hPa = 100 Pa
+                case Unit.kPa:      return 100 * v;             /// 1 kPa = 10 HPa
+                case Unit.inHg:     return 29.53 * v;           /// 1 inHg =
+                case Unit.psi:      return 14.5037738 * v;      /// 1 psi =
+                case Unit.MPa:      return 0.1 * v;             /// 1 MPa = 10000 hPa
+
+                /// Relative error: internal representation in %
+                case Unit.Promile:  return 10 * v;              /// 1 promile = 0.1 %
+
+                /// Diameter, length: internal representation in mm
+                case Unit.cm:       return 0.1 * v;             /// 1 cm = 10 mm
+                case Unit.inch:     return v / 25.4;            /// 1 inch = 25.4 mm
+                case Unit.dm:       return 0.01 * v;            /// 1 dm = 100 mm
+                case Unit.foot:     return v / 304.8;           /// 1 foot = 304.8 mm
+                case Unit.yard:     return v / 914.4;           /// 1 yard = 914,4 mm
+                case Unit.m:        return 0.001 * v;           /// 1 m = 1000 mm
+
+                /// Density: internal representation in kg/m3
+                case Unit.kgpl:     return 0.001 * v;
+
+                /// Energy, internal representation in Joul
+                case Unit.kJ:       return 0.001 * v;           /// 1 kJ = 1000 J
+                case Unit.MJ:       return 0.000001 * v;        /// 1 kJ = 1000000 J
+                case Unit.Wh:       return v / 3600.0;          /// 1 Wh = 3600 J
+                case Unit.kWh:      return v / 3600000.0;       /// 1 kWh = 3600000 J
+                case Unit.MWh:      return v / 3600000000.0;    /// 1 MWh = 3600000000 J
+
+                /// Electrical conductivity
+                case Unit.mSpm:     return 0.1 * v;
+
+                /// Invert pulses
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return (v <= float.Epsilon) ? 0 : 1/v;
+
+                default:            return v;                   /// Do not convert
+            }
+        }
+
+        public static double ConvertFrom(Unit units, double v)
+        {
+            switch (units)
+            {
+                /// Volume: internal representation in l
+                case Unit.ml:       return 0.001 * v;           /// 0.001 l
+                case Unit.USgal:    return 3.78541178 * v;      /// 1 gal(US) = 3.78541178 l
+                case Unit.UKgal:    return 4.54609 * v;         /// 1 gal(UK) = 4.54609 l
+                case Unit.cf:       return 28.316846592 * v;    /// 1 cubic foot = 28.316846592 l
+                case Unit.m3:       return 1000 * v;            /// 1000 l
+
+                /// Flow: internal representation in m3/h
+                case Unit.lph:      return 0.001 * v;           /// 1 l/h
+                case Unit.lpm:      return 0.06 * v;            /// 1 l/m
+                case Unit.lps:      return 3.6 * v;             /// 1 l/s
+                case Unit.USgalps:  return 13.627482408 * v;    /// 1 US gallon per second
+                case Unit.m3pm:     return 60 * v;              /// 1 m3/m
+                case Unit.cfs:      return 101.9406477312 * v;  /// 1 cubic foot per second
+
+                /// Mass: internal representation in kg
+                case Unit.g:        return 0.001 * v;           /// 1 g = 0.001 kg
+                case Unit.lb:       return 0.45359237 * v;      /// 1 lb = 0.45359237 kg
+                case Unit.t:        return 1000 * v;            /// 1 t = 1000 kg
+
+                /// Time or duration: internal representation in seconds [s] 
+                case Unit.ms:       return 0.001 * v;
+                case Unit.min:      return 60 * v;
+                case Unit.hour:     return 3600 * v;
+
+                /// Temperature: internal representation in °C
+                case Unit.F:        return 5 * (v - 32) / 9;    /// degree Fahrenheit
+                case Unit.K:        return v - 273.15;          /// degree Kelvin
+
+                /// Pressure: internal representation in  bar = 0.1 MPa
+                case Unit.Pa:       return 0.00001 * v;         /// 1 hPa = 100 Pa
+                case Unit.hPa:      return 0.001 * v;           /// 1 hPa = 100 Pa
+                case Unit.mbar:     return 0.001 * v;           /// 1 mbar = 1 hPa = 100 Pa
+                case Unit.kPa:      return 0.01 * v;            /// 1 kPa = 10 HPa
+                case Unit.inHg:     return 0.033864 * v;        /// 1 inHg = 33.864 hPa
+                case Unit.psi:      return 0.0689475729 * v;    /// 1 psi = 0.0689475729 bar
+                case Unit.MPa:      return 10 * v;              /// 1 MPa = 10000 hPa
+
+                /// Relative error: internal representation in %
+                case Unit.Promile:  return 0.1 * v;             /// 1 promile = 0.1 %
+
+                /// Diameter, length: internal representation in mm
+                case Unit.cm:       return 10 * v;              /// 1 cm = 10 mm
+                case Unit.inch:     return 25.4 * v;            /// 1 inch = 25.4 mm
+                case Unit.dm:       return 100 * v;             /// 1 dm = 100 mm
+                case Unit.foot:     return 304.8 * v;           /// 1 foot = 304.8 mm
+                case Unit.yard:     return 914.4 * v;           /// 1 yard = 914,4 mm
+                case Unit.m:        return 1000 * v;            /// 1 m = 1000 mm
+
+                /// Density: internal representation in kg/m3
+                case Unit.kgpl:     return 1000 * v;
+
+                /// Energy, internal representation in Joul
+                case Unit.kJ:       return 1000 * v;            /// 1 kJ = 1000 J
+                case Unit.MJ:       return 1000000 * v;         /// 1 kJ = 1000000 J
+                case Unit.Wh:       return 3600 * v;            /// 1 Wh = 3600 J
+                case Unit.kWh:      return 3600000 * v;         /// 1 kWh = 3600000 J
+                case Unit.MWh:      return 3600000000 * v;      /// 1 kWh = 3600000000 J
+
+                /// Electrical conductivity
+                case Unit.mSpm:     return 10 * v;
+
+                /// Invert
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return (v <= float.Epsilon) ? 0 : 1/v;
+
+                default:            return v;                   /// Do not convert
+            }
+        }
+	}
+}

DataStreamInterface/IDataStreamMeter.cs

@@ -0,0 +1,140 @@
+///
+/// Copyright (c) 2020 Sensus Slovensko a.s.
+///
+using System;
+
+namespace DataStreamInterface
+{
+    public interface IDataStreamMeter
+    {
+        /// <summary>
+        /// Returns count of water meters supported by the data stream component
+        /// </summary>
+        /// <returns>Water meters count</returns>
+        int GetMetersCount();
+
+        /// <summary>
+        /// Get state of the connected data stream meter
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <param name="state">Current state of the meter</param>
+        /// <param name="parameter">Current extra parameter of the meter</param>
+        /// <returns>true when successful</returns>
+        bool GetState(int meterIx, out int state, out string parameter);
+
+        /// <summary>
+        /// Set state of the connected data stream meter
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <param name="state">Required state of the meter</param>
+        /// <param name="parameter">Required extra parameter of the meter</param>
+        /// <returns>true when successful</returns>
+        bool SetState(int meterIx, int state, string parameter);
+
+        bool SetStateAll(int state, string parameter);
+
+        /// <summary>
+        /// Establish connection with a data stream meter
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <param name="connectionParameters">Connection parameters</param>
+        /// <param name="meterId">Meter ID (e.g. serial number)</param>
+        /// <returns>true when successful</returns>
+        bool OpenConnection(int meterIx, string connectionParameters, out string meterId);
+
+        /// <summary>
+        /// Stars saving measurement results into internal data structures of the component.
+        /// Each data frame obtains a unique ID.
+        /// The very first data fraim obrains ID = 0.
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <returns>true when successful</returns>
+        bool StartMeasurement(int meterIx);
+
+        bool StartMeasurementAll();
+
+        /// <summary>
+        /// Stops saving measurement results into internal data structures of the component.
+        /// Updates ID of the last date frame received from the meter.
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <param name="storedFramesCount">Number of stored date frames</param>
+        /// <returns>true when successful</returns>
+        bool StopMeasurement(int meterIx, out Int64 storedFramesCount);
+
+        bool StopMeasurementAll(out Int64[] storedFramesCounts);
+
+        /// <summary>
+        /// Closes connection with the data stream meter
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <returns>true when successful</returns>
+        bool CloseConnection(int meterIx);
+
+        bool CloseConnectionAll();
+
+        /// <summary>
+        /// This function is called when TBF program is shutting down.
+        /// </summary>
+        /// <returns>true when successful</returns>
+        bool Shutdown();
+
+        ///------------------------------------------------
+        /// Units of time, volume and optional quantities
+        ///------------------------------------------------
+
+        /// <summary>
+        /// Returns time units (s, ms, ...)
+        /// </summary>
+        Unit GetTimeUnits();
+
+        /// <summary>
+        /// Returns units of volume (ml, l, ...)
+        /// </summary>
+        Unit GetVolumeUnits();
+
+        ///-----------------------------------------------
+        /// Optional quantities: count, units, captions
+        ///-----------------------------------------------
+
+        /// <summary>
+        /// Returns count of optional quantities in each data frame
+        /// </summary>
+        /// <returns>Count of optional quantities</returns>
+        int GetQuantitiesCount();
+
+        /// <summary>
+        /// Returns units of the specified quantity
+        /// </summary>
+        /// <param name="quanityNr">Zero based quantity number 0 .. quantites count-1</param>
+        Unit GetQuantityUnits(int quantityNr);
+
+        /// <summary>
+        /// Returns caption of the specified quantity
+        /// </summary>
+        /// <param name="quanityNr">Zero based quantity number 0 .. quantites count-1</param>
+        string GetQuantityCaption(int quantityNr);
+
+        ///---------------------------
+        /// Datastream data exchange
+        ///---------------------------
+
+        /// <summary>
+        /// Retuns 'count' data frames starting with data frame with ID = 'id' 
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <param name="id">First frame ID</param>
+        /// <param name="count">Frames count</param>
+        /// <returns>Selected data frames</returns>
+        DataFrame[] GetFrames(int meterIx, Int64 id, int count);
+
+        /// <summary>
+        /// Returns ID of the data frame where time equals or exceeds the specified time.
+        /// When time of the first frame (ID=0) is larger then specified time, function returns 0.
+        /// </summary>
+        /// <param name="meterIx">Index of the meter in range 0 .. (GetMetersCount() - 1)</param>
+        /// <param name="time">Time</param>
+        /// <returns>ID of the data frame at or after the pecified time</returns>
+        Int64 GetID(int meterIx, double time);
+    }
+}

DataStreamInterface/Properties/AssemblyInfo.cs

@@ -0,0 +1,38 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Resources;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DataStreamInterface")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DataStreamInterface")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("e44458ee-b635-4d7c-a763-20054399e817")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: NeutralResourcesLanguageAttribute("en")]

DataStreamInterfaceTest/ActivityLog.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Text;
+using System.Windows.Forms;
+
+namespace DataStreamInterfaceTest
+{
+    public class ActivityLog
+    {
+        const int LinesCount = 50;
+
+        TextBox textBox;
+        string[] lines;
+        string activity;
+
+        public ActivityLog(TextBox textBox)
+        {
+            this.textBox = textBox;
+            lines = new string[LinesCount];
+            for (int i = 0; i < LinesCount; i++) lines[i] = string.Empty;
+        }
+
+        public void Print(string log)
+        {
+            for (int i = LinesCount - 1; i > 0; i--) lines[i] = lines[i - 1];
+            lines[0] = log;
+            DisplayLines();
+        }
+
+        private void DisplayLines()
+        {
+            StringBuilder sb = new StringBuilder();
+            foreach (var line in lines) sb.AppendLine(line);
+            textBox.Text = sb.ToString();
+        }
+    }
+}

DataStreamInterfaceTest/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+    </startup>
+</configuration>

DataStreamInterfaceTest/DataStreamInterfaceTest.csproj

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{1D1EEF9C-7F41-43D3-BD09-5054D00F7A23}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>DataStreamInterfaceTest</RootNamespace>
+    <AssemblyName>DataStreamInterfaceTest</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.ComponentModel.Composition" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Deployment" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ActivityLog.cs" />
+    <Compile Include="DemoMainWnd.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="DemoMainWnd.Designer.cs">
+      <DependentUpon>DemoMainWnd.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GetDblValueDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="GetDblValueDlg.designer.cs">
+      <DependentUpon>GetDblValueDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GetFrameBoundariesDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="GetFrameBoundariesDlg.designer.cs">
+      <DependentUpon>GetFrameBoundariesDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GetIntegerNumberDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="GetIntegerNumberDlg.Designer.cs">
+      <DependentUpon>GetIntegerNumberDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GetStateDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="GetStateDlg.designer.cs">
+      <DependentUpon>GetStateDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="LviIDComparer.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <EmbeddedResource Include="DemoMainWnd.resx">
+      <DependentUpon>DemoMainWnd.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <EmbeddedResource Include="GetDblValueDlg.resx">
+      <DependentUpon>GetDblValueDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="GetFrameBoundariesDlg.resx">
+      <DependentUpon>GetFrameBoundariesDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="GetIntegerNumberDlg.resx">
+      <DependentUpon>GetIntegerNumberDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="GetStateDlg.resx">
+      <DependentUpon>GetStateDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DataStreamInterface\DataStreamInterface.csproj">
+      <Project>{7ebeea14-91c4-48d7-af0a-7a4bc3ff9a28}</Project>
+      <Name>DataStreamInterface</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

DataStreamInterfaceTest/DemoMainWnd.Designer.cs

@@ -0,0 +1,380 @@
+namespace DataStreamInterfaceTest
+{
+    partial class DemoMainWnd
+    {
+        /// <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 Windows Form 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.splitContainer1 = new System.Windows.Forms.SplitContainer();
+            this.getIDButton = new System.Windows.Forms.Button();
+            this.getFramesButton = new System.Windows.Forms.Button();
+            this.measurementLabel = new System.Windows.Forms.Label();
+            this.stateLabel = new System.Windows.Forms.Label();
+            this.capabilitiesLabel = new System.Windows.Forms.Label();
+            this.getQuantityUnitsButton = new System.Windows.Forms.Button();
+            this.getQuantityCaptionButton = new System.Windows.Forms.Button();
+            this.getQuantitiesCountButton = new System.Windows.Forms.Button();
+            this.getVolumeUnitsButton = new System.Windows.Forms.Button();
+            this.getTimeUnitsButton = new System.Windows.Forms.Button();
+            this.setStateButton = new System.Windows.Forms.Button();
+            this.getStateButton = new System.Windows.Forms.Button();
+            this.stopMeasurementButton = new System.Windows.Forms.Button();
+            this.startMeasurementButton = new System.Windows.Forms.Button();
+            this.closeConnectionButton = new System.Windows.Forms.Button();
+            this.openConnectionButton = new System.Windows.Forms.Button();
+            this.splitContainer2 = new System.Windows.Forms.SplitContainer();
+            this.logsTextBox = new System.Windows.Forms.TextBox();
+            this.dataTabControl = new System.Windows.Forms.TabControl();
+            this.tabPage1 = new System.Windows.Forms.TabPage();
+            this.framesListView = new System.Windows.Forms.ListView();
+            this.tabPage2 = new System.Windows.Forms.TabPage();
+            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
+            this.splitContainer1.Panel1.SuspendLayout();
+            this.splitContainer1.Panel2.SuspendLayout();
+            this.splitContainer1.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.splitContainer2)).BeginInit();
+            this.splitContainer2.Panel1.SuspendLayout();
+            this.splitContainer2.Panel2.SuspendLayout();
+            this.splitContainer2.SuspendLayout();
+            this.dataTabControl.SuspendLayout();
+            this.tabPage1.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // splitContainer1
+            // 
+            this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.splitContainer1.FixedPanel = System.Windows.Forms.FixedPanel.Panel1;
+            this.splitContainer1.IsSplitterFixed = true;
+            this.splitContainer1.Location = new System.Drawing.Point(0, 0);
+            this.splitContainer1.Name = "splitContainer1";
+            // 
+            // splitContainer1.Panel1
+            // 
+            this.splitContainer1.Panel1.Controls.Add(this.getIDButton);
+            this.splitContainer1.Panel1.Controls.Add(this.getFramesButton);
+            this.splitContainer1.Panel1.Controls.Add(this.measurementLabel);
+            this.splitContainer1.Panel1.Controls.Add(this.stateLabel);
+            this.splitContainer1.Panel1.Controls.Add(this.capabilitiesLabel);
+            this.splitContainer1.Panel1.Controls.Add(this.getQuantityUnitsButton);
+            this.splitContainer1.Panel1.Controls.Add(this.getQuantityCaptionButton);
+            this.splitContainer1.Panel1.Controls.Add(this.getQuantitiesCountButton);
+            this.splitContainer1.Panel1.Controls.Add(this.getVolumeUnitsButton);
+            this.splitContainer1.Panel1.Controls.Add(this.getTimeUnitsButton);
+            this.splitContainer1.Panel1.Controls.Add(this.setStateButton);
+            this.splitContainer1.Panel1.Controls.Add(this.getStateButton);
+            this.splitContainer1.Panel1.Controls.Add(this.stopMeasurementButton);
+            this.splitContainer1.Panel1.Controls.Add(this.startMeasurementButton);
+            this.splitContainer1.Panel1.Controls.Add(this.closeConnectionButton);
+            this.splitContainer1.Panel1.Controls.Add(this.openConnectionButton);
+            // 
+            // splitContainer1.Panel2
+            // 
+            this.splitContainer1.Panel2.Controls.Add(this.splitContainer2);
+            this.splitContainer1.Size = new System.Drawing.Size(826, 583);
+            this.splitContainer1.SplitterDistance = 150;
+            this.splitContainer1.TabIndex = 0;
+            // 
+            // getIDButton
+            // 
+            this.getIDButton.Location = new System.Drawing.Point(12, 480);
+            this.getIDButton.Name = "getIDButton";
+            this.getIDButton.Size = new System.Drawing.Size(128, 24);
+            this.getIDButton.TabIndex = 12;
+            this.getIDButton.Text = "Get ID";
+            this.getIDButton.UseVisualStyleBackColor = true;
+            this.getIDButton.Click += new System.EventHandler(this.getIDButton_Click);
+            // 
+            // getFramesButton
+            // 
+            this.getFramesButton.Location = new System.Drawing.Point(12, 450);
+            this.getFramesButton.Name = "getFramesButton";
+            this.getFramesButton.Size = new System.Drawing.Size(128, 24);
+            this.getFramesButton.TabIndex = 11;
+            this.getFramesButton.Text = "Get frames";
+            this.getFramesButton.UseVisualStyleBackColor = true;
+            this.getFramesButton.Click += new System.EventHandler(this.getFramesButton_Click);
+            // 
+            // measurementLabel
+            // 
+            this.measurementLabel.AutoSize = true;
+            this.measurementLabel.Location = new System.Drawing.Point(12, 374);
+            this.measurementLabel.Name = "measurementLabel";
+            this.measurementLabel.Size = new System.Drawing.Size(74, 13);
+            this.measurementLabel.TabIndex = 15;
+            this.measurementLabel.Text = "Measurement:";
+            // 
+            // stateLabel
+            // 
+            this.stateLabel.AutoSize = true;
+            this.stateLabel.Location = new System.Drawing.Point(12, 194);
+            this.stateLabel.Name = "stateLabel";
+            this.stateLabel.Size = new System.Drawing.Size(112, 13);
+            this.stateLabel.TabIndex = 14;
+            this.stateLabel.Text = "State and connection:";
+            // 
+            // capabilitiesLabel
+            // 
+            this.capabilitiesLabel.AutoSize = true;
+            this.capabilitiesLabel.Location = new System.Drawing.Point(12, 9);
+            this.capabilitiesLabel.Name = "capabilitiesLabel";
+            this.capabilitiesLabel.Size = new System.Drawing.Size(63, 13);
+            this.capabilitiesLabel.TabIndex = 13;
+            this.capabilitiesLabel.Text = "Capabilities:";
+            // 
+            // getQuantityUnitsButton
+            // 
+            this.getQuantityUnitsButton.Location = new System.Drawing.Point(12, 145);
+            this.getQuantityUnitsButton.Name = "getQuantityUnitsButton";
+            this.getQuantityUnitsButton.Size = new System.Drawing.Size(128, 24);
+            this.getQuantityUnitsButton.TabIndex = 4;
+            this.getQuantityUnitsButton.Text = "Get quantity units";
+            this.getQuantityUnitsButton.UseVisualStyleBackColor = true;
+            this.getQuantityUnitsButton.Click += new System.EventHandler(this.getQuantityUnitsButton_Click);
+            // 
+            // getQuantityCaptionButton
+            // 
+            this.getQuantityCaptionButton.Location = new System.Drawing.Point(12, 115);
+            this.getQuantityCaptionButton.Name = "getQuantityCaptionButton";
+            this.getQuantityCaptionButton.Size = new System.Drawing.Size(128, 24);
+            this.getQuantityCaptionButton.TabIndex = 3;
+            this.getQuantityCaptionButton.Text = "Get quantity caption";
+            this.getQuantityCaptionButton.UseVisualStyleBackColor = true;
+            this.getQuantityCaptionButton.Click += new System.EventHandler(this.getQuantityCaptionButton_Click);
+            // 
+            // getQuantitiesCountButton
+            // 
+            this.getQuantitiesCountButton.Location = new System.Drawing.Point(12, 85);
+            this.getQuantitiesCountButton.Name = "getQuantitiesCountButton";
+            this.getQuantitiesCountButton.Size = new System.Drawing.Size(128, 24);
+            this.getQuantitiesCountButton.TabIndex = 2;
+            this.getQuantitiesCountButton.Text = "Get quantities count";
+            this.getQuantitiesCountButton.UseVisualStyleBackColor = true;
+            this.getQuantitiesCountButton.Click += new System.EventHandler(this.getQuantitiesCountButton_Click);
+            // 
+            // getVolumeUnitsButton
+            // 
+            this.getVolumeUnitsButton.Location = new System.Drawing.Point(12, 55);
+            this.getVolumeUnitsButton.Name = "getVolumeUnitsButton";
+            this.getVolumeUnitsButton.Size = new System.Drawing.Size(128, 24);
+            this.getVolumeUnitsButton.TabIndex = 1;
+            this.getVolumeUnitsButton.Text = "Get volume units";
+            this.getVolumeUnitsButton.UseVisualStyleBackColor = true;
+            this.getVolumeUnitsButton.Click += new System.EventHandler(this.getVolumeUnitsButton_Click);
+            // 
+            // getTimeUnitsButton
+            // 
+            this.getTimeUnitsButton.Location = new System.Drawing.Point(12, 25);
+            this.getTimeUnitsButton.Name = "getTimeUnitsButton";
+            this.getTimeUnitsButton.Size = new System.Drawing.Size(128, 24);
+            this.getTimeUnitsButton.TabIndex = 0;
+            this.getTimeUnitsButton.Text = "Get time units";
+            this.getTimeUnitsButton.UseVisualStyleBackColor = true;
+            this.getTimeUnitsButton.Click += new System.EventHandler(this.getTimeUnitsButton_Click);
+            // 
+            // setStateButton
+            // 
+            this.setStateButton.Location = new System.Drawing.Point(12, 315);
+            this.setStateButton.Name = "setStateButton";
+            this.setStateButton.Size = new System.Drawing.Size(128, 24);
+            this.setStateButton.TabIndex = 8;
+            this.setStateButton.Text = "Set state";
+            this.setStateButton.UseVisualStyleBackColor = true;
+            this.setStateButton.Click += new System.EventHandler(this.setStateButton_Click);
+            // 
+            // getStateButton
+            // 
+            this.getStateButton.Location = new System.Drawing.Point(12, 285);
+            this.getStateButton.Name = "getStateButton";
+            this.getStateButton.Size = new System.Drawing.Size(128, 24);
+            this.getStateButton.TabIndex = 7;
+            this.getStateButton.Text = "Get state";
+            this.getStateButton.UseVisualStyleBackColor = true;
+            this.getStateButton.Click += new System.EventHandler(this.getStateButton_Click);
+            // 
+            // stopMeasurementButton
+            // 
+            this.stopMeasurementButton.Location = new System.Drawing.Point(12, 420);
+            this.stopMeasurementButton.Name = "stopMeasurementButton";
+            this.stopMeasurementButton.Size = new System.Drawing.Size(128, 24);
+            this.stopMeasurementButton.TabIndex = 10;
+            this.stopMeasurementButton.Text = "Stop measurement";
+            this.stopMeasurementButton.UseVisualStyleBackColor = true;
+            this.stopMeasurementButton.Click += new System.EventHandler(this.stopMeasurementButton_Click);
+            // 
+            // startMeasurementButton
+            // 
+            this.startMeasurementButton.Location = new System.Drawing.Point(12, 390);
+            this.startMeasurementButton.Name = "startMeasurementButton";
+            this.startMeasurementButton.Size = new System.Drawing.Size(128, 24);
+            this.startMeasurementButton.TabIndex = 9;
+            this.startMeasurementButton.Text = "Start measurement";
+            this.startMeasurementButton.UseVisualStyleBackColor = true;
+            this.startMeasurementButton.Click += new System.EventHandler(this.startMeasurementButton_Click);
+            // 
+            // closeConnectionButton
+            // 
+            this.closeConnectionButton.Location = new System.Drawing.Point(12, 240);
+            this.closeConnectionButton.Name = "closeConnectionButton";
+            this.closeConnectionButton.Size = new System.Drawing.Size(128, 24);
+            this.closeConnectionButton.TabIndex = 6;
+            this.closeConnectionButton.Text = "Close connection";
+            this.closeConnectionButton.UseVisualStyleBackColor = true;
+            this.closeConnectionButton.Click += new System.EventHandler(this.closeConnectionButton_Click);
+            // 
+            // openConnectionButton
+            // 
+            this.openConnectionButton.Location = new System.Drawing.Point(12, 210);
+            this.openConnectionButton.Name = "openConnectionButton";
+            this.openConnectionButton.Size = new System.Drawing.Size(128, 24);
+            this.openConnectionButton.TabIndex = 5;
+            this.openConnectionButton.Text = "Open connection";
+            this.openConnectionButton.UseVisualStyleBackColor = true;
+            this.openConnectionButton.Click += new System.EventHandler(this.openConnectionButton_Click);
+            // 
+            // splitContainer2
+            // 
+            this.splitContainer2.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.splitContainer2.Location = new System.Drawing.Point(0, 0);
+            this.splitContainer2.Name = "splitContainer2";
+            this.splitContainer2.Orientation = System.Windows.Forms.Orientation.Horizontal;
+            // 
+            // splitContainer2.Panel1
+            // 
+            this.splitContainer2.Panel1.Controls.Add(this.logsTextBox);
+            // 
+            // splitContainer2.Panel2
+            // 
+            this.splitContainer2.Panel2.Controls.Add(this.dataTabControl);
+            this.splitContainer2.Size = new System.Drawing.Size(672, 583);
+            this.splitContainer2.SplitterDistance = 222;
+            this.splitContainer2.TabIndex = 0;
+            // 
+            // logsTextBox
+            // 
+            this.logsTextBox.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.logsTextBox.Location = new System.Drawing.Point(0, 0);
+            this.logsTextBox.Multiline = true;
+            this.logsTextBox.Name = "logsTextBox";
+            this.logsTextBox.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
+            this.logsTextBox.Size = new System.Drawing.Size(672, 222);
+            this.logsTextBox.TabIndex = 0;
+            // 
+            // dataTabControl
+            // 
+            this.dataTabControl.Controls.Add(this.tabPage1);
+            this.dataTabControl.Controls.Add(this.tabPage2);
+            this.dataTabControl.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.dataTabControl.Location = new System.Drawing.Point(0, 0);
+            this.dataTabControl.Name = "dataTabControl";
+            this.dataTabControl.SelectedIndex = 0;
+            this.dataTabControl.Size = new System.Drawing.Size(672, 357);
+            this.dataTabControl.TabIndex = 0;
+            // 
+            // tabPage1
+            // 
+            this.tabPage1.Controls.Add(this.framesListView);
+            this.tabPage1.Location = new System.Drawing.Point(4, 22);
+            this.tabPage1.Name = "tabPage1";
+            this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
+            this.tabPage1.Size = new System.Drawing.Size(664, 331);
+            this.tabPage1.TabIndex = 0;
+            this.tabPage1.Text = "Transferred frames";
+            this.tabPage1.UseVisualStyleBackColor = true;
+            // 
+            // framesListView
+            // 
+            this.framesListView.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.framesListView.GridLines = true;
+            this.framesListView.Location = new System.Drawing.Point(3, 3);
+            this.framesListView.Name = "framesListView";
+            this.framesListView.Size = new System.Drawing.Size(658, 325);
+            this.framesListView.TabIndex = 0;
+            this.framesListView.UseCompatibleStateImageBehavior = false;
+            this.framesListView.View = System.Windows.Forms.View.Details;
+            // 
+            // tabPage2
+            // 
+            this.tabPage2.Location = new System.Drawing.Point(4, 22);
+            this.tabPage2.Name = "tabPage2";
+            this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
+            this.tabPage2.Size = new System.Drawing.Size(664, 331);
+            this.tabPage2.TabIndex = 1;
+            this.tabPage2.Text = "Graph";
+            this.tabPage2.UseVisualStyleBackColor = true;
+            // 
+            // DemoMainWnd
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(826, 583);
+            this.Controls.Add(this.splitContainer1);
+            this.Name = "DemoMainWnd";
+            this.Text = "Datastream interface test";
+            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.DemoMainWnd_FormClosing);
+            this.splitContainer1.Panel1.ResumeLayout(false);
+            this.splitContainer1.Panel1.PerformLayout();
+            this.splitContainer1.Panel2.ResumeLayout(false);
+            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
+            this.splitContainer1.ResumeLayout(false);
+            this.splitContainer2.Panel1.ResumeLayout(false);
+            this.splitContainer2.Panel1.PerformLayout();
+            this.splitContainer2.Panel2.ResumeLayout(false);
+            ((System.ComponentModel.ISupportInitialize)(this.splitContainer2)).EndInit();
+            this.splitContainer2.ResumeLayout(false);
+            this.dataTabControl.ResumeLayout(false);
+            this.tabPage1.ResumeLayout(false);
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.SplitContainer splitContainer1;
+        private System.Windows.Forms.Button openConnectionButton;
+        private System.Windows.Forms.Button closeConnectionButton;
+        private System.Windows.Forms.Button stopMeasurementButton;
+        private System.Windows.Forms.Button startMeasurementButton;
+        private System.Windows.Forms.Button setStateButton;
+        private System.Windows.Forms.Button getStateButton;
+        private System.Windows.Forms.Button getQuantityUnitsButton;
+        private System.Windows.Forms.Button getQuantityCaptionButton;
+        private System.Windows.Forms.Button getQuantitiesCountButton;
+        private System.Windows.Forms.Button getVolumeUnitsButton;
+        private System.Windows.Forms.Button getTimeUnitsButton;
+        private System.Windows.Forms.Label measurementLabel;
+        private System.Windows.Forms.Label stateLabel;
+        private System.Windows.Forms.Label capabilitiesLabel;
+        private System.Windows.Forms.Button getIDButton;
+        private System.Windows.Forms.Button getFramesButton;
+        private System.Windows.Forms.SplitContainer splitContainer2;
+        private System.Windows.Forms.TextBox logsTextBox;
+        private System.Windows.Forms.TabControl dataTabControl;
+        private System.Windows.Forms.TabPage tabPage1;
+        private System.Windows.Forms.ListView framesListView;
+        private System.Windows.Forms.TabPage tabPage2;
+    }
+}
+

DataStreamInterfaceTest/DemoMainWnd.cs

@@ -0,0 +1,292 @@
+using System;
+using System.Text;
+using System.Windows.Forms;
+using DataStreamInterface;
+
+namespace DataStreamInterfaceTest
+{
+    public partial class DemoMainWnd : Form
+    {
+        IDataStreamMeter dataStreamMeter;
+
+        ActivityLog activityLog;
+
+        Unit timeUnits;
+        Unit volumeUnits;
+        int quantitiesCount;
+        string[] quantityCaption;
+        Unit[] quantityUnit;
+
+        Int64 storedFramesCount;
+        DataFrame[] transferredFrames;
+
+        public DemoMainWnd() : this(null) { }
+
+        public DemoMainWnd(IDataStreamMeter dataStreamMeter)
+        {
+            InitializeComponent();
+            this.dataStreamMeter = dataStreamMeter;
+            activityLog = new ActivityLog(logsTextBox);
+
+            framesListView.Columns.Add("ID", 100);
+            framesListView.Columns.Add("Time", 100);
+            framesListView.Columns.Add("Volume", 100);
+            framesListView.Columns.Add("Additional quantities", 300);
+            framesListView.ListViewItemSorter = new LviIDComparer();
+        }
+
+        void ShowNoMeterInterfaceMessage()
+        {
+            MessageBox.Show("No datastream meter interface");
+        }
+
+        private void getTimeUnitsButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                timeUnits = dataStreamMeter.GetTimeUnits();
+                activityLog.Print(string.Format("Time units are {0}", timeUnits));
+            }
+        }
+
+        private void getVolumeUnitsButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                volumeUnits = dataStreamMeter.GetVolumeUnits();
+                activityLog.Print(string.Format("Volume units are {0}", volumeUnits));
+            }
+        }
+
+        private void getQuantitiesCountButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                int quantitesCountOri = quantitiesCount;
+                quantitiesCount = dataStreamMeter.GetQuantitiesCount();
+                activityLog.Print(string.Format("There are {0} additional quantites", quantitiesCount));
+
+                if (quantitesCountOri == 0)
+                {
+                    quantityUnit = new Unit[quantitiesCount];
+                    quantityCaption = new string[quantitiesCount];
+                    for (int i = 0; i < quantitiesCount; i++) quantityCaption[i] = string.Empty;
+                }
+                else if (quantitiesCount != quantitesCountOri)
+                {
+                    quantityUnit = new Unit[quantitiesCount];
+                    quantityCaption = new string[quantitiesCount];
+                    for (int i = 0; i < quantitiesCount; i++) quantityCaption[i] = string.Empty;
+
+                    activityLog.Print(string.Format("Quantities count changed during operation"));
+                    MessageBox.Show("Quantities count changed during operation", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
+                }
+            }
+        }
+
+        private void getQuantityCaptionButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                GetIntegerNumberDlg dlg = new GetIntegerNumberDlg(string.Format("Enter index {0} .. {1}", 0, quantitiesCount - 1), 0, quantitiesCount - 1);
+                if (dlg.ShowDialog() == DialogResult.OK)
+                {
+                    quantityCaption[dlg.Number] = dataStreamMeter.GetQuantityCaption(dlg.Number);
+                    activityLog.Print(string.Format("Caption of quantity #{0} is {1}", dlg.Number, quantityCaption[dlg.Number]));
+                }
+            }
+        }
+
+        private void getQuantityUnitsButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                GetIntegerNumberDlg dlg = new GetIntegerNumberDlg(string.Format("Enter index {0} .. {1}", 0, quantitiesCount - 1), 0, quantitiesCount - 1);
+                if (dlg.ShowDialog() == DialogResult.OK)
+                {
+                    quantityUnit[dlg.Number] = dataStreamMeter.GetQuantityUnits(dlg.Number);
+                    activityLog.Print(string.Format("Units of quantity #{0} are {1}", dlg.Number, quantityUnit[dlg.Number]));
+                }
+            }
+        }
+
+        private void openConnectionButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                string meterId;
+                if (dataStreamMeter.OpenConnection(0, "no connection parameters", out meterId))
+                {
+                    activityLog.Print(string.Format("Connection established, meter ID is {0}", meterId));
+                }
+                else
+                {
+                    activityLog.Print("Failed to establish a connection");
+                }
+            }
+        }
+
+        private void closeConnectionButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                if (dataStreamMeter.CloseConnection(0))
+                {
+                    framesListView.Items.Clear();
+                    activityLog.Print("Connection closed");
+                }
+                else
+                {
+                    activityLog.Print("Failed to close the connection");
+                }
+            }
+        }
+
+        private void DemoMainWnd_FormClosing(object sender, FormClosingEventArgs e)
+        {
+            if (dataStreamMeter == null)
+            {
+                dataStreamMeter.Shutdown();
+            }
+        }
+
+        private void getStateButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                int state;
+                string parameter;
+                if (dataStreamMeter.GetState(0, out state, out parameter))
+                {
+                    activityLog.Print(string.Format("Water meter state is {0} / {1}", state, parameter));
+                }
+                else
+                {
+                    activityLog.Print("Failed to obtain the water meter state");
+                }
+            }
+        }
+
+        private void setStateButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                GetStateDlg dlg = new GetStateDlg();
+                if (dlg.ShowDialog() == DialogResult.OK)
+                {
+                    if (dataStreamMeter.SetState(0, dlg.State, dlg.Parameter))
+                    {
+                        activityLog.Print(string.Format("Water meter state set to {0} / {1}", dlg.State, dlg.Parameter));
+                    }
+                    else
+                    {
+                        activityLog.Print(string.Format("Failed to set the water meter state to {0} / {1}", dlg.State, dlg.Parameter));
+                    }
+                }
+            }
+        }
+
+        private void startMeasurementButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                if (dataStreamMeter.StartMeasurement(0))
+                {
+                    framesListView.Items.Clear();
+                    activityLog.Print(string.Format("Measurement started"));
+                }
+                else
+                {
+                    activityLog.Print("Failed to start a measurement");
+                }
+            }
+        }
+
+        private void stopMeasurementButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                if (dataStreamMeter.StopMeasurement(0, out storedFramesCount))
+                {
+                    framesListView.Items.Clear();
+                    activityLog.Print(string.Format("Measurement sopped, {0} frames acquired", storedFramesCount));
+                }
+                else
+                {
+                    activityLog.Print("Failed to stop the measurement");
+                }
+            }
+        }
+
+        private void getFramesButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                GetFrameBoundariesDlg dlg = new GetFrameBoundariesDlg("Enter frames range boundaries", 0, storedFramesCount - 1);
+                if (dlg.ShowDialog() != DialogResult.OK) return;
+                DataFrame[] frames = dataStreamMeter.GetFrames(0, dlg.From, Convert.ToInt32(dlg.To - dlg.From + 1));
+                {
+                    foreach (var frame in frames)
+                    {
+                        if (frame != null) framesListView.Items.Add(GetListViewItem(frame));
+                    }
+                }
+            }
+        }
+
+        private void getIDButton_Click(object sender, EventArgs e)
+        {
+            if (dataStreamMeter == null)
+                ShowNoMeterInterfaceMessage();
+            else
+            {
+                GetDblValueDlg dlg = new GetDblValueDlg("Enter time in seconds");
+                if (dlg.ShowDialog() == DialogResult.OK)
+                {
+                    Int64 id = dataStreamMeter.GetID(0, dlg.DblValue);
+                    activityLog.Print(string.Format("GetID({0}) returned {1}", dlg.DblValue, id));
+                }
+            }
+        }
+
+        ListViewItem GetListViewItem(DataFrame frame)
+        {
+            ListViewItem lvi = new ListViewItem(frame.ID.ToString());
+            lvi.SubItems.Add(frame.Time.ToString());
+            lvi.SubItems.Add(frame.Volume.ToString());
+            StringBuilder sb = new StringBuilder();
+            foreach (var quantity in frame.Quantity)
+            {
+                sb.Append(quantity.ToString());
+                sb.Append("  ");
+            }
+            lvi.SubItems.Add(sb.ToString());
+            lvi.Tag = frame;
+            return lvi;
+        }
+    }
+}

DataStreamInterfaceTest/GetDblValueDlg.Designer.cs

@@ -0,0 +1,88 @@
+namespace DataStreamInterfaceTest
+{
+    partial class GetDblValueDlg
+    {
+        /// <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 Windows Form 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.valueTextBox = new System.Windows.Forms.TextBox();
+            this.okButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // valueTextBox
+            // 
+            this.valueTextBox.Location = new System.Drawing.Point(35, 20);
+            this.valueTextBox.Name = "valueTextBox";
+            this.valueTextBox.Size = new System.Drawing.Size(94, 20);
+            this.valueTextBox.TabIndex = 0;
+            // 
+            // okButton
+            // 
+            this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.okButton.Location = new System.Drawing.Point(216, 16);
+            this.okButton.Name = "okButton";
+            this.okButton.Size = new System.Drawing.Size(75, 29);
+            this.okButton.TabIndex = 1;
+            this.okButton.Text = "OK";
+            this.okButton.UseVisualStyleBackColor = true;
+            this.okButton.Click += new System.EventHandler(this.okButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cancelButton.Location = new System.Drawing.Point(306, 16);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(75, 29);
+            this.cancelButton.TabIndex = 2;
+            this.cancelButton.Text = "Cancel";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            // 
+            // GetFlowDlg
+            // 
+            this.AcceptButton = this.okButton;
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.CancelButton = this.cancelButton;
+            this.ClientSize = new System.Drawing.Size(396, 58);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.okButton);
+            this.Controls.Add(this.valueTextBox);
+            this.Name = "GetFlowDlg";
+            this.Text = "Enter flow";
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox valueTextBox;
+        private System.Windows.Forms.Button okButton;
+        private System.Windows.Forms.Button cancelButton;
+    }
+}

DataStreamInterfaceTest/GetDblValueDlg.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Globalization;
+using System.Windows.Forms;
+
+namespace DataStreamInterfaceTest
+{
+    public partial class GetDblValueDlg : Form
+    {
+        public double DblValue;
+
+        double lowerLimit;
+        double upperLimit;
+
+
+        public GetDblValueDlg()
+            : this("Enter flow in [m3/h] please")
+        {
+        }
+
+        public GetDblValueDlg(string title)
+            : this(title, 0, 100.0)
+        {
+        }
+
+        public GetDblValueDlg(string title, double lowerLimit, double upperLimit)
+        {
+            InitializeComponent();
+            this.Text = title;
+            this.lowerLimit = lowerLimit;
+            this.upperLimit = upperLimit;
+        }
+
+
+        private void okButton_Click(object sender, EventArgs e)
+        {
+            double val;
+            if (TryParseUDouble(valueTextBox.Text, out val))
+            {
+                DblValue = val;
+                DialogResult = DialogResult.OK;
+                Close();
+            }
+            else
+            {
+                MessageBox.Show("Invalid value");
+                DialogResult = DialogResult.None;
+            }
+        }
+
+        /// <summary>
+        /// Parse an unsigned double number
+        /// </summary>
+        bool TryParseUDouble(string text, out double result)
+        {
+            return double.TryParse(text, NumberStyles.AllowDecimalPoint, CultureInfo.CurrentCulture, out result) ||
+                   double.TryParse(text, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out result);
+        }
+    }
+}

DataStreamInterfaceTest/GetFrameBoundariesDlg.Designer.cs

@@ -0,0 +1,126 @@
+namespace DataStreamInterfaceTest
+{
+    partial class GetFrameBoundariesDlg
+    {
+        /// <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 Windows Form 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.fromTextBox = new System.Windows.Forms.TextBox();
+            this.okButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.toTextBox = new System.Windows.Forms.TextBox();
+            this.fromLabel = new System.Windows.Forms.Label();
+            this.toLabel = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // fromTextBox
+            // 
+            this.fromTextBox.Location = new System.Drawing.Point(89, 16);
+            this.fromTextBox.Name = "fromTextBox";
+            this.fromTextBox.Size = new System.Drawing.Size(100, 20);
+            this.fromTextBox.TabIndex = 0;
+            // 
+            // okButton
+            // 
+            this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.okButton.Location = new System.Drawing.Point(225, 24);
+            this.okButton.Name = "okButton";
+            this.okButton.Size = new System.Drawing.Size(75, 36);
+            this.okButton.TabIndex = 1;
+            this.okButton.Text = "OK";
+            this.okButton.UseVisualStyleBackColor = true;
+            this.okButton.Click += new System.EventHandler(this.okButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cancelButton.Location = new System.Drawing.Point(316, 24);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(75, 36);
+            this.cancelButton.TabIndex = 2;
+            this.cancelButton.Text = "Cancel";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            // 
+            // toTextBox
+            // 
+            this.toTextBox.Location = new System.Drawing.Point(89, 46);
+            this.toTextBox.Name = "toTextBox";
+            this.toTextBox.Size = new System.Drawing.Size(100, 20);
+            this.toTextBox.TabIndex = 3;
+            // 
+            // fromLabel
+            // 
+            this.fromLabel.AutoSize = true;
+            this.fromLabel.Location = new System.Drawing.Point(12, 19);
+            this.fromLabel.Name = "fromLabel";
+            this.fromLabel.Size = new System.Drawing.Size(30, 13);
+            this.fromLabel.TabIndex = 4;
+            this.fromLabel.Text = "From";
+            // 
+            // toLabel
+            // 
+            this.toLabel.AutoSize = true;
+            this.toLabel.Location = new System.Drawing.Point(12, 49);
+            this.toLabel.Name = "toLabel";
+            this.toLabel.Size = new System.Drawing.Size(20, 13);
+            this.toLabel.TabIndex = 5;
+            this.toLabel.Text = "To";
+            // 
+            // GetFrameBoundariesDlg
+            // 
+            this.AcceptButton = this.okButton;
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.AutoSize = true;
+            this.CancelButton = this.cancelButton;
+            this.ClientSize = new System.Drawing.Size(419, 79);
+            this.ControlBox = false;
+            this.Controls.Add(this.toLabel);
+            this.Controls.Add(this.fromLabel);
+            this.Controls.Add(this.toTextBox);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.okButton);
+            this.Controls.Add(this.fromTextBox);
+            this.Name = "GetFrameBoundariesDlg";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.Text = "Enter frames range boundaries";
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox fromTextBox;
+        private System.Windows.Forms.Button okButton;
+        private System.Windows.Forms.Button cancelButton;
+        private System.Windows.Forms.TextBox toTextBox;
+        private System.Windows.Forms.Label fromLabel;
+        private System.Windows.Forms.Label toLabel;
+    }
+}

DataStreamInterfaceTest/GetFrameBoundariesDlg.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Windows.Forms;
+
+namespace DataStreamInterfaceTest
+{
+    public partial class GetFrameBoundariesDlg : Form
+    {
+        /// <summary>
+        /// Integer number entered in this form
+        /// </summary>
+        public Int64 From;
+        public Int64 To;
+
+        Int64 lowerLimit;
+        Int64 upperLimit;
+
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        public GetFrameBoundariesDlg()
+            : this("Enter state please")
+        {
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        public GetFrameBoundariesDlg(string title)
+            : this(title, Int64.MinValue, Int64.MaxValue)
+        {
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title, limits and non-empty initial value.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="lowerLimit">Lower limit</param>
+        /// <param name="upperLimit">Upper limit</param>
+        /// <param name="initialValue">Initial value</param>
+        public GetFrameBoundariesDlg(string title, Int64 lowerLimit, Int64 upperLimit, int initialValue)
+            : this(title, lowerLimit, upperLimit)
+        {
+            fromTextBox.Text = initialValue.ToString();
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title and lower/upper limits.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="lowerLimit">Lower limit</param>
+        /// <param name="upperLimit">Upper limit</param>
+        public GetFrameBoundariesDlg(string title, Int64 lowerLimit, Int64 upperLimit)
+        {
+            InitializeComponent();
+            this.Text = title;
+            this.lowerLimit = lowerLimit;
+            this.upperLimit = upperLimit;
+        }
+
+
+        /// <summary>
+        /// OK button handler that verifies validity of the entered value.
+        /// </summary>
+        private void okButton_Click(object sender, EventArgs e)
+        {
+            Int64 from;
+            Int64 to;
+            if (Int64.TryParse(fromTextBox.Text, out from) && from >= lowerLimit && from <= upperLimit &&
+                Int64.TryParse(toTextBox.Text, out to) && to >= lowerLimit && to <= upperLimit &&
+                to >= from && to < from + Int32.MaxValue)
+            {
+                From = from;
+                To = to;
+                DialogResult = DialogResult.OK;
+            }
+            else
+            {
+                string message = (lowerLimit != 0 || upperLimit != Int32.MaxValue)
+                               ? string.Format("Invalid boundaries ({0}..{1})", lowerLimit, upperLimit)
+                               : "Invalid boundaries";
+                MessageBox.Show(message);
+                DialogResult = DialogResult.None;   /// Prevent closing this window
+            }
+        }
+    }
+}

DataStreamInterfaceTest/GetFrameBoundariesDlg.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>

DataStreamInterfaceTest/GetIntegerNumberDlg.Designer.cs

@@ -0,0 +1,90 @@
+namespace DataStreamInterfaceTest
+{
+    partial class GetIntegerNumberDlg
+    {
+        /// <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 Windows Form 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.numberTextBox = new System.Windows.Forms.TextBox();
+            this.okButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // numberTextBox
+            // 
+            this.numberTextBox.Location = new System.Drawing.Point(36, 16);
+            this.numberTextBox.Name = "numberTextBox";
+            this.numberTextBox.Size = new System.Drawing.Size(100, 20);
+            this.numberTextBox.TabIndex = 0;
+            // 
+            // okButton
+            // 
+            this.okButton.Location = new System.Drawing.Point(174, 7);
+            this.okButton.Name = "okButton";
+            this.okButton.Size = new System.Drawing.Size(75, 36);
+            this.okButton.TabIndex = 1;
+            this.okButton.Text = "OK";
+            this.okButton.UseVisualStyleBackColor = true;
+            this.okButton.Click += new System.EventHandler(this.okButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cancelButton.Location = new System.Drawing.Point(265, 7);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(75, 36);
+            this.cancelButton.TabIndex = 2;
+            this.cancelButton.Text = "Cancel";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            // 
+            // GetIntegerNumberDlg
+            // 
+            this.AcceptButton = this.okButton;
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.AutoSize = true;
+            this.CancelButton = this.cancelButton;
+            this.ClientSize = new System.Drawing.Size(363, 50);
+            this.ControlBox = false;
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.okButton);
+            this.Controls.Add(this.numberTextBox);
+            this.Name = "GetIntegerNumberDlg";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.Text = "Enter integer number please";
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox numberTextBox;
+        private System.Windows.Forms.Button okButton;
+        private System.Windows.Forms.Button cancelButton;
+    }
+}

DataStreamInterfaceTest/GetIntegerNumberDlg.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Windows.Forms;
+
+namespace DataStreamInterfaceTest
+{
+    public partial class GetIntegerNumberDlg : Form
+    {
+        /// <summary>
+        /// Integer number entered in this form
+        /// </summary>
+        public int Number;
+        
+        int lowerLimit;
+        int upperLimit;
+
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        public GetIntegerNumberDlg()
+            : this("Enter integer number please")
+        {
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        public GetIntegerNumberDlg(string title)
+            : this(title, Int32.MinValue, Int32.MaxValue)
+        {
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title, limits and non-empty initial value.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="lowerLimit">Lower limit</param>
+        /// <param name="upperLimit">Upper limit</param>
+        /// <param name="initialValue">Initial value</param>
+        public GetIntegerNumberDlg(string title, int lowerLimit, int upperLimit, int initialValue)
+            : this(title, lowerLimit, upperLimit)
+        {
+            numberTextBox.Text = initialValue.ToString();
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title and lower/upper limits.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="lowerLimit">Lower limit</param>
+        /// <param name="upperLimit">Upper limit</param>
+        public GetIntegerNumberDlg(string title, int lowerLimit, int upperLimit)
+        {
+            InitializeComponent();
+            this.Text = title;
+            this.lowerLimit = lowerLimit;
+            this.upperLimit = upperLimit;
+        }
+
+
+        /// <summary>
+        /// OK button handler that verifies validity of the entered value.
+        /// </summary>
+        private void okButton_Click(object sender, EventArgs e)
+        {
+            int number;
+            if (int.TryParse(numberTextBox.Text, out number) && number >= lowerLimit && number <= upperLimit)
+            {
+                Number = number;
+                DialogResult = DialogResult.OK;
+            }
+            else
+            {
+                string message = (lowerLimit != Int32.MinValue || upperLimit != Int32.MaxValue)
+                               ? string.Format("Invalid integer number ({0}..{1})", lowerLimit, upperLimit)
+                               : "Invalid integer number";
+                MessageBox.Show(message);
+                DialogResult = DialogResult.None;   /// Prevent closing this window
+            }
+        }
+    }
+}

DataStreamInterfaceTest/GetIntegerNumberDlg.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>

DataStreamInterfaceTest/GetStateDlg.Designer.cs

@@ -0,0 +1,126 @@
+namespace DataStreamInterfaceTest
+{
+    partial class GetStateDlg
+    {
+        /// <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 Windows Form 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.stateTextBox = new System.Windows.Forms.TextBox();
+            this.okButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.parameterTextBox = new System.Windows.Forms.TextBox();
+            this.stateLabel = new System.Windows.Forms.Label();
+            this.parameterLabel = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // stateTextBox
+            // 
+            this.stateTextBox.Location = new System.Drawing.Point(89, 16);
+            this.stateTextBox.Name = "stateTextBox";
+            this.stateTextBox.Size = new System.Drawing.Size(100, 20);
+            this.stateTextBox.TabIndex = 0;
+            // 
+            // okButton
+            // 
+            this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.okButton.Location = new System.Drawing.Point(225, 24);
+            this.okButton.Name = "okButton";
+            this.okButton.Size = new System.Drawing.Size(75, 36);
+            this.okButton.TabIndex = 1;
+            this.okButton.Text = "OK";
+            this.okButton.UseVisualStyleBackColor = true;
+            this.okButton.Click += new System.EventHandler(this.okButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cancelButton.Location = new System.Drawing.Point(316, 24);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(75, 36);
+            this.cancelButton.TabIndex = 2;
+            this.cancelButton.Text = "Cancel";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            // 
+            // parameterTextBox
+            // 
+            this.parameterTextBox.Location = new System.Drawing.Point(89, 46);
+            this.parameterTextBox.Name = "parameterTextBox";
+            this.parameterTextBox.Size = new System.Drawing.Size(100, 20);
+            this.parameterTextBox.TabIndex = 3;
+            // 
+            // stateLabel
+            // 
+            this.stateLabel.AutoSize = true;
+            this.stateLabel.Location = new System.Drawing.Point(12, 19);
+            this.stateLabel.Name = "stateLabel";
+            this.stateLabel.Size = new System.Drawing.Size(32, 13);
+            this.stateLabel.TabIndex = 4;
+            this.stateLabel.Text = "State";
+            // 
+            // parameterLabel
+            // 
+            this.parameterLabel.AutoSize = true;
+            this.parameterLabel.Location = new System.Drawing.Point(12, 49);
+            this.parameterLabel.Name = "parameterLabel";
+            this.parameterLabel.Size = new System.Drawing.Size(55, 13);
+            this.parameterLabel.TabIndex = 5;
+            this.parameterLabel.Text = "Parameter";
+            // 
+            // GetStateDlg
+            // 
+            this.AcceptButton = this.okButton;
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.AutoSize = true;
+            this.CancelButton = this.cancelButton;
+            this.ClientSize = new System.Drawing.Size(419, 79);
+            this.ControlBox = false;
+            this.Controls.Add(this.parameterLabel);
+            this.Controls.Add(this.stateLabel);
+            this.Controls.Add(this.parameterTextBox);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.okButton);
+            this.Controls.Add(this.stateTextBox);
+            this.Name = "GetStateDlg";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.Text = "Enter state please";
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox stateTextBox;
+        private System.Windows.Forms.Button okButton;
+        private System.Windows.Forms.Button cancelButton;
+        private System.Windows.Forms.TextBox parameterTextBox;
+        private System.Windows.Forms.Label stateLabel;
+        private System.Windows.Forms.Label parameterLabel;
+    }
+}

DataStreamInterfaceTest/GetStateDlg.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Windows.Forms;
+
+namespace DataStreamInterfaceTest
+{
+    public partial class GetStateDlg : Form
+    {
+        /// <summary>
+        /// Integer number entered in this form
+        /// </summary>
+        public int State;
+        public string Parameter;
+        
+        int lowerLimit;
+        int upperLimit;
+
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        public GetStateDlg()
+            : this("Enter state please")
+        {
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        public GetStateDlg(string title)
+            : this(title, Int32.MinValue, Int32.MaxValue)
+        {
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title, limits and non-empty initial value.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="lowerLimit">Lower limit</param>
+        /// <param name="upperLimit">Upper limit</param>
+        /// <param name="initialValue">Initial value</param>
+        public GetStateDlg(string title, int lowerLimit, int upperLimit, int initialValue)
+            : this(title, lowerLimit, upperLimit)
+        {
+            stateTextBox.Text = initialValue.ToString();
+        }
+
+        /// <summary>
+        /// Constructor with a custom window title and lower/upper limits.
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="lowerLimit">Lower limit</param>
+        /// <param name="upperLimit">Upper limit</param>
+        public GetStateDlg(string title, int lowerLimit, int upperLimit)
+        {
+            InitializeComponent();
+            this.Text = title;
+            this.lowerLimit = lowerLimit;
+            this.upperLimit = upperLimit;
+        }
+
+
+        /// <summary>
+        /// OK button handler that verifies validity of the entered value.
+        /// </summary>
+        private void okButton_Click(object sender, EventArgs e)
+        {
+            int number;
+            if (int.TryParse(stateTextBox.Text, out number) && number >= lowerLimit && number <= upperLimit)
+            {
+                State = number;
+                Parameter = parameterTextBox.Text;
+                DialogResult = DialogResult.OK;
+            }
+            else
+            {
+                string message = (lowerLimit != Int32.MinValue || upperLimit != Int32.MaxValue)
+                               ? string.Format("Invalid state ({0}..{1})", lowerLimit, upperLimit)
+                               : "Invalid state";
+                MessageBox.Show(message);
+                DialogResult = DialogResult.None;   /// Prevent closing this window
+            }
+        }
+    }
+}

DataStreamInterfaceTest/GetStateDlg.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>

DataStreamInterfaceTest/LviIDComparer.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections;
+using System.Windows.Forms;
+
+namespace DataStreamInterfaceTest
+{
+    public class LviIDComparer : IComparer
+    {
+        int column;
+        SortOrder order;
+
+        public LviIDComparer()
+        {
+            column = 0;
+            order = SortOrder.Ascending;
+        }
+
+        public LviIDComparer(int column, SortOrder order)
+        {
+            this.column = column;
+            this.order = order;
+        }
+
+        public int Compare(object x, object y)
+        {
+            Int64 valX = Int64.Parse(((ListViewItem)x).SubItems[column].Text);
+            Int64 valY = Int64.Parse(((ListViewItem)y).SubItems[column].Text);
+
+            if (order == SortOrder.Ascending)
+            {
+                return valX > valY ? 1 : valX == valY ? 0 : -1;
+            }
+            else
+            {
+                return valX < valY ? 1 : valX == valY ? 0 : -1;
+            }
+        }
+    }
+}

DataStreamInterfaceTest/Program.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+using System.ComponentModel.Composition;
+using System.ComponentModel.Composition.Hosting;
+using System.Windows.Forms;
+using DataStreamInterface;
+
+namespace DataStreamInterfaceTest
+{
+    class Program
+    {
+#if DEBUG
+        const string CatalogDir = "..\\..\\..\\DataStreamMeter\\bin\\Debug";
+#else
+        const string CatalogDir = "..\\..\\..\\DataStreamMeter\\bin\\Release";
+#endif
+
+        [Import(typeof(IDataStreamMeter))]
+        IDataStreamMeter dataStreamMeter;
+
+        private Program()
+        {
+            Console.WriteLine("Components found:");
+            foreach (var file in Directory.EnumerateFiles(CatalogDir))
+            {
+                Console.WriteLine(file);
+            }
+
+            try
+            {
+                var catalog = new AggregateCatalog();
+                catalog.Catalogs.Add(new AssemblyCatalog(typeof(DataStreamInterface.IDataStreamMeter).Assembly));
+                catalog.Catalogs.Add(new DirectoryCatalog(CatalogDir));
+                (new CompositionContainer(catalog)).ComposeParts(this);
+            }
+            catch (CompositionException compositionException)
+            {
+                Console.WriteLine(compositionException.ToString());
+            }
+        }
+
+        /// <summary>
+        /// The main entry point for the application.
+        /// </summary>
+        [STAThread]
+        static void Main()
+        {
+            Program p = new Program();
+
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            Application.Run(new DemoMainWnd(p.dataStreamMeter));
+        }
+    }
+}

DataStreamInterfaceTest/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DataStreamInterfaceTest")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DataStreamInterfaceTest")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("429fdea9-ec3a-47d8-88b3-5df11de8b4c8")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

DataStreamInterfaceTest/Properties/Resources.Designer.cs

@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace DataStreamInterfaceTest.Properties
+{
+
+
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources()
+        {
+        }
+
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if ((resourceMan == null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DataStreamMainDemo.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+    }
+}

DataStreamInterfaceTest/Properties/Resources.resx

@@ -0,0 +1,117 @@
+<?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.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: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" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+            </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" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </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=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

DataStreamInterfaceTest/Properties/Settings.Designer.cs

@@ -0,0 +1,30 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace DataStreamInterfaceTest.Properties
+{
+
+
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+    {
+
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+        public static Settings Default
+        {
+            get
+            {
+                return defaultInstance;
+            }
+        }
+    }
+}

DataStreamInterfaceTest/Properties/Settings.settings

@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>

DataStreamMeter/DataStreamMeter.csproj

@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{E6925701-57A6-4167-B5C4-BF670F1DE310}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>DataStreamMeter</RootNamespace>
+    <AssemblyName>DataStreamMeter</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.ComponentModel.Composition" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="GetDblValueDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="GetDblValueDlg.Designer.cs">
+      <DependentUpon>GetDblValueDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="MeterDataEventArgs.cs" />
+    <Compile Include="MeterSimulationDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="MeterSimulationDlg.Designer.cs">
+      <DependentUpon>MeterSimulationDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="MeterSimulation.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Sample.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DataStreamInterface\DataStreamInterface.csproj">
+      <Project>{7ebeea14-91c4-48d7-af0a-7a4bc3ff9a28}</Project>
+      <Name>DataStreamInterface</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="GetDblValueDlg.resx">
+      <DependentUpon>GetDblValueDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="MeterSimulationDlg.resx">
+      <DependentUpon>MeterSimulationDlg.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

DataStreamMeter/GetDblValueDlg.Designer.cs

@@ -0,0 +1,88 @@
+namespace DataStreamMeter
+{
+    partial class GetDblValueDlg
+    {
+        /// <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 Windows Form 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.valueTextBox = new System.Windows.Forms.TextBox();
+            this.okButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // valueTextBox
+            // 
+            this.valueTextBox.Location = new System.Drawing.Point(35, 20);
+            this.valueTextBox.Name = "valueTextBox";
+            this.valueTextBox.Size = new System.Drawing.Size(94, 20);
+            this.valueTextBox.TabIndex = 0;
+            // 
+            // okButton
+            // 
+            this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.okButton.Location = new System.Drawing.Point(216, 16);
+            this.okButton.Name = "okButton";
+            this.okButton.Size = new System.Drawing.Size(75, 29);
+            this.okButton.TabIndex = 1;
+            this.okButton.Text = "OK";
+            this.okButton.UseVisualStyleBackColor = true;
+            this.okButton.Click += new System.EventHandler(this.okButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cancelButton.Location = new System.Drawing.Point(306, 16);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(75, 29);
+            this.cancelButton.TabIndex = 2;
+            this.cancelButton.Text = "Cancel";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            // 
+            // GetFlowDlg
+            // 
+            this.AcceptButton = this.okButton;
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.CancelButton = this.cancelButton;
+            this.ClientSize = new System.Drawing.Size(396, 58);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.okButton);
+            this.Controls.Add(this.valueTextBox);
+            this.Name = "GetFlowDlg";
+            this.Text = "Enter flow";
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox valueTextBox;
+        private System.Windows.Forms.Button okButton;
+        private System.Windows.Forms.Button cancelButton;
+    }
+}

DataStreamMeter/GetDblValueDlg.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Globalization;
+using System.Windows.Forms;
+
+namespace DataStreamMeter
+{
+    public partial class GetDblValueDlg : Form
+    {
+        public double DblValue;
+
+        double lowerLimit;
+        double upperLimit;
+
+
+        public GetDblValueDlg()
+            : this("Enter flow in [m3/h] please")
+        {
+        }
+
+        public GetDblValueDlg(string title)
+            : this(title, 0, 100.0)
+        {
+        }
+
+        public GetDblValueDlg(string title, double lowerLimit, double upperLimit)
+        {
+            InitializeComponent();
+            this.Text = title;
+            this.lowerLimit = lowerLimit;
+            this.upperLimit = upperLimit;
+        }
+
+
+        private void okButton_Click(object sender, EventArgs e)
+        {
+            double val;
+            if (TryParseUDouble(valueTextBox.Text, out val))
+            {
+                DblValue = val;
+                DialogResult = DialogResult.OK;
+                Close();
+            }
+            else
+            {
+                MessageBox.Show("Invalid value");
+                DialogResult = DialogResult.None;
+            }
+        }
+
+        /// <summary>
+        /// Parse an unsigned double number
+        /// </summary>
+        bool TryParseUDouble(string text, out double result)
+        {
+            return double.TryParse(text, NumberStyles.AllowDecimalPoint, CultureInfo.CurrentCulture, out result) ||
+                   double.TryParse(text, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out result);
+        }
+    }
+}

DataStreamMeter/GetDblValueDlg.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>

DataStreamMeter/MeterDataEventArgs.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace DataStreamMeter
+{
+    public class MeterDataEventArgs : EventArgs
+    {
+        public State State;
+        public double Time;
+        public double Volume;
+        public double Flow;
+
+        public MeterDataEventArgs(State state, double time, double volume, double flow)
+        {
+            State = state;
+            Time = time;
+            Volume = volume;
+            Flow = flow;
+        }
+    }
+}

DataStreamMeter/MeterSimulation.cs

@@ -0,0 +1,351 @@
+using System;
+using System.ComponentModel.Composition;
+using DataStreamInterface;
+
+namespace DataStreamMeter
+{
+    [Export(typeof(IDataStreamMeter))]
+    public class MeterSimulation : IDataStreamMeter
+    {
+        MeterSimulationDlg modelessDlg;
+
+        /// Water meter specification
+        public readonly string MeterID = "3141592653";
+        public const Unit TimeUnits = Unit.s;           /// Unit.s, Unit.ms, ...
+        public const Unit VolumeUnits = Unit.l;         /// Unit.l, Unit.USgal, ...
+        public const Unit FlowUnits = Unit.m3ph;        /// Unit.m3ph, Unit.USgalps, Unit.cfs, ...
+        public const double SamplingPeriodSec = 0.125;  /// Sampling period in seconds (here 125 ms, 8 Hz)
+        public readonly double SamplingPeriod;
+
+
+        public const Int64 MaxSamplesCount = 40000;    /// Maximal test time is SamplingPeriod * MaxSamplesCount
+        Sample[] samples = new Sample[MaxSamplesCount];
+        Int64 storedSamplesCount;
+
+
+        readonly object stateChangeAndTimerTickLock = new object();
+        public State State;
+        string connectionParameters;
+
+        /// initialTime is time when simulation started 
+        /// (lastSampleTime - initialTime).TotalSeconds is multiple of Sampling Period
+        DateTime initialTime;
+
+        /// Last user interface tick info
+        bool lastTickValid;
+        State lastTickState;
+
+        /// Values incrementally updated on each timer tick
+        double currentTime;
+        double currentVolume;
+        double currentFlow;
+        double currentFlow_m3ph;
+
+        DateTime startTimeStamp;        /// Measurement start DateTime
+        double startTime;               /// Measurement start time in seconds
+        DateTime stopTimeStamp;         /// Measurement end DateTime
+        double stopTime;                /// Measurement end time in seconds
+
+
+        public MeterSimulation()
+        {
+            modelessDlg = null;
+            State = State.Disconnected;
+            SamplingPeriod = DataStreamInterface.Units.ConvertTo(TimeUnits, SamplingPeriodSec);
+            lastTickValid = false;
+            initialTime = DateTime.Now.Date;    /// An arbitrary initial time (in this case the last midnight)
+        }
+
+        public Unit GetTimeUnits()
+        {
+            return TimeUnits;
+        }
+
+        public Unit GetVolumeUnits()
+        {
+            return VolumeUnits;
+        }
+
+        public int GetQuantitiesCount()
+        {
+            return 1;
+        }
+
+        public string GetQuantityCaption(int quantityNr)
+        {
+            if (quantityNr == 0) return "Flow";
+            return string.Empty;
+        }
+
+        public Unit GetQuantityUnits(int quantityNr)
+        {
+            if (quantityNr == 0) return FlowUnits;
+            return Unit.None;
+        }
+
+
+        public int GetMetersCount()
+        {
+            return 20;
+        }
+
+        public bool OpenConnection(int meterIx, string connectionParameters, out string meterID)
+        {
+            lock (stateChangeAndTimerTickLock)
+            {
+                if (State != State.Disconnected)
+                {
+                    /// Meter is already connected
+                    meterID = MeterID;
+                    return true;
+                }
+
+                /// Connect the meter
+                meterID = MeterID;
+                this.connectionParameters = connectionParameters;
+                lastTickValid = false;
+                State = State.Connected;
+            }
+
+            /// Open modeless form
+            modelessDlg = new MeterSimulationDlg(this, MeterID);
+            modelessDlg.Show();
+            return true;
+        }
+
+        public bool CloseConnection(int meterIx)
+        {
+            bool closeModelessDlg = false;
+
+            lock (stateChangeAndTimerTickLock)
+            {
+                if (State != State.Disconnected)
+                {
+                    State = State.Disconnected;
+                    storedSamplesCount = 0;
+                    closeModelessDlg = true;
+                }
+            }
+
+            if (closeModelessDlg)
+            {
+                if (modelessDlg != null) modelessDlg.Close();
+                modelessDlg = null;
+            }
+            return true;
+        }
+
+        public bool CloseConnectionAll()
+        {
+            return CloseConnection(0);
+        }
+
+        public bool Shutdown()
+        {
+            return true;
+        }
+
+        public bool GetState(int meterIx, out int state, out string parameter)
+        {
+            state = (int)this.State;
+            parameter = this.connectionParameters;
+            return true;
+        }
+
+        public bool SetState(int meterIx, int state, string parameter)
+        {
+            /// It's not allowed to change the satate in this demo
+            return false;
+        }
+
+        public bool SetStateAll(int state, string parameter)
+        {
+            return SetState(0, state, parameter);
+        }
+
+        public bool StartMeasurement(int meterIx = 0)
+        {
+            lock (stateChangeAndTimerTickLock)
+            {
+                if (State == State.Connected)
+                {
+                    startTimeStamp = DateTime.Now;
+                    startTime = TimeInSecondsFromDateTime(startTimeStamp, initialTime, SamplingPeriodSec);
+                    storedSamplesCount = 0;
+                    State = State.MeasurementInProgress;
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+
+        public bool StartMeasurementAll()
+        {
+            return StartMeasurement(0);
+        }
+
+        public bool StopMeasurement(int meterIx, out Int64 storedFramesCount)
+        {
+            lock (stateChangeAndTimerTickLock)
+            {
+                if (State == State.MeasurementInProgress)
+                {
+                    stopTimeStamp = DateTime.Now;
+                    stopTime = TimeInSecondsFromDateTime(stopTimeStamp, initialTime, SamplingPeriodSec);
+
+                    int newSamplesCount = Convert.ToInt32(Math.Round((stopTime - currentTime) / SamplingPeriodSec));
+                    double time = Units.ConvertTo(TimeUnits, currentTime);
+                    double volume = currentVolume;
+                    double volumeIncrement = Units.ConvertTo(VolumeUnits, currentFlow_m3ph * (SamplingPeriodSec / 3.6));
+                    for (int i = 0; i < newSamplesCount; i++)
+                    {
+                        time += SamplingPeriod;
+                        volume += volumeIncrement;
+                        if (storedSamplesCount < MaxSamplesCount)
+                        {
+                            samples[storedSamplesCount++] = new Sample(time, volume, currentFlow);
+                        }
+                    }
+
+                    State = State.Connected;
+                    storedFramesCount = storedSamplesCount;
+                    return true;
+                }
+                else
+                {
+                    storedFramesCount = 0;
+                    return false;
+                }
+            }
+        }
+
+        public bool StopMeasurementAll(out Int64[] storedFramesCount)
+        {
+            storedFramesCount = new Int64[1];
+            return StopMeasurement(0, out storedFramesCount[0]);
+        }
+
+        public void TimerTick(double flow_m3ph)
+        {
+            lock (stateChangeAndTimerTickLock)
+            {
+                double lastSampleTime = TimeInSecondsFromDateTime(DateTime.Now, initialTime, SamplingPeriodSec);
+                currentFlow_m3ph = flow_m3ph;
+                currentFlow = Units.ConvertTo(FlowUnits, flow_m3ph);
+
+                if (!lastTickValid)
+                {
+                    currentTime = lastSampleTime;
+                    currentVolume = 0;
+                    lastTickValid = true;
+                    lastTickState = State;
+                    return;
+                }
+                else
+                {
+                    int newSamplesCount = Convert.ToInt32(Math.Round((lastSampleTime - currentTime) / SamplingPeriodSec));
+                    double volumeIncrement = Units.ConvertTo(VolumeUnits, currentFlow_m3ph * (SamplingPeriodSec / 3.6));
+                    for (int i = 0; i < newSamplesCount; i++)
+                    {
+                        currentTime += SamplingPeriodSec;
+                        currentVolume += volumeIncrement;
+
+                        if (State == State.MeasurementInProgress && currentTime > startTime && storedSamplesCount < MaxSamplesCount)
+                        {
+                            samples[storedSamplesCount++] = new Sample(Units.ConvertTo(TimeUnits, currentTime), currentVolume, currentFlow);
+                        }
+                    }
+                    currentTime = lastSampleTime;   /// Rectify, prevent error propagation
+                    lastTickState = State;
+                }
+            }
+
+            modelessDlg.OnMeterdata(new MeterDataEventArgs(State, currentTime, currentVolume, currentFlow));
+        }
+
+        
+        /// <summary>
+        /// Obtain the last time instance before 'DateTime time' which is multiple of samplingPeriod-s after 'DateTime initialTime'.
+        /// </summary>
+        /// <param name="time">Time to be converted to seconds and rounded to samplingPeriod-s</param>
+        /// <param name="startTime">Initial time</param>
+        /// <param name="samplePeriod">Sampling period in seconds</param>
+        /// <returns></returns>
+        double TimeInSecondsFromDateTime(DateTime time, DateTime initialTime, double samplingPeriod)
+        {
+            TimeSpan span = time - initialTime;
+            return samplingPeriod * Math.Floor(span.TotalSeconds / samplingPeriod);
+        }
+
+
+        ///---------------------------
+        /// Datastream data exchange
+        ///---------------------------
+
+        /// <summary>
+        /// Retuns 'count' data frames starting with data frame with ID = 'id' 
+        /// </summary>
+        /// <param name="id">First frame ID</param>
+        /// <param name="count">Frames count</param>
+        /// <returns>Selected data frames</returns>
+        public DataFrame[] GetFrames(int meterIx, Int64 startID, int count)
+        {
+            DataFrame[] frames = new DataFrame[count];
+
+            if (State != State.MeasurementInProgress)
+            {
+                for (int j = 0; j < count; j++)
+                {
+                    Int64 id = startID + j;
+                    if (id < storedSamplesCount)
+                    {
+                        frames[j] = new DataFrame(id, samples[id].Time, samples[id].Volume, new double[1] { samples[id].Flow });
+                    }
+                }
+            }
+
+            return frames;
+        }
+
+        /// <summary>
+        /// Returns ID of the data frame where time equals or exceeds the specified time.
+        /// When time of the first frame (ID=0) is larger then specified time, function returns 0.
+        /// </summary>
+        /// <param name="time">Time</param>
+        /// <returns>ID of the data frame at or after the pecified time</returns>
+        public Int64 GetID(int meterIx, double time)
+        {
+            if (storedSamplesCount == 0) return -1;
+
+            Int64 lo = 0;
+            Int64 hi = storedSamplesCount - 1;
+
+            if (samples[hi].Time < time) return -1;
+
+            while (lo < hi)
+            {
+                Int64 mid = (lo + hi) / 2;
+                if (samples[mid].Time < time)
+                {
+                    lo = mid + 1;
+                }
+                else
+                {
+                    hi = mid;
+                }
+            }
+
+            return lo;
+        }
+    }
+
+    public enum State
+    {
+        Disconnected = 0,
+        Connected = 1,
+        MeasurementInProgress = 2,
+    }
+}

DataStreamMeter/MeterSimulationDlg.Designer.cs

@@ -0,0 +1,323 @@
+namespace DataStreamMeter
+{
+    partial class MeterSimulationDlg
+    {
+        /// <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 Windows Form 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.components = new System.ComponentModel.Container();
+            this.meterIDGroupBox = new System.Windows.Forms.GroupBox();
+            this.label3 = new System.Windows.Forms.Label();
+            this.label2 = new System.Windows.Forms.Label();
+            this.volumeUnitsTextBox = new System.Windows.Forms.TextBox();
+            this.timeUnitsTextBox = new System.Windows.Forms.TextBox();
+            this.label1 = new System.Windows.Forms.Label();
+            this.meterIDTextBox = new System.Windows.Forms.TextBox();
+            this.groupBox1 = new System.Windows.Forms.GroupBox();
+            this.setFlowButton = new System.Windows.Forms.Button();
+            this.flowm3phTextBox = new System.Windows.Forms.TextBox();
+            this.flowTrackBar = new System.Windows.Forms.TrackBar();
+            this.groupBox2 = new System.Windows.Forms.GroupBox();
+            this.flowTextBox = new System.Windows.Forms.TextBox();
+            this.volumeTextBox = new System.Windows.Forms.TextBox();
+            this.timeTextBox = new System.Windows.Forms.TextBox();
+            this.stateTextBox = new System.Windows.Forms.TextBox();
+            this.label8 = new System.Windows.Forms.Label();
+            this.label7 = new System.Windows.Forms.Label();
+            this.label6 = new System.Windows.Forms.Label();
+            this.label5 = new System.Windows.Forms.Label();
+            this.lastUITickTextBox = new System.Windows.Forms.TextBox();
+            this.label4 = new System.Windows.Forms.Label();
+            this.timer1 = new System.Windows.Forms.Timer(this.components);
+            this.meterIDGroupBox.SuspendLayout();
+            this.groupBox1.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flowTrackBar)).BeginInit();
+            this.groupBox2.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // meterIDGroupBox
+            // 
+            this.meterIDGroupBox.Controls.Add(this.label3);
+            this.meterIDGroupBox.Controls.Add(this.label2);
+            this.meterIDGroupBox.Controls.Add(this.volumeUnitsTextBox);
+            this.meterIDGroupBox.Controls.Add(this.timeUnitsTextBox);
+            this.meterIDGroupBox.Controls.Add(this.label1);
+            this.meterIDGroupBox.Controls.Add(this.meterIDTextBox);
+            this.meterIDGroupBox.Location = new System.Drawing.Point(12, 12);
+            this.meterIDGroupBox.Name = "meterIDGroupBox";
+            this.meterIDGroupBox.Size = new System.Drawing.Size(453, 105);
+            this.meterIDGroupBox.TabIndex = 0;
+            this.meterIDGroupBox.TabStop = false;
+            this.meterIDGroupBox.Text = "Water meter info";
+            // 
+            // label3
+            // 
+            this.label3.AutoSize = true;
+            this.label3.Location = new System.Drawing.Point(18, 76);
+            this.label3.Name = "label3";
+            this.label3.Size = new System.Drawing.Size(67, 13);
+            this.label3.TabIndex = 5;
+            this.label3.Text = "Volume units";
+            // 
+            // label2
+            // 
+            this.label2.AutoSize = true;
+            this.label2.Location = new System.Drawing.Point(18, 50);
+            this.label2.Name = "label2";
+            this.label2.Size = new System.Drawing.Size(55, 13);
+            this.label2.TabIndex = 4;
+            this.label2.Text = "Time units";
+            // 
+            // volumeUnitsTextBox
+            // 
+            this.volumeUnitsTextBox.Enabled = false;
+            this.volumeUnitsTextBox.Location = new System.Drawing.Point(122, 73);
+            this.volumeUnitsTextBox.Name = "volumeUnitsTextBox";
+            this.volumeUnitsTextBox.Size = new System.Drawing.Size(52, 20);
+            this.volumeUnitsTextBox.TabIndex = 3;
+            // 
+            // timeUnitsTextBox
+            // 
+            this.timeUnitsTextBox.Enabled = false;
+            this.timeUnitsTextBox.Location = new System.Drawing.Point(122, 47);
+            this.timeUnitsTextBox.Name = "timeUnitsTextBox";
+            this.timeUnitsTextBox.Size = new System.Drawing.Size(52, 20);
+            this.timeUnitsTextBox.TabIndex = 2;
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(18, 24);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(73, 13);
+            this.label1.TabIndex = 1;
+            this.label1.Text = "Meter ID (s/n)";
+            // 
+            // meterIDTextBox
+            // 
+            this.meterIDTextBox.Enabled = false;
+            this.meterIDTextBox.Location = new System.Drawing.Point(122, 21);
+            this.meterIDTextBox.Name = "meterIDTextBox";
+            this.meterIDTextBox.Size = new System.Drawing.Size(145, 20);
+            this.meterIDTextBox.TabIndex = 0;
+            // 
+            // groupBox1
+            // 
+            this.groupBox1.Controls.Add(this.setFlowButton);
+            this.groupBox1.Controls.Add(this.flowm3phTextBox);
+            this.groupBox1.Controls.Add(this.flowTrackBar);
+            this.groupBox1.Location = new System.Drawing.Point(12, 123);
+            this.groupBox1.Name = "groupBox1";
+            this.groupBox1.Size = new System.Drawing.Size(453, 96);
+            this.groupBox1.TabIndex = 1;
+            this.groupBox1.TabStop = false;
+            this.groupBox1.Text = "Flow";
+            // 
+            // setFlowButton
+            // 
+            this.setFlowButton.Location = new System.Drawing.Point(289, 17);
+            this.setFlowButton.Name = "setFlowButton";
+            this.setFlowButton.Size = new System.Drawing.Size(75, 23);
+            this.setFlowButton.TabIndex = 4;
+            this.setFlowButton.Text = "Set value";
+            this.setFlowButton.UseVisualStyleBackColor = true;
+            this.setFlowButton.Click += new System.EventHandler(this.setFlowButton_Click);
+            // 
+            // flowm3phTextBox
+            // 
+            this.flowm3phTextBox.Enabled = false;
+            this.flowm3phTextBox.Location = new System.Drawing.Point(122, 19);
+            this.flowm3phTextBox.Name = "flowm3phTextBox";
+            this.flowm3phTextBox.Size = new System.Drawing.Size(145, 20);
+            this.flowm3phTextBox.TabIndex = 3;
+            // 
+            // flowTrackBar
+            // 
+            this.flowTrackBar.LargeChange = 1;
+            this.flowTrackBar.Location = new System.Drawing.Point(0, 43);
+            this.flowTrackBar.Maximum = 25;
+            this.flowTrackBar.Name = "flowTrackBar";
+            this.flowTrackBar.Size = new System.Drawing.Size(447, 45);
+            this.flowTrackBar.TabIndex = 2;
+            this.flowTrackBar.Scroll += new System.EventHandler(this.flowTrackBar_Scroll);
+            // 
+            // groupBox2
+            // 
+            this.groupBox2.Controls.Add(this.flowTextBox);
+            this.groupBox2.Controls.Add(this.volumeTextBox);
+            this.groupBox2.Controls.Add(this.timeTextBox);
+            this.groupBox2.Controls.Add(this.stateTextBox);
+            this.groupBox2.Controls.Add(this.label8);
+            this.groupBox2.Controls.Add(this.label7);
+            this.groupBox2.Controls.Add(this.label6);
+            this.groupBox2.Controls.Add(this.label5);
+            this.groupBox2.Controls.Add(this.lastUITickTextBox);
+            this.groupBox2.Controls.Add(this.label4);
+            this.groupBox2.Location = new System.Drawing.Point(12, 225);
+            this.groupBox2.Name = "groupBox2";
+            this.groupBox2.Size = new System.Drawing.Size(453, 150);
+            this.groupBox2.TabIndex = 2;
+            this.groupBox2.TabStop = false;
+            this.groupBox2.Text = "State";
+            // 
+            // flowTextBox
+            // 
+            this.flowTextBox.Enabled = false;
+            this.flowTextBox.Location = new System.Drawing.Point(122, 121);
+            this.flowTextBox.Name = "flowTextBox";
+            this.flowTextBox.Size = new System.Drawing.Size(99, 20);
+            this.flowTextBox.TabIndex = 9;
+            // 
+            // volumeTextBox
+            // 
+            this.volumeTextBox.Enabled = false;
+            this.volumeTextBox.Location = new System.Drawing.Point(122, 95);
+            this.volumeTextBox.Name = "volumeTextBox";
+            this.volumeTextBox.Size = new System.Drawing.Size(99, 20);
+            this.volumeTextBox.TabIndex = 8;
+            // 
+            // timeTextBox
+            // 
+            this.timeTextBox.Enabled = false;
+            this.timeTextBox.Location = new System.Drawing.Point(122, 68);
+            this.timeTextBox.Name = "timeTextBox";
+            this.timeTextBox.Size = new System.Drawing.Size(99, 20);
+            this.timeTextBox.TabIndex = 7;
+            // 
+            // stateTextBox
+            // 
+            this.stateTextBox.Enabled = false;
+            this.stateTextBox.Location = new System.Drawing.Point(122, 42);
+            this.stateTextBox.Name = "stateTextBox";
+            this.stateTextBox.Size = new System.Drawing.Size(99, 20);
+            this.stateTextBox.TabIndex = 6;
+            // 
+            // label8
+            // 
+            this.label8.AutoSize = true;
+            this.label8.Location = new System.Drawing.Point(18, 124);
+            this.label8.Name = "label8";
+            this.label8.Size = new System.Drawing.Size(29, 13);
+            this.label8.TabIndex = 5;
+            this.label8.Text = "Flow";
+            // 
+            // label7
+            // 
+            this.label7.AutoSize = true;
+            this.label7.Location = new System.Drawing.Point(18, 98);
+            this.label7.Name = "label7";
+            this.label7.Size = new System.Drawing.Size(42, 13);
+            this.label7.TabIndex = 4;
+            this.label7.Text = "Volume";
+            // 
+            // label6
+            // 
+            this.label6.AutoSize = true;
+            this.label6.Location = new System.Drawing.Point(18, 71);
+            this.label6.Name = "label6";
+            this.label6.Size = new System.Drawing.Size(30, 13);
+            this.label6.TabIndex = 3;
+            this.label6.Text = "Time";
+            // 
+            // label5
+            // 
+            this.label5.AutoSize = true;
+            this.label5.Location = new System.Drawing.Point(18, 45);
+            this.label5.Name = "label5";
+            this.label5.Size = new System.Drawing.Size(32, 13);
+            this.label5.TabIndex = 2;
+            this.label5.Text = "State";
+            // 
+            // lastUITickTextBox
+            // 
+            this.lastUITickTextBox.Enabled = false;
+            this.lastUITickTextBox.Location = new System.Drawing.Point(122, 13);
+            this.lastUITickTextBox.Name = "lastUITickTextBox";
+            this.lastUITickTextBox.Size = new System.Drawing.Size(145, 20);
+            this.lastUITickTextBox.TabIndex = 1;
+            // 
+            // label4
+            // 
+            this.label4.AutoSize = true;
+            this.label4.Location = new System.Drawing.Point(18, 16);
+            this.label4.Name = "label4";
+            this.label4.Size = new System.Drawing.Size(61, 13);
+            this.label4.TabIndex = 0;
+            this.label4.Text = "Last UI tick";
+            // 
+            // timer1
+            // 
+            this.timer1.Interval = 1000;
+            this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
+            // 
+            // MeterSimulationDlg
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(477, 387);
+            this.Controls.Add(this.groupBox2);
+            this.Controls.Add(this.groupBox1);
+            this.Controls.Add(this.meterIDGroupBox);
+            this.Name = "MeterSimulationDlg";
+            this.Text = "MeterDialog";
+            this.meterIDGroupBox.ResumeLayout(false);
+            this.meterIDGroupBox.PerformLayout();
+            this.groupBox1.ResumeLayout(false);
+            this.groupBox1.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flowTrackBar)).EndInit();
+            this.groupBox2.ResumeLayout(false);
+            this.groupBox2.PerformLayout();
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.GroupBox meterIDGroupBox;
+        private System.Windows.Forms.TextBox meterIDTextBox;
+        private System.Windows.Forms.Label label3;
+        private System.Windows.Forms.Label label2;
+        private System.Windows.Forms.TextBox volumeUnitsTextBox;
+        private System.Windows.Forms.TextBox timeUnitsTextBox;
+        private System.Windows.Forms.Label label1;
+        private System.Windows.Forms.GroupBox groupBox1;
+        private System.Windows.Forms.TextBox flowm3phTextBox;
+        private System.Windows.Forms.TrackBar flowTrackBar;
+        private System.Windows.Forms.GroupBox groupBox2;
+        private System.Windows.Forms.Button setFlowButton;
+        private System.Windows.Forms.Timer timer1;
+        private System.Windows.Forms.TextBox lastUITickTextBox;
+        private System.Windows.Forms.Label label4;
+        private System.Windows.Forms.TextBox flowTextBox;
+        private System.Windows.Forms.TextBox volumeTextBox;
+        private System.Windows.Forms.TextBox timeTextBox;
+        private System.Windows.Forms.TextBox stateTextBox;
+        private System.Windows.Forms.Label label8;
+        private System.Windows.Forms.Label label7;
+        private System.Windows.Forms.Label label6;
+        private System.Windows.Forms.Label label5;
+    }
+}

DataStreamMeter/MeterSimulationDlg.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Windows.Forms;
+
+namespace DataStreamMeter
+{
+    public partial class MeterSimulationDlg : Form
+    {
+        MeterSimulation meterSimulation;
+        double currentFlow;
+
+
+        public string MeterID;
+
+
+        public void OnMeterdata(MeterDataEventArgs args)
+        {
+            if (MeterDataHandler == null) return;
+            MeterDataHandler(null, args);
+        }
+        public event EventHandler<MeterDataEventArgs> MeterDataHandler;
+
+
+        /// <summary>
+        /// Default constructor with no meter
+        /// </summary>
+        public MeterSimulationDlg()
+            : this(null, string.Empty)
+        {
+        }
+
+        public MeterSimulationDlg(MeterSimulation meterSimulation, string meterID)
+        {
+            InitializeComponent();
+            this.meterSimulation = meterSimulation;
+            meterIDTextBox.Text = meterID;
+
+            currentFlow = 0;
+            flowm3phTextBox.Text = currentFlow.ToString();
+            flowTrackBar.Value = Convert.ToInt32(currentFlow);
+
+            MeterDataHandler += delegate(object sender, MeterDataEventArgs args)
+            {
+                if (InvokeRequired)
+                {
+                    Invoke(new EventHandler<MeterDataEventArgs>(DisplayMeterData), sender, args);
+                }
+                else
+                {
+                    DisplayMeterData(sender, args);
+                }
+            };
+
+            if (meterSimulation != null)
+            {
+                timer1.Enabled = true;
+                timer1.Start();
+            }
+        }
+
+        private void flowTrackBar_Scroll(object sender, EventArgs e)
+        {
+            currentFlow = flowTrackBar.Value;
+            flowm3phTextBox.Text = currentFlow.ToString("F2");
+        }
+
+        private void setFlowButton_Click(object sender, EventArgs e)
+        {
+            GetDblValueDlg dlg = new GetDblValueDlg("Enter flow in [m3/h] please", 0, 25.0);
+            if (dlg.ShowDialog() == DialogResult.OK)
+            {
+                currentFlow = dlg.DblValue;
+                flowm3phTextBox.Text = currentFlow.ToString();
+                flowTrackBar.Value = Convert.ToInt32(currentFlow);
+            }
+        }
+
+        private void timer1_Tick(object sender, EventArgs e)
+        {
+            lastUITickTextBox.Text = DateTime.Now.ToString("HH:mm:ss fff");
+            meterSimulation.TimerTick(currentFlow);
+        }
+
+        void DisplayMeterData(object sender, MeterDataEventArgs args)
+        {
+            stateTextBox.Text = args.State.ToString();
+            timeTextBox.Text = args.Time.ToString();
+            volumeTextBox.Text = args.Volume.ToString();
+            flowTextBox.Text = args.Flow.ToString();
+        }
+    }
+}

DataStreamMeter/MeterSimulationDlg.resx

@@ -0,0 +1,123 @@
+<?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>
+  <metadata name="timer1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+</root>

DataStreamMeter/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DataStreamMeter")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DataStreamMeter")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8acd46eb-c84d-4199-9f40-7420b7ebabc2")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

DataStreamMeter/Sample.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace DataStreamMeter
+{
+    public class Sample
+    {
+        public readonly double Time;        /// In water meter time units
+        public readonly double Volume;      /// In water meter colume units
+        public readonly double Flow;        /// In water meter flow units
+
+        public Sample(double time, double volume, double flow)
+        {
+            Time = time;
+            Volume = volume;
+            Flow = flow;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("time={0} volume={1} flow={2}", Time, Volume, Flow);
+        }
+    }
+}

Decrypt/Decrypt.csproj

@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Decrypt</RootNamespace>
     <AssemblyName>Decrypt</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <TargetFrameworkProfile>
     </TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
@@ -24,6 +24,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
     <PlatformTarget>x86</PlatformTarget>
@@ -33,6 +34,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup>
     <StartupObject>Decrypt.Program</StartupObject>

Decrypt/app.config

@@ -1,3 +1,3 @@
 <?xml version="1.0"?>
 <configuration>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2"/></startup></configuration>

DeviceTest/DeviceTest.csproj

@@ -10,7 +10,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>DeviceTest</RootNamespace>
     <AssemblyName>DeviceTest</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <TargetFrameworkProfile>
     </TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
@@ -24,6 +24,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
     <PlatformTarget>x86</PlatformTarget>
@@ -33,6 +34,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup>
     <StartupObject>DeviceTest.Program</StartupObject>

DeviceTest/DeviceTestDlg.cs

@@ -645,7 +645,8 @@ namespace DeviceTest
 								MessageBoxIcon.Exclamation);
 
 				foreach (var dev in tbfDevices) dev.StopDevice();
-				tbfDevices.Clear();
+                foreach (var dev in tbfDevices) dev.StopDevice2();
+                tbfDevices.Clear();
 
 				startButton.Enabled = true;
 				stopButton.Enabled = false;
@@ -856,7 +857,8 @@ namespace DeviceTest
 			}
 
 			foreach (var d in tbfDevices) d.StopDevice();
-		}
+            foreach (var d in tbfDevices) d.StopDevice2();
+        }
 
 		private void stopButton_Click(object sender, EventArgs e)
 		{