Reconfigured for Torino PT50

.gitignore

@@ -4,6 +4,8 @@ DeviceTest/bin/
 DeviceTest/obj/
 Dirichlet.Numerics/bin
 Dirichlet.Numerics/obj
+GemCard/bin
+GemCard/obj
 GraphLib/bin
 GraphLib/obj
 MonitoringDB/bin

Config/Config.csproj

@@ -18,7 +18,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TORINO50;LANG_IT</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
@@ -28,7 +28,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TORINO50;LANG_IT</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
@@ -77,6 +77,7 @@
     <Compile Include="Entities\IHasItemNr.cs" />
     <Compile Include="Entities\IHasName.cs" />
     <Compile Include="Entities\IHasValves.cs" />
+    <Compile Include="Entities\IParamsProvider.cs" />
     <Compile Include="Entities\MeasurementCorrection.cs" />
     <Compile Include="Entities\MetersPath.cs" />
     <Compile Include="Entities\OutputPath.cs" />
@@ -118,6 +119,7 @@
       <DependentUpon>Strings.resx</DependentUpon>
     </Compile>
     <Compile Include="Units.cs" />
+    <Compile Include="Utils.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources\Strings.cs.resx" />

Config/Data.cs

@@ -32,7 +32,7 @@ namespace Config
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 1;
-#elif TORUN_PT50_2015 || CEVAK_PT40_272 || MURES_PT40 || FUZHOU_40 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50 || JUZNA_AFRIKA_50
+#elif TORUN_PT50_2015 || CEVAK_PT40_272 || MURES_PT40 || FUZHOU_40 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50 || JUZNA_AFRIKA_50 || ZAMBIA
         public const int WMsCount = 20;
 		public const int LineSize = 10;
 		public const int CompoundWMsCount = 1;
@@ -50,8 +50,8 @@ namespace Config
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif TURA_SPECIAL
-		public const int WMsCount = 6;
+#elif TURA_SPECIAL || SENTEC
+        public const int WMsCount = 6;
 		public const int LineSize = 6;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;

Config/Entities/ComponentProcedure.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.IO;
@@ -13,13 +13,25 @@ namespace Config.Entities
 		public virtual string Parameters { get; set; }
 		public virtual Procedure Procedure { get; set; }
 
+        IParamsProvider paramsProvider;
+        /// 
+        public virtual IParamsProvider GetParamsProvider() { return paramsProvider; }
+        public virtual void SetParamsProvider(IParamsProvider paramsProvider) { this.paramsProvider = paramsProvider; }
+
+
+        protected ComponentProcedure() { }
+
+        public ComponentProcedure(string name, string parameters, Procedure procedure)
+        {
+            this.CmpntName = name;
+            this.Parameters = parameters;
+            this.Procedure = procedure;
+        }
+
+
 		public virtual ComponentProcedure Clone(Procedure newProcedure)
 		{
-			ComponentProcedure result = new ComponentProcedure();
-			result.CmpntName = CmpntName;
-			result.Parameters = Parameters;
-            result.Procedure = newProcedure;
-			return result;
+            return new ComponentProcedure(CmpntName, Parameters, newProcedure);
 		}
 
         public virtual void Export(StreamWriter output)
@@ -34,11 +46,16 @@ namespace Config.Entities
 
             if (string.IsNullOrEmpty(firstLine)) return null;
 
-            ComponentProcedure result = new ComponentProcedure();
-            result.CmpntName = firstLine;
-            result.Parameters = input.ReadLine().Replace("~", Environment.NewLine);
-            result.Procedure = newProcedure;
-            return result;
+            try
+            {
+                string cmptnName = firstLine;
+                string parameters = input.ReadLine().Replace("~", Environment.NewLine);
+                return new ComponentProcedure(cmptnName, parameters, newProcedure);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
 	}
 }

Config/Entities/ComponentTest.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.IO;
@@ -13,13 +13,25 @@ namespace Config.Entities
 		public virtual string Parameters { get; set; }
 		public virtual Test Test { get; set; }
 
+        IParamsProvider paramsProvider;
+        /// 
+        public virtual IParamsProvider GetParamsProvider() { return paramsProvider; }
+        public virtual void SetParamsProvider(IParamsProvider paramsProvider) { this.paramsProvider = paramsProvider; }
+
+
+        protected ComponentTest() { }
+
+        public ComponentTest(string name, string parameters, Test test)
+        {
+            this.CmpntName = name;
+            this.Parameters = parameters;
+            this.Test = test;
+        }
+
+
 		public virtual ComponentTest Clone()
 		{
-			ComponentTest result = new ComponentTest();
-			result.CmpntName = CmpntName;
-			result.Parameters = Parameters;
-			result.Test = Test;
-			return result;
+            return new ComponentTest(CmpntName, Parameters, Test);
 		}
 
         public virtual void Export(StreamWriter output)
@@ -34,11 +46,16 @@ namespace Config.Entities
 
             if (string.IsNullOrEmpty(firstLine)) return null;
 
-            ComponentTest result = new ComponentTest();
-            result.CmpntName = firstLine;
-            result.Parameters = input.ReadLine().Replace("~", Environment.NewLine);
-            result.Test = newTest;
-            return result;
+            try
+            {
+                string cmptnName = firstLine;
+                string parameters = input.ReadLine().Replace("~", Environment.NewLine);
+                return new ComponentTest(cmptnName, parameters, newTest);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
     }
 }

Config/Entities/Enums.cs

@@ -38,6 +38,29 @@ namespace Config.Entities
         }
     }
 
+    /// <summary>
+    /// Flags returned by each device configuration control Verify(...) function.
+    /// </summary>
+    public enum CfgUpdateFlags
+    {
+        None = 0,
+        Error = 0x1,			/// Some settings in the user control are invalid and cannot be set
+        Warning = 0x02,			/// Some settings in the user control are suspicious, can be set after user confirmation
+        RestartRqrd = 0x04,		/// TBF program restart is required to apply all changed parameters
+        AnyChange = 0x08,		/// At least one parameter have changed
+        VolatileChange = 0x10,
+        InvokeCfgChange = 0x20,	/// Invoke CfgChange handler of the component 
+    }
+
+    public enum RemoteDBUse
+    {
+        [Description("Local DB only")]          LocalDBOnly,
+        [Description("Remote DB only")]         RemoteDBOnly,
+        [Description("Both DB-s, local 1st")]   BothDBsLocalFirst,
+        [Description("Both DB-s, remote 1st")]  BothDBsRemoteFirst,
+        Count,
+    }
+
 	public enum ProcedureState
 	{
 		Active,
@@ -82,8 +105,11 @@ namespace Config.Entities
 	{
         [Description("")]       NotSpecified,
 #if LANG_PL
-        [Description("Zimna")]  ColdWater,
-        [Description("Gorąca")] HotWater,
+        [Description("zimna")]  ColdWater,
+        [Description("ciepła")] HotWater,
+#elif LANG_IT
+        [Description("freddo")] ColdWater,
+        [Description("caldo")]  HotWater,
 #else
 		[Description("cold")]   ColdWater,
 		[Description("hot")]    HotWater,

Config/Entities/IParamsProvider.cs

@@ -1,10 +1,19 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
-namespace TBF.BenchControl.Generic
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace Config.Entities
 {
 	public interface IParamsProvider
 	{
+        /// <summary>
+        /// Get XML Serializer
+        /// </summary>
+        XmlSerializer GetSerializer();
+
 		string ComponentName { get; }
 
 		/// <summary>
@@ -13,13 +22,19 @@ namespace TBF.BenchControl.Generic
 		int ParamsCount();
 
 		/// <summary>
-		/// Parameter names
+		/// Returns a parameter name
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		string ParamName(int ix);
 
+        /// <summary>
+        /// 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);
+
 		/// <summary>
-		/// Parameter values in string form
+		/// Returns a parameter value in the string form
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		string ToString(int ix);
@@ -43,9 +58,9 @@ namespace TBF.BenchControl.Generic
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		/// <param name="strValue">String representation of the parameter</param>
-		void UpdateParam(int ix, string strValue);
+        CfgUpdateFlags UpdateParam(int ix, string strValue);
 
-		void UpdateDbEntity();
+		void UpdateEmbeddedDbEntity();
 
         /// <summary>
         /// Creates an object copy

Config/Entities/Procedure.cs

@@ -225,6 +225,15 @@ namespace Config.Entities
             return diff.ToString();
         }
 
+        public virtual ComponentProcedure GetProcedureParamsEntity(string cmpntName)
+        {
+            foreach (var procPrms in MoreParams)
+            {
+                if (procPrms.CmpntName == cmpntName) return procPrms;
+            }
+            return null;
+        }
+
 		public override string ToString()
 		{
 			return string.Format("{0}, rev.{1}", Name, Revision);

Config/Entities/Test.cs

@@ -301,6 +301,15 @@ namespace Config.Entities
             return diff.ToString();
         }
 
+        public virtual ComponentTest GetTestParamsEntity(string cmpntName)
+        {
+            foreach (var tstPrms in MoreParams)
+            {
+                if (tstPrms.CmpntName == cmpntName) return tstPrms;
+            }
+            return null;
+        }
+
         public virtual float GetErrLimLo(float flow)
         {
             if (ErrLimLo <= ErrLimHi)

Config/FluentCommon.cs

@@ -39,7 +39,11 @@ namespace Config
 					dbType = Data.CurrentBench.WaterMetersDBSettings.DbType;
 					connectionString = Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
                     break;
-			}
+                case Users.Entities.DBKind.RemoteConfig:
+                    dbType = Data.CurrentBench.UsersDBSettings.DbType;
+                    connectionString = Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
+                    break;
+            }
 
             return CreateSessionFactory(database, dbType, connectionString, false);
 		}
@@ -69,6 +73,7 @@ namespace Config
                 {
                     default:
 					case Users.Entities.DBKind.Config:
+                    case Users.Entities.DBKind.RemoteConfig:
                         cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Data>());
                         break;
                     case Users.Entities.DBKind.Results:

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.18.876.0")]
-[assembly: AssemblyFileVersion("2.18.876.0")]
+[assembly: AssemblyVersion("2.18.928.0")]
+[assembly: AssemblyFileVersion("2.18.928.0")]

Config/Units.cs

@@ -73,14 +73,23 @@ namespace Config
         [Description("imp/dm3")]     ppdm3,		/// * 1 pulse/dm3
         [Description("stopień/l")]   degpl,		/// * 1 degree/l
         [Description("stopień/dm3")] degpdm3,	/// * 1 degree/dm3
+        [Description("l/imp")]       lpp,		/// * 1 l/pulse
+        [Description("dm3/imp")]     dm3pp,		/// * 1 dm3/pulse
+        [Description("l/stopień")]   lpdeg,		/// * 1 l/degree
+        [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
 #endif
         /// 
         [Description("pulse/kWh")]  ppkWh,		/// * 1 pulse/kWh
+        [Description("kWh/pulse")]  kWhpp,		/// * 1 kWh/pulse
                                                 
         Count
     }
@@ -151,8 +160,29 @@ namespace Config
         [Description("Text")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Datum a čas")]		DateTime,
-#else
+#elif LANG_IT
 		[Description("Volume")]				Volume,
+		[Description("Flusso")]				Flow,
+		[Description("Massa")]              Mass,
+        [Description("Tempo")]				Time,
+        [Description("Temperatura")]	    Temperature,
+		[Description("Pressione")]			Pressure,
+        [Description("Umidità")]			Humidity,
+        [Description("Errore")]				Error,
+		[Description("Lungezza")]			Length,
+		[Description("Densità")]			Density,
+		[Description("Energia")]			Energy,
+		[Description("Impulso")]			Pulses,
+        [Description("Impulso/litro")]		PulsePerLtr,
+        [Description("Impulso/kWh")]		PulsePerKWh,
+
+        /// Quantities without units and conversions
+        [Description("Numero")]				Number,
+        [Description("Stringa")]			String,
+        [Description("Boolean")]			Boolean,
+        [Description("Data e ora")]		    DateTime,
+#else
+        [Description("Volume")]				Volume,
 		[Description("Flow")]				Flow,
 		[Description("Mass")]				Mass,
         [Description("Time")]				Time,
@@ -268,9 +298,14 @@ namespace Config
                 case Unit.ppdm3:
                 case Unit.degpl:
                 case Unit.degpdm3:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:
                     return Config.Quantity.PulsePerLtr;
 
                 case Unit.ppkWh:
+                case Unit.kWhpp:
                     return Config.Quantity.PulsePerKWh;
 
                 default:
@@ -357,6 +392,12 @@ namespace Config
 				case Unit.kWh:      return v / 3600000.0;   /// 1 kWh = 3600000 J
                 case Unit.MWh:      return v / 3600000000.0;/// 1 MWh = 3600000000 J
 
+                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;
             }
         }
@@ -424,6 +465,12 @@ namespace Config
 				case Unit.kWh:		return 3600000 * v;     /// 1 kWh = 3600000 J
                 case Unit.MWh:      return 3600000000 * v;  /// 1 kWh = 3600000000 J
 
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return ((v == 0) ? 0 : 1 / v);
+
                 default:            return v;
             }
         }

Config/Utils.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Config
+{
+    public static class Utils
+    {
+        public static string SignificantDigitsToFmt(double value, int sigDigits)
+        {
+            if (sigDigits == 5)
+            {
+                if (value >= 9999.5 || value < -9999.5) return "F0";
+                else if (value >= 999.95 || value < -999.95) return "F1";
+                else if (value >= 99.995 || value < -99.995) return "F2";
+                else if (value >= 9.9995 || value < -9.9995) return "F3";
+                else if (value >= 0.99995 || value < -0.99995) return "F4";
+                else if (value >= 0.099995 || value < -0.099995) return "F5";
+                else if (value >= 0.0099995 || value < -0.0099995) return "F6";
+                else if (value >= 0.00099995 || value < -0.00099995) return "F7";
+                else if (value >= 0.000099995 || value < -0.000099995) return "F8";
+                else return "F9";
+            }
+            else if (sigDigits == 4)
+            {
+                if (value >= 999.5 || value < -999.5) return "F0";
+                else if (value >= 99.95 || value < -99.95) return "F1";
+                else if (value >= 9.995 || value < -9.995) return "F2";
+                else if (value >= 0.9995 || value < -0.9995) return "F3";
+                else if (value >= 0.09995 || value < -0.09995) return "F4";
+                else if (value >= 0.009995 || value < -0.009995) return "F5";
+                else if (value >= 0.0009995 || value < -0.0009995) return "F6";
+                else if (value >= 0.00009995 || value < -0.00009995) return "F7";
+                else return "F8";
+            }
+            else if (sigDigits == 3)
+            {
+                if (value >= 99.5 || value < -99.5) return "F0";
+                else if (value >= 9.95 || value < -9.95) return "F1";
+                else if (value >= 0.995 || value < -0.995) return "F2";
+                else if (value >= 0.0995 || value < -0.0995) return "F3";
+                else if (value >= 0.00995 || value < -0.00995) return "F4";
+                else if (value >= 0.000995 || value < -0.000995) return "F5";
+                else if (value >= 0.0000995 || value < -0.0000995) return "F6";
+                else return "F7";
+            }
+            else if (sigDigits == 2)
+            {
+                if (value >= 9.5 || value < -9.5) return "F0";
+                else if (value >= 0.95 || value < -0.95) return "F1";
+                else if (value >= 0.095 || value < -0.095) return "F2";
+                else if (value >= 0.0095 || value < -0.0095) return "F3";
+                else if (value >= 0.00095 || value < -0.00095) return "F4";
+                else if (value >= 0.000095 || value < -0.000095) return "F5";
+                else return "F6";
+            }
+            else /// if (sigDigits == 1)
+            {
+                if (value >= 0.95 || value < -0.95) return "F0";
+                else if (value >= 0.095 || value < -0.095) return "F1";
+                else if (value >= 0.0095 || value < -0.0095) return "F2";
+                else if (value >= 0.00095 || value < -0.00095) return "F3";
+                else if (value >= 0.000095 || value < -0.000095) return "F4";
+                else return "F5";
+            }
+        }
+    }
+}

GemCard/APDUCommand.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Text;
+
+namespace GemCard
+{
+	/// <summary>
+	/// This class represents a command APDU
+	/// </summary>
+	public	class	APDUCommand
+	{
+		/// <summary>
+        /// Minimun size of an APDU command in bytes
+		/// </summary>
+		public const int APDU_MIN_LENGTH = 4;
+
+        public byte Class;      /// Class byte
+        public byte Ins;        /// Instruction byte
+        public byte P1;         /// Parameter P1 byte
+        public byte P2;         /// Parameter P2 byte
+        public byte[] Data;     /// Data to send to the card if any, null if no data to send
+        public byte Le;	        /// Number of data expected, 0 if none
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="bCla">Class byte</param>
+		/// <param name="bIns">Instruction byte</param>
+		/// <param name="bP1">Parameter P1 byte</param>
+		/// <param name="bP2">Parameter P2 byte</param>
+		/// <param name="baData">Data to send to the card if any, null if no data to send</param>
+		/// <param name="bLe">Number of data expected, 0 if none</param>
+		public APDUCommand(byte bCla, byte bIns, byte bP1, byte bP2, byte[] baData, byte bLe)
+		{
+            this.Class = bCla;
+            this.Ins = bIns;
+            this.P1 = bP1;
+            this.P2 = bP2;
+            this.Data = baData;
+            this.Le = bLe;
+		}
+
+
+		/// <summary>
+		/// Update the current APDU with selected parameters
+		/// </summary>
+		/// <param name="apduParam">APDU parameters</param>
+		public void Update(APDUParam apduParam)
+		{
+			if (apduParam.UseData)    Data = apduParam.Data;
+			if (apduParam.UseLe)      Le   = apduParam.Le;
+			if (apduParam.UseP1)      P1   = apduParam.P1;
+			if (apduParam.UseP2)      P2   = apduParam.P2;
+            if (apduParam.UseChannel) Class += apduParam.Channel;
+        }
+
+        /// <summary>
+        /// Overrides the ToString method to format to a string the APDUCommand object
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            string strData = null;
+            byte bLc = 0;
+            byte bP3 = Le;    
+
+            if (Data != null)
+            {
+                StringBuilder sData = new StringBuilder(Data.Length * 2);
+                for (int nI = 0; nI < Data.Length; nI++)
+                {
+                    sData.AppendFormat("{0:X02}", Data[nI]);
+                }
+
+                strData = "Data=" + sData.ToString();
+                bLc = (byte) Data.Length;
+                bP3 = bLc;
+            }
+            
+            //string strApdu = string.Format("Class={0:X02} Ins={1:X02} P1={2:X02} P2={3:X02} Le={4:X02} Lc={5:X02} ",
+                //m_bCla, m_bIns, m_bP1, m_bP2, m_bLe, bLc);
+            StringBuilder strApdu = new StringBuilder();
+
+            strApdu.AppendFormat("Class={0:X02} Ins={1:X02} P1={2:X02} P2={3:X02} P3={4:X02} ",
+                Class, Ins, P1, P2, bP3);
+
+            if (Data != null)
+            {
+                strApdu.Append(strData);
+            }
+
+            return strApdu.ToString();
+        }
+    }
+}

GemCard/APDUParam.cs

@@ -0,0 +1,147 @@
+using System;
+
+namespace GemCard
+{
+    /// <summary>
+    /// This class is used to update a set of parameters of an APDUCommand object
+    /// </summary>
+    public class APDUParam
+    {
+        byte bClass;
+        byte bChannel;
+        byte bP2;
+        byte bP1;
+
+        byte[] baData;
+        short nLe;
+
+        bool fUseP1;
+        bool fUseP2;
+        bool fChannel;
+        bool fData;
+        bool fClass;
+        bool fLe;
+
+        /// <summary>
+        /// Resets the current instance, all flags are set to false
+        /// </summary>
+        public void Reset()
+        {
+            bClass = 0;
+            bChannel = 0;
+            bP2 = 0;
+            bP1 = 0;
+
+            baData = null;
+            nLe = -1;
+
+            fUseP1 = false;
+            fUseP2 = false;
+            fChannel = false;
+            fData = false;
+            fClass = false;
+            fLe = false;
+        }
+
+        #region Constructors
+
+        public APDUParam()
+        {
+            Reset();
+        }
+
+        /// <summary>
+        /// Copy constructor (used for cloning)
+        /// </summary>
+        /// <param name="param"></param>
+        public APDUParam(APDUParam param)
+        {
+            // Copy field
+            if (param.baData != null)
+            {
+                param.baData.CopyTo(baData, 0);
+            }
+
+            this.bClass = param.bClass;
+            this.bChannel = param.bChannel;
+            this.bP1 = param.bP1;
+            this.bP2 = param.bP2;
+            this.nLe = param.nLe;
+
+            // Copy flags field
+            this.fChannel = param.fChannel;
+            this.fClass = param.fClass;
+            this.fData = param.fData;
+            this.fLe = param.fLe;
+            this.fUseP1 = param.fUseP1;
+            this.fUseP2 = param.fUseP2;
+        }
+
+        public APDUParam(byte bClass, byte bP1, byte bP2, byte[] baData, short nLe)
+        {
+            this.Class = bClass;
+            this.P1 = bP1;
+            this.P2 = bP2;
+            this.Data = baData;
+            this.Le = (byte)nLe;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Clones the current APDUParam instance
+        /// </summary>
+        /// <returns></returns>
+        public APDUParam Clone()
+        {
+            return new APDUParam(this);
+        }
+
+        #region Properties
+
+        public bool UseClass { get { return fClass; } }
+        public bool UseChannel { get { return fChannel; } }
+        public bool UseLe { get { return fLe; } }
+        public bool UseData { get { return fData; } }
+        public bool UseP1 { get { return fUseP1; } }
+        public bool UseP2 { get { return fUseP2; } }
+
+        public byte P1
+        {
+            get { return bP1; }
+            set { bP1 = value; fUseP1 = true; }
+        }
+
+        public byte P2
+        {
+            get { return bP2; }
+            set { bP2 = value; fUseP2 = true; }
+        }
+
+        public byte[] Data
+        {
+            get { return baData; }
+            set { baData = value; fData = true; }
+        }
+
+        public byte Le
+        {
+            get { return (byte)nLe; }
+            set { nLe = value; fLe = true; }
+        }
+
+        public byte Channel
+        {
+            get { return bChannel; }
+            set { bChannel = value; fChannel = true; }
+        }
+
+        public byte Class
+        {
+            get { return bClass; }
+            set { bClass = value; fClass = true; }
+        }
+
+        #endregion
+    }
+}

GemCard/APDUResponse.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Text;
+
+namespace GemCard
+{
+	/// <summary>
+	/// This class represents the APDU response sent by the card
+	/// </summary>
+	public class APDUResponse
+	{
+		/// <summary>
+		///	Status bytes length
+		/// </summary>
+		public const int SW_LENGTH = 2;
+
+        /// <summary>
+        /// Response data. Contains the data sent by the card minus the 2 status bytes (SW1, SW2)
+        /// null if no data were sent by the card
+        /// </summary>
+        public byte[] Data;
+        public byte SW1;
+        public byte SW2;
+
+        /// <summary>
+        /// Status get property
+        /// </summary>
+        public ushort Status
+        {
+            get { return (ushort)(((short)SW1 << 8) + (short)SW2); }
+        }
+
+		/// <summary>
+		/// Constructor from the byte data sent back by the card
+		/// </summary>
+		/// <param name="baData">Buffer of data from the card</param>
+		public APDUResponse(byte[] baData)
+		{
+			if (baData.Length > SW_LENGTH)
+			{
+				Data = new byte[baData.Length - SW_LENGTH];
+
+                for (int nI = 0; nI < baData.Length - SW_LENGTH; nI++)
+                {
+                    this.Data[nI] = baData[nI];
+                }
+			}
+
+            this.SW1 = baData[baData.Length - 2];
+            this.SW2 = baData[baData.Length - 1];
+		}
+
+        /// <summary>
+        /// Overrides the ToString method to format to a string the APDUResponse object
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            if (Data != null)
+            {
+                StringBuilder sData = new StringBuilder(Data.Length * 2);
+                for (int nI = 0; nI < Data.Length; nI++)
+                {
+                    sData.AppendFormat("{0:X02}", Data[nI]);
+                }
+
+                return sData.ToString();
+            }
+            else
+            {
+                return string.Empty;
+            }
+        }
+	}
+}

GemCard/AssemblyInfo.cs

@@ -0,0 +1,58 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// 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("")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]		
+
+//
+// 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 Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("1.0.*")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the 
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing. 
+//
+// Notes: 
+//   (*) If no key is specified, the assembly is not signed.
+//   (*) KeyName refers to a key that has been installed in the Crypto Service
+//       Provider (CSP) on your machine. KeyFile refers to a file which contains
+//       a key.
+//   (*) If the KeyFile and the KeyName values are both specified, the 
+//       following processing occurs:
+//       (1) If the KeyName can be found in the CSP, that key is used.
+//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
+//           in the KeyFile is installed into the CSP and used.
+//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile 
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]

GemCard/CardBase.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace GemCard 
+{
+    /// <summary>
+    /// Values for AttrId of SCardGetAttrib
+    /// </summary>
+    public class SCARD_ATTR_VALUE
+    {
+        private const uint 
+            SCARD_CLASS_COMMUNICATIONS = 2,
+            SCARD_CLASS_PROTOCOL = 3,
+            SCARD_CLASS_MECHANICAL = 6,
+            SCARD_CLASS_VENDOR_DEFINED = 7,
+            SCARD_CLASS_IFD_PROTOCOL = 8,
+            SCARD_CLASS_ICC_STATE = 9,
+            SCARD_CLASS_SYSTEM = 0x7fff;
+
+        private static UInt32 SCardAttrValue(UInt32 attrClass, UInt32 val)
+        {
+            return (attrClass << 16) | val;
+        }
+
+        public static UInt32 CHANNEL_ID { get { return SCardAttrValue(SCARD_CLASS_COMMUNICATIONS, 0x0110); } }
+
+        public static UInt32 CHARACTERISTICS { get { return SCardAttrValue(SCARD_CLASS_MECHANICAL, 0x0150); } }
+
+        public static UInt32 CURRENT_PROTOCOL_TYPE { get { return SCardAttrValue(SCARD_CLASS_IFD_PROTOCOL, 0x0201); } }
+
+        public static UInt32 DEVICE_UNIT { get { return SCardAttrValue(SCARD_CLASS_SYSTEM, 0x0001); } }
+        public static UInt32 DEVICE_FRIENDLY_NAME { get { return SCardAttrValue(SCARD_CLASS_SYSTEM, 0x0003); } }
+        public UInt32 DEVICE_SYSTEM_NAME { get { return SCardAttrValue(SCARD_CLASS_SYSTEM, 0x0004); } }
+
+        public static UInt32 ICC_PRESENCE { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0300); } }
+        public static UInt32 ICC_INTERFACE_STATUS { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0301); } }
+        public static UInt32 ATR_STRING { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0303); } }
+        public static UInt32 ICC_TYPE_PER_ATR { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0304); } }
+
+        public static UInt32 PROTOCOL_TYPES { get { return SCardAttrValue(SCARD_CLASS_PROTOCOL, 0x0120); } }
+
+        public static UInt32 VENDOR_NAME { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0100); } }
+        public static UInt32 VENDOR_IFD_TYPE { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0101); } }
+        public static UInt32 VENDOR_IFD_VERSION { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0102); } }
+        public static UInt32 VENDOR_IFD_SERIAL_NO { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0103); } }
+    }
+
+    /// <summary>
+    /// Abstract class that adds a basic event management to the ICard interface. 
+    /// </summary>
+    abstract public class CardBase : ICard
+    {
+        protected const uint INFINITE = 0xFFFFFFFF;
+        protected const uint WAIT_TIME = 250;
+
+        protected bool m_bRunCardDetection = true;
+        protected Thread m_thread = null;
+
+        /// <summary>
+        /// Event handler for the card insertion
+        /// </summary>
+        public event EventHandler<CardInsertedEventArgs> OnCardInserted = null;
+
+        /// <summary>
+        /// Event handler for the card removal
+        /// </summary>
+        public event EventHandler<CardRemovedEventArgs> OnCardRemoved = null;
+
+        ~CardBase()
+        {
+            // Stop any eventual card detection thread
+            StopCardEvents();
+        }
+
+        #region Abstract method that implement the ICard interface
+        abstract public string[] ListReaders();
+        abstract public void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols);
+        abstract public void Disconnect(DISCONNECT Disposition);
+        abstract public APDUResponse Transmit(APDUCommand ApduCmd);
+        abstract public void BeginTransaction();
+        abstract public void EndTransaction(DISCONNECT Disposition);
+        abstract public byte[] GetAttribute(UInt32 AttribId);
+        #endregion
+
+        /// <summary>
+        /// This method should start a thread that checks for card insertion or removal
+        /// </summary>
+        /// <param name="Reader"></param>
+        public void StartCardEvents(string Reader)
+        {
+            if (m_thread == null)
+            {
+                m_bRunCardDetection = true;
+
+                m_thread = new Thread(new ParameterizedThreadStart(RunCardDetection));
+                m_thread.Start(Reader);
+            }
+        }
+
+        /// <summary>
+        /// Stops the card events thread
+        /// </summary>
+        public void StopCardEvents()
+        {
+            if (m_thread != null)
+            {
+                int
+                    nTimeOut = 10,
+                    nCount = 0;
+                bool m_bStop = false;
+                m_bRunCardDetection = false;
+
+                do
+                {
+                    if (nCount > nTimeOut)
+                    {
+                        m_thread.Abort();
+                        break;
+                    }
+
+                    if (m_thread.ThreadState == ThreadState.Aborted)
+                        m_bStop = true;
+
+                    if (m_thread.ThreadState == ThreadState.Stopped)
+                        m_bStop = true;
+
+                    Thread.Sleep(200);
+                    ++nCount;           // Manage time out
+                }
+                while (!m_bStop);
+
+                m_thread = null;
+            }
+        }
+
+        /// <summary>
+        /// This function must implement a card detection mechanism.
+        /// 
+        /// When card insertion is detected, it must call the method CardInserted()
+        /// When card removal is detected, it must call the method CardRemoved()
+        /// 
+        /// </summary>
+        /// <param name="Reader">Name of the reader to scan for card event</param>
+        abstract protected void RunCardDetection(object Reader);
+
+        #region Event methods
+
+        protected void CardInserted(object sender, CardInsertedEventArgs args)
+        {
+            if (OnCardInserted != null) OnCardInserted(sender, args);
+        }
+
+        protected void CardRemoved(object sender, CardRemovedEventArgs args)
+        {
+            if (OnCardRemoved != null) OnCardRemoved(sender, args);
+        }
+
+        #endregion
+    }
+}

GemCard/CardCOM.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Runtime.InteropServices;
+using SCARDSSPLib;
+using GemCardExLib;
+
+namespace GemCard
+{
+	/// <summary>
+	/// Implements the ICard interface using the SCard COM objects from Microsoft and SCardDatabaseEx object
+	/// for the ListReaders function.
+	/// </summary>
+	public class CardCOM : CardBase
+	{
+		private ISCard	m_itfCard = null;
+
+		/// <summary>
+		/// Default constructor
+		/// </summary>
+		public CardCOM()
+		{
+			// Create the SCard object
+			m_itfCard = new CSCardClass();
+		}
+
+		#region ICard Members
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardListReaders(SCARDCONTEXT hContext, 
+		///		LPCTSTR mszGroups, 
+		///		LPTSTR mszReaders, 
+		///		LPDWORD pcchReaders 
+		///	);
+		/// </summary>
+		/// <returns>A string array of the readers</returns>
+		public	override string[]	ListReaders()
+		{
+			ISCardDatabaseEx itfCardBase = new SCardDatabaseEx();
+
+			return (string[]) itfCardBase.ListReaders();
+		}
+
+		/// <summary>
+		///  Wraps the PCSC function
+		///  LONG SCardConnect(
+		///		IN SCARDCONTEXT hContext,
+		///		IN LPCTSTR szReader,
+		///		IN DWORD dwShareMode,
+		///		IN DWORD dwPreferredProtocols,
+		///		OUT LPSCARDHANDLE phCard,
+		///		OUT LPDWORD pdwActiveProtocol
+		///	);
+		/// </summary>
+		/// <param name="Reader"></param>
+		/// <param name="ShareMode"></param>
+		/// <param name="PreferredProtocols"></param>
+		public override void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols)
+		{
+			// Calls AttachReader to connect to the card
+			m_itfCard.AttachByReader(Reader, (SCARD_SHARE_MODES) ShareMode, (SCARD_PROTOCOLS) PreferredProtocols);
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		///	LONG SCardDisconnect(
+		///		IN SCARDHANDLE hCard,
+		///		IN DWORD dwDisposition
+		///	);
+		/// </summary>
+		/// <param name="Disposition"></param>
+		public override void Disconnect(DISCONNECT Disposition)
+		{
+			// Off the connection with the card
+			m_itfCard.Detach((SCARD_DISPOSITIONS) Disposition);
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardTransmit(
+		///		SCARDHANDLE hCard,
+		///		LPCSCARD_I0_REQUEST pioSendPci,
+		///		LPCBYTE pbSendBuffer,
+		///		DWORD cbSendLength,
+		///		LPSCARD_IO_REQUEST pioRecvPci,
+		///		LPBYTE pbRecvBuffer,
+		///		LPDWORD pcbRecvLength
+		///	);
+		/// </summary>
+		/// <param name="ApduCmd">APDUCommand object with the APDU to send to the card</param>
+		/// <returns>An APDUResponse object with the response from the card</returns>
+		public override APDUResponse Transmit(APDUCommand ApduCmd)
+		{
+			CSCardCmd	itfCmd = new CSCardCmdClass();
+			CByteBuffer	itfData = new CByteBufferClass();
+			int	nLe = ApduCmd.Le;
+
+			if (ApduCmd.Data == null)
+			{
+				itfData.SetSize(0);
+			}
+			else
+			{
+				int nWrite = 0;
+
+				itfData.SetSize(ApduCmd.Data.Length);
+				itfData.Write(ref ApduCmd.Data[0], ApduCmd.Data.Length, ref nWrite);
+			}
+
+			// Build the APDU command
+			itfCmd.BuildCmd(ApduCmd.Class, ApduCmd.Ins, ApduCmd.P1, ApduCmd.P2, itfData, ref nLe);
+
+			// Send the command
+			m_itfCard.Transaction(ref itfCmd);
+
+			// Analyse the response
+			int nRead = 0;
+			byte[]	pbResp = new byte[itfCmd.ApduReplyLength];
+
+			itfCmd.ApduReply.Read(ref pbResp[0], itfCmd.ApduReplyLength, ref nRead);
+
+			return new APDUResponse(pbResp);
+		}
+
+        /// <summary>
+        /// Wraps the PSCS function
+        /// LONG SCardBeginTransaction(
+        ///     SCARDHANDLE hCard
+        //  );
+        /// This function is not supported in the COM implementation
+        /// </summary>
+        public override void BeginTransaction()
+        {
+            throw new NotImplementedException("BeginTransaction is not supported in the COM implementation");
+        }
+
+        /// <summary>
+        /// Wraps the PCSC function
+        /// LONG SCardEndTransaction(
+        ///     SCARDHANDLE hCard,
+        ///     DWORD dwDisposition
+        /// );
+        /// This function is not supported in the COM implementation
+        /// </summary>
+        /// <param name="Disposition">A value from DISCONNECT enum</param>
+        public override void EndTransaction(DISCONNECT Disposition)
+        {
+            throw new NotImplementedException("EndTransaction is not supported in the COM implementation");
+        }
+
+        /// <summary>
+        /// Gets the attributes of the card
+        /// </summary>
+        /// <param name="AttribId">Identifier for the Attribute to get</param>
+        /// <returns>Attribute content</returns>
+        public override byte[] GetAttribute(UInt32 AttribId)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        /// <summary>
+        /// This function must implement a card detection mechanism.
+        /// 
+        /// When card insertion is detected, it must call the method CardInserted()
+        /// When card removal is detected, it must call the method CardRemoved()
+        /// 
+        /// </summary>
+        protected override void RunCardDetection(object Reader)
+        {
+            throw new Exception("The method or operation is not implemented.");
+        }
+	}
+}

GemCard/CardInsertedEventArgs.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace GemCard
+{
+    public class CardInsertedEventArgs : EventArgs
+    {
+        public CardInsertedEventArgs() { }
+    }
+}

GemCard/CardNative.cs

@@ -0,0 +1,620 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace GemCard
+{
+    /// <summary>
+    /// CARD_STATE enumeration, used by the PC/SC function SCardGetStatusChanged
+    /// </summary>
+    enum CARD_STATE
+    {
+        UNAWARE = 0x00000000,
+        IGNORE = 0x00000001,
+        CHANGED = 0x00000002,
+        UNKNOWN = 0x00000004,
+        UNAVAILABLE = 0x00000008,
+        EMPTY = 0x00000010,
+        PRESENT = 0x00000020,
+        ATRMATCH = 0x00000040,
+        EXCLUSIVE = 0x00000080,
+        INUSE = 0x00000100,
+        MUTE = 0x00000200,
+        UNPOWERED = 0x00000400
+    }
+
+	/// <summary>
+	/// Wraps the SCARD_IO_STRUCTURE
+    ///  
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct	SCard_IO_Request
+	{
+		public UInt32	m_dwProtocol;
+		public UInt32	m_cbPciLength;
+	}
+
+
+    /// <summary>
+    /// Wraps theSCARD_READERSTATE structure of PC/SC
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    public struct SCard_ReaderState
+    {
+        public string m_szReader;
+        public IntPtr m_pvUserData;
+        public UInt32 m_dwCurrentState;
+        public UInt32 m_dwEventState;
+        public UInt32 m_cbAtr;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst=32)]
+        public byte[] m_rgbAtr;
+    }
+
+	/// <summary>
+	/// Implementation of ICard using native (P/Invoke) interoperability for PC/SC
+	/// </summary>
+	public class CardNative : CardBase
+	{
+		private	UInt32	m_hContext = 0;
+		private	UInt32	m_hCard = 0;
+		private	UInt32	m_nProtocol = (uint) PROTOCOL.T0;
+		private	int	m_nLastError = 0;
+
+		#region PCSC_FUNCTIONS
+        /// <summary>
+        /// Native SCardGetStatusChanged from winscard.dll
+        /// </summary>
+        /// <param name="hContext"></param>
+        /// <param name="dwTimeout"></param>
+        /// <param name="rgReaderStates"></param>
+        /// <param name="cReaders"></param>
+        /// <returns></returns>
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardGetStatusChange(UInt32 hContext,
+            UInt32 dwTimeout,
+            [In,Out] SCard_ReaderState[] rgReaderStates,
+            UInt32 cReaders);
+
+		/// <summary>
+		/// Native SCardListReaders function from winscard.dll
+		/// </summary>
+		/// <param name="hContext"></param>
+		/// <param name="mszGroups"></param>
+		/// <param name="mszReaders"></param>
+		/// <param name="pcchReaders"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern int SCardListReaders(UInt32 hContext,
+			[MarshalAs(UnmanagedType.LPTStr)] string mszGroups,
+			IntPtr mszReaders,
+			out UInt32	pcchReaders);
+
+		/// <summary>
+		/// Native SCardEstablishContext function from winscard.dll
+		/// </summary>
+		/// <param name="dwScope"></param>
+		/// <param name="pvReserved1"></param>
+		/// <param name="pvReserved2"></param>
+		/// <param name="phContext"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal	static	extern	int	SCardEstablishContext(UInt32 dwScope,
+			IntPtr pvReserved1,
+			IntPtr pvReserved2,
+			IntPtr phContext);
+
+		/// <summary>
+		/// Native SCardReleaseContext function from winscard.dll
+		/// </summary>
+		/// <param name="hContext"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern	int	SCardReleaseContext(UInt32 hContext);
+
+		/// <summary>
+		/// Native SCardConnect function from winscard.dll
+		/// </summary>
+		/// <param name="hContext"></param>
+		/// <param name="szReader"></param>
+		/// <param name="dwShareMode"></param>
+		/// <param name="dwPreferredProtocols"></param>
+		/// <param name="phCard"></param>
+		/// <param name="pdwActiveProtocol"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true, CharSet=CharSet.Auto)]
+		internal static	extern	int	SCardConnect(UInt32 hContext,
+			[MarshalAs(UnmanagedType.LPTStr)] string szReader,
+			UInt32	dwShareMode, 
+			UInt32	dwPreferredProtocols,
+			IntPtr	phCard, 
+			IntPtr	pdwActiveProtocol);
+
+		/// <summary>
+		/// Native SCardDisconnect function from winscard.dll
+		/// </summary>
+		/// <param name="hCard"></param>
+		/// <param name="dwDisposition"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern	int	SCardDisconnect(UInt32 hCard,
+			UInt32 dwDisposition);
+
+		/// <summary>
+		/// Native SCardTransmit function from winscard.dll
+		/// </summary>
+		/// <param name="hCard"></param>
+		/// <param name="pioSendPci"></param>
+		/// <param name="pbSendBuffer"></param>
+		/// <param name="cbSendLength"></param>
+		/// <param name="pioRecvPci"></param>
+		/// <param name="pbRecvBuffer"></param>
+		/// <param name="pcbRecvLength"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern	int	SCardTransmit(UInt32 hCard,
+			[In] ref SCard_IO_Request pioSendPci,
+			byte[] pbSendBuffer,
+			UInt32 cbSendLength,
+			IntPtr pioRecvPci,
+			[Out] byte[] pbRecvBuffer,
+			out UInt32 pcbRecvLength
+			);
+
+        /// <summary>
+        /// Native SCardBeginTransaction function of winscard.dll
+        /// </summary>
+        /// <param name="hContext"></param>
+        /// <returns></returns>
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardBeginTransaction(UInt32 hContext);
+
+        /// <summary>
+        /// Native SCardEndTransaction function of winscard.dll
+        /// </summary>
+        /// <param name="hContext"></param>
+        /// <returns></returns>
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardEndTransaction(UInt32 hContext, UInt32 dwDisposition);
+
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardGetAttrib(UInt32 hCard,
+            UInt32 dwAttribId,
+            [Out] byte[] pbAttr,
+            out UInt32 pcbAttrLen);
+
+        #endregion
+
+		/// <summary>
+		/// Default constructor
+		/// </summary>
+		public CardNative()
+		{
+		}
+
+		/// <summary>
+		/// Object destruction
+		/// </summary>
+		~CardNative()
+		{
+			Disconnect(DISCONNECT.Unpower);
+
+			ReleaseContext();
+		}
+
+		#region ICard Members
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardListReaders(SCARDCONTEXT hContext, 
+		///		LPCTSTR mszGroups, 
+		///		LPTSTR mszReaders, 
+		///		LPDWORD pcchReaders 
+		///	);
+		/// </summary>
+		/// <returns>A string array of the readers</returns>
+		public	override string[]	ListReaders()
+		{
+			EstablishContext(SCOPE.User);
+
+			string[]	sListReaders = null;
+			UInt32	pchReaders = 0;
+			IntPtr	szListReaders = IntPtr.Zero;
+
+			m_nLastError = SCardListReaders(m_hContext, null, szListReaders, out pchReaders);
+			if (m_nLastError == 0)
+			{
+				szListReaders = Marshal.AllocHGlobal((int) pchReaders);
+				m_nLastError = SCardListReaders(m_hContext, null, szListReaders, out pchReaders);
+				if (m_nLastError == 0)
+				{
+					char[] caReadersData = new char[pchReaders];
+					int	nbReaders = 0;
+					for (int nI = 0; nI < pchReaders; nI++)
+					{
+						caReadersData[nI] = (char) Marshal.ReadByte(szListReaders, nI);
+
+						if (caReadersData[nI] == 0)
+							nbReaders++;
+					}
+
+					// Remove last 0
+					--nbReaders;
+
+					if (nbReaders != 0)
+					{
+						sListReaders = new string[nbReaders];
+						char[] caReader = new char[pchReaders];
+						int	nIdx = 0;
+						int	nIdy = 0;
+						int	nIdz = 0;
+						// Get the nJ string from the multi-string
+
+						while(nIdx < pchReaders - 1)
+						{
+							caReader[nIdy] = caReadersData[nIdx];
+							if (caReader[nIdy] == 0)
+							{
+								sListReaders[nIdz] = new string(caReader, 0, nIdy);
+								++nIdz;
+								nIdy = 0;
+								caReader = new char[pchReaders];
+							}
+							else
+								++nIdy;
+
+							++nIdx;
+						}
+					}
+
+				}
+
+				Marshal.FreeHGlobal(szListReaders);
+			}
+
+			ReleaseContext();
+
+			return sListReaders;
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function 
+		/// LONG SCardEstablishContext(
+		///		IN DWORD dwScope,
+		///		IN LPCVOID pvReserved1,
+		///		IN LPCVOID pvReserved2,
+		///		OUT LPSCARDCONTEXT phContext
+		///	);
+		/// </summary>
+		/// <param name="Scope"></param>
+		public void EstablishContext(SCOPE Scope)
+		{
+			IntPtr	hContext = Marshal.AllocHGlobal(Marshal.SizeOf(m_hContext));
+
+			m_nLastError = SCardEstablishContext((uint) Scope, IntPtr.Zero, IntPtr.Zero, hContext);
+			if (m_nLastError != 0)
+			{
+				string msg = "SCardEstablishContext error: " + m_nLastError;
+
+				Marshal.FreeHGlobal(hContext);
+				throw new Exception(msg);
+			}
+
+			m_hContext = (uint) Marshal.ReadInt32(hContext);
+
+			Marshal.FreeHGlobal(hContext);
+		}
+
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardReleaseContext(
+		///		IN SCARDCONTEXT hContext
+		///	);
+		/// </summary>
+		public void ReleaseContext()
+		{
+			if (m_hContext != 0)
+			{
+				m_nLastError = SCardReleaseContext(m_hContext);
+
+				if (m_nLastError != 0)
+				{
+					string	msg = "SCardReleaseContext error: " + m_nLastError;
+					throw new Exception(msg);
+				}
+
+				m_hContext = 0;
+			}
+		}
+
+		/// <summary>
+		///  Wraps the PCSC function
+		///  LONG SCardConnect(
+		///		IN SCARDCONTEXT hContext,
+		///		IN LPCTSTR szReader,
+		///		IN DWORD dwShareMode,
+		///		IN DWORD dwPreferredProtocols,
+		///		OUT LPSCARDHANDLE phCard,
+		///		OUT LPDWORD pdwActiveProtocol
+		///	);
+		/// </summary>
+		/// <param name="Reader"></param>
+		/// <param name="ShareMode"></param>
+		/// <param name="PreferredProtocols"></param>
+		public override void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols)
+		{
+			EstablishContext(SCOPE.User);
+
+			IntPtr	hCard = Marshal.AllocHGlobal(Marshal.SizeOf(m_hCard));
+			IntPtr	pProtocol = Marshal.AllocHGlobal(Marshal.SizeOf(m_nProtocol));
+
+			m_nLastError = SCardConnect(m_hContext, 
+				Reader, 
+				(uint) ShareMode, 
+				(uint) PreferredProtocols, 
+				hCard,
+				pProtocol);
+
+			if (m_nLastError != 0)
+			{
+				string msg = "SCardConnect error: " + m_nLastError;
+
+				Marshal.FreeHGlobal(hCard);
+				Marshal.FreeHGlobal(pProtocol);
+				throw new Exception(msg);
+			}
+
+			m_hCard = (uint) Marshal.ReadInt32(hCard);
+			m_nProtocol = (uint) Marshal.ReadInt32(pProtocol);
+
+			Marshal.FreeHGlobal(hCard);
+			Marshal.FreeHGlobal(pProtocol);
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		///	LONG SCardDisconnect(
+		///		IN SCARDHANDLE hCard,
+		///		IN DWORD dwDisposition
+		///	);
+		/// </summary>
+		/// <param name="Disposition"></param>
+		public override void Disconnect(DISCONNECT Disposition)
+		{
+			if (m_hCard != 0)
+			{
+				m_nLastError = SCardDisconnect(m_hCard, (uint) Disposition);
+				m_hCard = 0;
+
+				if (m_nLastError != 0)
+				{
+					string msg = "SCardDisconnect error: " + m_nLastError;
+					throw new Exception(msg);
+				}
+
+				ReleaseContext();
+			}
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardTransmit(
+		///		SCARDHANDLE hCard,
+		///		LPCSCARD_I0_REQUEST pioSendPci,
+		///		LPCBYTE pbSendBuffer,
+		///		DWORD cbSendLength,
+		///		LPSCARD_IO_REQUEST pioRecvPci,
+		///		LPBYTE pbRecvBuffer,
+		///		LPDWORD pcbRecvLength
+		///	);
+		/// </summary>
+		/// <param name="ApduCmd">APDUCommand object with the APDU to send to the card</param>
+		/// <returns>An APDUResponse object with the response from the card</returns>
+		public override APDUResponse Transmit(APDUCommand ApduCmd)
+		{
+			uint	RecvLength = (uint) (ApduCmd.Le + APDUResponse.SW_LENGTH);
+			byte[]	ApduBuffer = null;
+			byte[]	ApduResponse = new byte[ApduCmd.Le + APDUResponse.SW_LENGTH];
+			SCard_IO_Request	ioRequest = new SCard_IO_Request();
+			ioRequest.m_dwProtocol = m_nProtocol;
+			ioRequest.m_cbPciLength = 8;
+
+			// Build the command APDU
+			if (ApduCmd.Data == null)
+			{
+				ApduBuffer = new byte[APDUCommand.APDU_MIN_LENGTH + ((ApduCmd.Le != 0) ? 1 : 0)];
+
+				if (ApduCmd.Le != 0)
+					ApduBuffer[4] = (byte) ApduCmd.Le;
+			}
+			else
+			{
+				ApduBuffer = new byte[APDUCommand.APDU_MIN_LENGTH + 1 + ApduCmd.Data.Length];
+
+				for (int nI = 0; nI < ApduCmd.Data.Length; nI++)
+					ApduBuffer[APDUCommand.APDU_MIN_LENGTH + 1 + nI] = ApduCmd.Data[nI];
+
+				ApduBuffer[APDUCommand.APDU_MIN_LENGTH] = (byte) ApduCmd.Data.Length;
+			}
+
+			ApduBuffer[0] = ApduCmd.Class;
+			ApduBuffer[1] = ApduCmd.Ins;
+			ApduBuffer[2] = ApduCmd.P1;
+			ApduBuffer[3] = ApduCmd.P2;
+
+			m_nLastError = SCardTransmit(m_hCard, ref ioRequest, ApduBuffer, (uint) ApduBuffer.Length, IntPtr.Zero, ApduResponse, out RecvLength); 
+			if (m_nLastError != 0)
+			{
+				string msg = "SCardTransmit error: " + m_nLastError;
+				throw new Exception(msg);
+			}
+			
+			byte[] ApduData = new byte[RecvLength];
+
+			for (int nI = 0; nI < RecvLength; nI++)
+				ApduData[nI] = ApduResponse[nI];
+
+			return new APDUResponse(ApduData);
+		}
+
+
+        /// <summary>
+        /// Wraps the PSCS function
+        /// LONG SCardBeginTransaction(
+        ///     SCARDHANDLE hCard
+        //  );
+        /// </summary>
+        public override void BeginTransaction()
+        {
+            if (m_hCard != 0)
+            {
+                m_nLastError = SCardBeginTransaction(m_hCard);
+                if (m_nLastError != 0)
+                {
+                    string msg = "SCardBeginTransaction error: " + m_nLastError;
+                    throw new Exception(msg);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Wraps the PCSC function
+        /// LONG SCardEndTransaction(
+        ///     SCARDHANDLE hCard,
+        ///     DWORD dwDisposition
+        /// );
+        /// </summary>
+        /// <param name="Disposition">A value from DISCONNECT enum</param>
+        public override void EndTransaction(DISCONNECT Disposition)
+        {
+            if (m_hCard != 0)
+            {
+                m_nLastError = SCardEndTransaction(m_hCard, (UInt32)Disposition);
+                if (m_nLastError != 0)
+                {
+                    string msg = "SCardEndTransaction error: " + m_nLastError;
+                    throw new Exception(msg);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the attributes of the card
+        /// </summary>
+        /// <param name="AttribId">Identifier for the Attribute to get</param>
+        /// <returns>Attribute content</returns>
+        public override byte[] GetAttribute(UInt32 AttribId)
+        {
+            byte[] attr = null;
+            UInt32 attrLen = 0;
+
+            m_nLastError = SCardGetAttrib(m_hCard, AttribId, attr, out attrLen);
+            if (m_nLastError == 0)
+            {
+                if (attrLen != 0)
+                {
+                    attr = new byte[attrLen];
+                    m_nLastError = SCardGetAttrib(m_hCard, AttribId, attr, out attrLen);
+                    if (m_nLastError != 0)
+                    {
+                        string msg = "SCardGetAttr error: " + m_nLastError;
+                        throw new Exception(msg);
+                    }
+                }
+            }
+            else
+            {
+                string msg = "SCardGetAttr error: " + m_nLastError;
+                throw new Exception(msg);
+            }
+
+            return attr;
+        }
+        #endregion
+
+        /// <summary>
+        /// This function must implement a card detection mechanism.
+        /// 
+        /// When card insertion is detected, it must call the method CardInserted()
+        /// When card removal is detected, it must call the method CardRemoved()
+        /// 
+        /// </summary>
+        protected override void RunCardDetection(object Reader)
+        {
+            bool bFirstLoop = true;
+            UInt32 hContext = 0;    // Local context
+            IntPtr phContext;
+
+            phContext = Marshal.AllocHGlobal(Marshal.SizeOf(hContext));
+
+            if (SCardEstablishContext((uint) SCOPE.User, IntPtr.Zero, IntPtr.Zero, phContext) == 0)
+            {
+                hContext = (uint)Marshal.ReadInt32(phContext);
+                Marshal.FreeHGlobal(phContext);
+
+                UInt32 nbReaders = 1;
+                SCard_ReaderState[] readerState = new SCard_ReaderState[nbReaders];
+
+                readerState[0].m_dwCurrentState = (UInt32) CARD_STATE.UNAWARE;
+                readerState[0].m_szReader = (string)Reader;
+
+                UInt32 eventState;
+                UInt32 currentState = readerState[0].m_dwCurrentState;
+
+                // Card detection loop
+                do
+                {
+                    if (SCardGetStatusChange(hContext, WAIT_TIME
+                        , readerState, nbReaders) == 0)
+                    {
+                        eventState = readerState[0].m_dwEventState;
+                        currentState = readerState[0].m_dwCurrentState;
+
+                        // Check state
+                        if (((eventState & (uint) CARD_STATE.CHANGED) == (uint) CARD_STATE.CHANGED) && !bFirstLoop)    
+                        {
+                            // State has changed
+                            if ((eventState & (uint) CARD_STATE.EMPTY) == (uint) CARD_STATE.EMPTY)
+                            {
+                                // There is no card, card has been removed -> Fire CardRemoved event
+                                CardRemoved(this, new CardRemovedEventArgs());
+                            }
+
+                            if (((eventState & (uint)CARD_STATE.PRESENT) == (uint)CARD_STATE.PRESENT) && 
+                                ((eventState & (uint) CARD_STATE.PRESENT) != (currentState & (uint) CARD_STATE.PRESENT)))
+                            {
+                                // There is a card in the reader -> Fire CardInserted event
+                                CardInserted(this, new CardInsertedEventArgs());
+                            }
+
+                            if ((eventState & (uint) CARD_STATE.ATRMATCH) == (uint) CARD_STATE.ATRMATCH)
+                            {
+                                // There is a card in the reader and it matches the ATR we were expecting-> Fire CardInserted event
+                                CardInserted(this, new CardInsertedEventArgs());
+                            }
+                        }
+
+                        // The current stateis now the event state
+                        readerState[0].m_dwCurrentState = eventState;
+
+                        bFirstLoop = false;
+                    }
+
+                    Thread.Sleep(100);
+
+                    if (m_bRunCardDetection == false)
+                        break;
+                }
+                while (true);    // Exit on request
+            }
+            else
+            {
+                Marshal.FreeHGlobal(phContext);
+                throw new Exception("PC/SC error");
+            }
+
+            SCardReleaseContext(hContext);
+        }
+	}
+}

GemCard/CardRemovedEventArgs.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace GemCard
+{
+    public class CardRemovedEventArgs : EventArgs
+    {
+        public CardRemovedEventArgs() { }
+    }
+}

GemCard/GemCard.csproj

@@ -0,0 +1,194 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <ProjectType>Local</ProjectType>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}</ProjectGuid>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ApplicationIcon>
+    </ApplicationIcon>
+    <AssemblyKeyContainerName>
+    </AssemblyKeyContainerName>
+    <AssemblyName>GemCard</AssemblyName>
+    <AssemblyOriginatorKeyFile>
+    </AssemblyOriginatorKeyFile>
+    <DefaultClientScript>JScript</DefaultClientScript>
+    <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>
+    <DefaultTargetSchema>IE50</DefaultTargetSchema>
+    <DelaySign>false</DelaySign>
+    <OutputType>Library</OutputType>
+    <RootNamespace>GemCard</RootNamespace>
+    <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
+    <StartupObject>
+    </StartupObject>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <OutputPath>bin\Debug\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <BaseAddress>285212672</BaseAddress>
+    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
+    <ConfigurationOverrideFile>
+    </ConfigurationOverrideFile>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <DebugSymbols>true</DebugSymbols>
+    <FileAlignment>4096</FileAlignment>
+    <NoStdLib>false</NoStdLib>
+    <NoWarn>
+    </NoWarn>
+    <Optimize>false</Optimize>
+    <RegisterForComInterop>false</RegisterForComInterop>
+    <RemoveIntegerChecks>false</RemoveIntegerChecks>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <OutputPath>bin\Release\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <BaseAddress>285212672</BaseAddress>
+    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
+    <ConfigurationOverrideFile>
+    </ConfigurationOverrideFile>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <DebugSymbols>false</DebugSymbols>
+    <FileAlignment>4096</FileAlignment>
+    <NoStdLib>false</NoStdLib>
+    <NoWarn>
+    </NoWarn>
+    <Optimize>true</Optimize>
+    <RegisterForComInterop>false</RegisterForComInterop>
+    <RemoveIntegerChecks>false</RemoveIntegerChecks>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <BaseAddress>285212672</BaseAddress>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <FileAlignment>4096</FileAlignment>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <BaseAddress>285212672</BaseAddress>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Optimize>true</Optimize>
+    <FileAlignment>4096</FileAlignment>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System">
+      <Name>System</Name>
+    </Reference>
+    <Reference Include="System.Data">
+      <Name>System.Data</Name>
+    </Reference>
+    <Reference Include="System.Xml">
+      <Name>System.XML</Name>
+    </Reference>
+    <COMReference Include="GemCardExLib">
+      <Guid>{F1FF634B-BEDF-461C-A409-5B88E05F5117}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+    </COMReference>
+    <COMReference Include="SCARDSSPLib">
+      <Guid>{82C38704-19F1-11D3-A11F-00C04F79F800}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+    </COMReference>
+    <COMReference Include="stdole">
+      <Guid>{00020430-0000-0000-C000-000000000046}</Guid>
+      <VersionMajor>2</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>primary</WrapperTool>
+      <Isolated>False</Isolated>
+    </COMReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="APDUCommand.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="APDUParam.cs" />
+    <Compile Include="APDUResponse.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="CardBase.cs" />
+    <Compile Include="CardInsertedEventArgs.cs" />
+    <Compile Include="CardNative.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="CardRemovedEventArgs.cs" />
+    <Compile Include="ICard.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="SmartCardException.cs">
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+</Project>

GemCard/GemCard.csproj.user

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <LastOpenVersion>8.0.50215</LastOpenVersion>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ReferencePath>
+    </ReferencePath>
+    <CopyProjectDestinationFolder>
+    </CopyProjectDestinationFolder>
+    <CopyProjectUncPath>
+    </CopyProjectUncPath>
+    <CopyProjectOption>0</CopyProjectOption>
+    <ProjectView>ProjectFiles</ProjectView>
+    <ProjectTrust>0</ProjectTrust>
+    <PublishUrlHistory />
+    <InstallUrlHistory />
+    <SupportUrlHistory />
+    <UpdateUrlHistory />
+    <BootstrapperUrlHistory />
+    <ErrorReportUrlHistory />
+    <FallbackCulture>en-US</FallbackCulture>
+    <VerifyUploadedFiles>false</VerifyUploadedFiles>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <EnableASPDebugging>false</EnableASPDebugging>
+    <EnableASPXDebugging>false</EnableASPXDebugging>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+    <EnableSQLServerDebugging>false</EnableSQLServerDebugging>
+    <RemoteDebugEnabled>false</RemoteDebugEnabled>
+    <RemoteDebugMachine>
+    </RemoteDebugMachine>
+    <StartAction>Project</StartAction>
+    <StartArguments>
+    </StartArguments>
+    <StartPage>
+    </StartPage>
+    <StartProgram>
+    </StartProgram>
+    <StartURL>
+    </StartURL>
+    <StartWorkingDirectory>
+    </StartWorkingDirectory>
+    <StartWithIE>true</StartWithIE>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <EnableASPDebugging>false</EnableASPDebugging>
+    <EnableASPXDebugging>false</EnableASPXDebugging>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+    <EnableSQLServerDebugging>false</EnableSQLServerDebugging>
+    <RemoteDebugEnabled>false</RemoteDebugEnabled>
+    <RemoteDebugMachine>
+    </RemoteDebugMachine>
+    <StartAction>Project</StartAction>
+    <StartArguments>
+    </StartArguments>
+    <StartPage>
+    </StartPage>
+    <StartProgram>
+    </StartProgram>
+    <StartURL>
+    </StartURL>
+    <StartWorkingDirectory>
+    </StartWorkingDirectory>
+    <StartWithIE>false</StartWithIE>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <StartWithIE>true</StartWithIE>
+  </PropertyGroup>
+</Project>

GemCard/ICard.cs

@@ -0,0 +1,149 @@
+using System;
+
+namespace GemCard
+{
+	/// <summary>
+	/// This interface gives access to the basic card functions. It must be implemented by a class.
+	/// </summary>
+	public interface	ICard
+	{
+		/// <summary>
+		/// Wraps the PCSC funciton
+		/// LONG SCardListReaders(SCARDCONTEXT hContext, 
+		///		LPCTSTR mszGroups, 
+		///		LPTSTR mszReaders, 
+		///		LPDWORD pcchReaders 
+		///	);
+		/// </summary>
+		/// <returns>A string array of the readers</returns>
+		string[] ListReaders();
+
+		/// <summary>
+		///  Wraps the PCSC function
+		///  LONG SCardConnect(
+		///		IN SCARDCONTEXT hContext,
+		///		IN LPCTSTR szReader,
+		///		IN DWORD dwShareMode,
+		///		IN DWORD dwPreferredProtocols,
+		///		OUT LPSCARDHANDLE phCard,
+		///		OUT LPDWORD pdwActiveProtocol
+		///	);
+		/// </summary>
+		/// <param name="Reader"></param>
+		/// <param name="ShareMode"></param>
+		/// <param name="PreferredProtocols"></param>
+		void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols);
+
+		/// <summary>
+		/// Wraps the PCSC function
+		///	LONG SCardDisconnect(
+		///		IN SCARDHANDLE hCard,
+		///		IN DWORD dwDisposition
+		///	);
+		/// </summary>
+		/// <param name="Disposition"></param>
+		void Disconnect(DISCONNECT Disposition);
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardTransmit(
+		///		SCARDHANDLE hCard,
+		///		LPCSCARD_I0_REQUEST pioSendPci,
+		///		LPCBYTE pbSendBuffer,
+		///		DWORD cbSendLength,
+		///		LPSCARD_IO_REQUEST pioRecvPci,
+		///		LPBYTE pbRecvBuffer,
+		///		LPDWORD pcbRecvLength
+		///	);
+		/// </summary>
+		/// <param name="ApduCmd">APDUCommand object with the APDU to send to the card</param>
+		/// <returns>An APDUResponse object with the response from the card</returns>
+		APDUResponse Transmit(APDUCommand ApduCmd);
+
+        /// <summary>
+        /// Wraps the PSCS function
+        /// LONG SCardBeginTransaction(
+        ///     SCARDHANDLE hCard
+        //  );
+        /// </summary>
+        void BeginTransaction();
+
+        /// <summary>
+        /// Wraps the PCSC function
+        /// LONG SCardEndTransaction(
+        ///     SCARDHANDLE hCard,
+        ///     DWORD dwDisposition
+        /// );
+        /// </summary>
+        void EndTransaction(DISCONNECT Disposition);
+
+        /// <summary>
+        /// Gets the attributes of the card
+        /// </summary>
+        /// <param name="AttribId">Identifier for the Attribute to get</param>
+        /// <returns>Attribute content</returns>
+        byte[] GetAttribute(UInt32 AttribId);
+	}
+
+	/// <summary>
+	/// SCOPE context
+	/// </summary>
+	public enum SCOPE
+	{
+		/// <summary>
+		/// The context is a user context, and any database operations are performed within the
+		/// domain of the user.
+		/// </summary>
+		User,		
+
+		/// <summary>
+		/// The context is that of the current terminal, and any database operations are performed
+		/// within the domain of that terminal.  (The calling application must have appropriate
+		/// access permissions for any database actions.)
+		/// </summary>
+		Terminal,	
+
+		/// <summary>
+		/// The context is the system context, and any database operations are performed within the
+		/// domain of the system.  (The calling application must have appropriate access
+		/// permissions for any database actions.)
+		/// </summary>
+		System	
+	}
+
+	/// <summary>
+	/// SHARE mode enumeration
+	/// </summary>
+	public enum SHARE
+	{
+        Exclusive = 1,	/// This app. is not willing to share this card with other applications.
+        Shared,			/// This app. is willing to share this card with other applications.
+        Direct, 		/// This app. demands direct control of the reader, so it is not available to other applications.
+	}
+
+
+	/// <summary>
+	/// PROTOCOL enumeration
+	/// </summary>
+	public enum PROTOCOL
+	{
+        Undefined = 0x00000000,	                    /// There is no active protocol.
+        T0        = 0x00000001,	                    /// T=0 is the active protocol.
+        T1        = 0x00000002,	                    /// T=1 is the active protocol.
+        T0orT1    = T0 | T1,                        /// T=1 or T=0 can be the active protocol
+        Raw       = 0x00010000,                     /// Raw is the active protocol.
+		Default   = unchecked ((int) 0x80000000),   /// Use implicit PTS.
+	}
+
+
+	/// <summary>
+	/// DISCONNECT action enumeration
+	/// </summary>
+	public enum DISCONNECT
+	{
+        Leave,		/// Don't do anything special on close
+        Reset,		/// Reset the card on close
+        Unpower,	/// Power down the card on close
+        Eject,	    /// Eject(!) the card on close
+	}
+}

GemCard/SmartCardException.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace GemCard
+{
+	/// <summary>
+	///  Smart card exceptions
+	/// </summary>
+	public class SmartCardException : Exception
+	{
+
+		public SmartCardException() : base("Smart card exception")
+		{
+		}
+
+		public SmartCardException(string Message) : base(Message)
+		{
+		}
+	}
+
+
+    public class ApduCommandException : Exception
+    {
+		public const	string
+			NotValidDocument = "The file is not a valid APDU command document",
+			NoSuchCommand = "No such APDU command in the document",
+            ParamLeFormat = "Le parameter format is not correct",
+            ParamP3Format = "P3 parameter format is not correct",
+            NoSuchSequence = "No such APDU sequence in the document", 
+            MissingApduOrCommand = "An Apdu or a Sequence is missing in this Sequence";
+            
+		public ApduCommandException() : base("APDU command exception")
+		{
+		}
+
+		public ApduCommandException(string Message) : base(Message)
+		{
+		}
+
+    }
+}

GraphLib/GraphLib.csproj

@@ -75,7 +75,6 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
-    <Compile Include="PrecisionTimer.cs" />
     <Compile Include="Utils.cs" />
   </ItemGroup>
   <ItemGroup>

GraphLib/PlotterDisplayEx.cs

@@ -43,11 +43,6 @@ namespace GraphLib
         PlotterGraphSelectCurvesForm GraphPropertiesForm = null;
         PrintPreviewForm printPreviewForm = null;
 
-        private PrecisionTimer.Timer mTimer = null;
-        private float play_speed = 0.5f;
-        private float play_speed_max = 10f;
-        private float play_speed_min = 0.5f;
-
         private bool paused = false;
         private bool isRunning = false;
 
@@ -58,11 +53,6 @@ namespace GraphLib
         public PlotterDisplayEx()
         {
             InitializeComponent();
-            mTimer = new PrecisionTimer.Timer();
-            mTimer.Period = 50;                         // 20 fps
-            mTimer.Tick += new EventHandler(OnTimerTick);
-            play_speed = 0.5f; // 20x10 = 200 values per second == sample frequency     
-            mTimer.Start();
             isRunning = false;
         }
        
@@ -192,85 +182,10 @@ namespace GraphLib
 
         protected override void Dispose(bool disposing)
         {
-            paused = true;
-
-            if (mTimer.IsRunning)
-            {
-                mTimer.Stop();
-                mTimer.Dispose();
-            }
-            
+            paused = true;            
             base.Dispose(disposing);
         }
 
-        public void Start()
-        {
-            if (isRunning == false && paused == false)
-            {
-                gPane.starting_idx = 0;
-                paused = false;
-                isRunning = true;
-               // mTimer.Start();                
-                tb1.Buttons[0].ImageIndex = 2;                
-            }
-            else
-            {
-                if (paused == false)
-                {
-                    //mTimer.Stop();
-                    paused = true;
-                }
-                else
-                {
-                   // mTimer.Start();
-                    paused = false;
-                }
-
-                if (paused)
-                {
-                    
-                    tb1.Buttons[0].ImageIndex = 0;  
-                }
-                else
-                {
-                   
-                    tb1.Buttons[0].ImageIndex = 2;  
-                }
-            }
-        }
-
-        public void Stop()
-        {
-            if (isRunning)
-            {
-               // mTimer.Stop();
-                isRunning = false;
-                paused = false;
-                hScrollBar1.Value = 0;
-                tb1.Buttons[0].ImageIndex = 0;
-            }
-        }
-
-       
-        private void tb1_ButtonClick(object sender, ToolBarButtonClickEventArgs e)
-        {
-            bool pushed = e.Button.Pushed;
-            switch (e.Button.Tag.ToString().ToLower())
-            {
-                case "play":
-
-                    Start();
-                      
-                    break;
-
-                case "stop":
-
-                    Stop();
-                   
-                    break;       
-            }
-        }
-
         private void SetPlayPanelVisible()
         {
             panel1.Visible = true;          
@@ -317,27 +232,6 @@ namespace GraphLib
             {
             }
         }
-
-        private void UpdatePlayback()
-        {
-            if (!paused && isRunning == true)
-            {
-                try
-                {
-                    gPane.starting_idx += play_speed;
-                    UpdateScrollBar();
-                    gPane.Invalidate();
-                }
-                catch { }
-            }
-        }
-
-        private void OnTimerTick(object sender, EventArgs e)
-        {
-            UpdateControl();
-
-            UpdatePlayback();
-        }
         
         private void UpdateScrollBar()
         {

GraphLib/PlotterDisplayEx.designer.cs

@@ -57,7 +57,6 @@ namespace GraphLib
 			this.tb1.Size = new System.Drawing.Size(80, 26);
 			this.tb1.TabIndex = 1;
 			this.tb1.Visible = false;
-			this.tb1.ButtonClick += new System.Windows.Forms.ToolBarButtonClickEventHandler(this.tb1_ButtonClick);
 			// 
 			// tbbSave
 			// 

GraphLib/PrecisionTimer.cs

@@ -1,490 +0,0 @@
-using System;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-
-#region License
-
-/*  
- * Based on the work of  Leslie Sanford  
- */
-
-#endregion
-
-
-namespace PrecisionTimer
-{    
-    public enum Mode
-    {        
-        OneShot,        
-        Periodic
-    };
-    
-    [StructLayout(LayoutKind.Sequential)]
-    public struct TimerCaps
-    {       
-        public int periodMin;       
-        public int periodMax;
-    }
-
-    
-    public sealed class Timer : IComponent
-    {       
-        private delegate void TimeProc(int id, int msg, int user, int param1, int param2);
-
-        private delegate void EventRaiser(EventArgs e);
-            
-        [DllImport("winmm.dll")]
-        private static extern int timeGetDevCaps(ref TimerCaps caps,
-                                                 int sizeOfTimerCaps);
-
-        [DllImport("winmm.dll")]
-        private static extern int timeSetEvent(int delay, 
-                                               int resolution,
-                                               TimeProc proc, 
-                                               int user, 
-                                               int mode);
-
-        [DllImport("winmm.dll")]
-        private static extern int timeKillEvent(int id);
-
-        private const int TIMERR_NOERROR = 0;
-        
-        private int timerID;
-
-        private volatile Mode mode;
-        
-        private volatile int period;
-
-        private volatile int resolution;        
-        
-        private TimeProc timeProcPeriodic;
-
-        private TimeProc timeProcOneShot;
-
-        private EventRaiser tickRaiser;
-
-        private bool running = false;
-
-        private volatile bool disposed = false;
-
-        private ISynchronizeInvoke synchronizingObject = null;
-
-        private ISite site = null;
-
-        private static TimerCaps caps;      
-         
-        public event EventHandler Started;
-         
-        public event EventHandler Stopped;
-         
-        public event EventHandler Tick;
-         
-        static Timer()
-        {
-            // Get multimedia timer capabilities.
-            timeGetDevCaps(ref caps, Marshal.SizeOf(caps));
-        }
-
-        
-        public Timer(IContainer container)
-        {
-            
-            container.Add(this);
-
-            Initialize();
-        }
-
-         
-        public Timer()
-        {
-            Initialize();
-        }
-
-        ~Timer()
-        {
-            if(IsRunning)
-            {
-                // Stop and destroy timer.
-                timeKillEvent(timerID);
-            }
-        }
-
-        private void Initialize()
-        {
-            this.mode = Mode.Periodic;
-            this.period = Capabilities.periodMin;
-            this.resolution = 1;
-
-            running = false;
-
-            timeProcPeriodic = new TimeProc(TimerPeriodicEventCallback);
-            timeProcOneShot = new TimeProc(TimerOneShotEventCallback);
-            tickRaiser = new EventRaiser(OnTick);
-        }
-
-        
-        public void Start()
-        {
-            
-            if(disposed)
-            {
-                throw new ObjectDisposedException("Timer");
-            }
- 
-            if(IsRunning)
-            {
-                return;
-            }
-           
-            if(Mode == Mode.Periodic)
-            {
-                 timerID = timeSetEvent(Period, Resolution, timeProcPeriodic, 0, (int)Mode);
-            }
-            else
-            {
-                  timerID = timeSetEvent(Period, Resolution, timeProcOneShot, 0, (int)Mode);
-            }
-
-            if(timerID != 0)
-            {
-                running = true;
-
-                if(SynchronizingObject != null && SynchronizingObject.InvokeRequired)
-                {
-                    SynchronizingObject.BeginInvoke(
-                        new EventRaiser(OnStarted), 
-                        new object[] { EventArgs.Empty });
-                }
-                else
-                {
-                    OnStarted(EventArgs.Empty);
-                }                
-            }
-            else
-            {
-                throw new TimerException("Unable to start timer.");
-            }
-        }
-
-        
-        public void Stop()
-        {
-            
-            if(disposed)
-            {
-                throw new ObjectDisposedException("Timer");
-            }
-                        
-            if(!running)
-            {
-                return;
-            }
-
-                       
-            int result = timeKillEvent(timerID);
-
-            Debug.Assert(result == TIMERR_NOERROR);
-
-            running = false;
-
-            if(SynchronizingObject != null && SynchronizingObject.InvokeRequired)
-            {
-                SynchronizingObject.BeginInvoke(
-                    new EventRaiser(OnStopped), 
-                    new object[] { EventArgs.Empty });
-            }
-            else
-            {
-                OnStopped(EventArgs.Empty);
-            }
-        }        
-
-         
-        private void TimerPeriodicEventCallback(int id, int msg, int user, int param1, int param2)
-        {
-            if(synchronizingObject != null)
-            {
-                synchronizingObject.BeginInvoke(tickRaiser, new object[] { EventArgs.Empty });
-            }
-            else
-            {
-                OnTick(EventArgs.Empty);
-            }
-        }
-      
-        private void TimerOneShotEventCallback(int id, int msg, int user, int param1, int param2)
-        {
-            if(synchronizingObject != null)
-            {
-                synchronizingObject.BeginInvoke(tickRaiser, new object[] { EventArgs.Empty });
-                Stop();
-            }
-            else
-            {
-                OnTick(EventArgs.Empty);
-                Stop();
-            }
-        }
-
-        
-       
-        // Raises the Disposed event.
-        private void OnDisposed(EventArgs e)
-        {
-            EventHandler handler = Disposed;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-        // Raises the Started event.
-        private void OnStarted(EventArgs e)
-        {
-            EventHandler handler = Started;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-        // Raises the Stopped event.
-        private void OnStopped(EventArgs e)
-        {
-            EventHandler handler = Stopped;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-        // Raises the Tick event.
-        private void OnTick(EventArgs e)
-        {
-            EventHandler handler = Tick;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-      
-       
-       
-
-        /// <summary>
-        /// Gets or sets the object used to marshal event-handler calls.
-        /// </summary>
-        public ISynchronizeInvoke SynchronizingObject
-        {
-            get
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                #endregion
-
-                return synchronizingObject;
-            }
-            set
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                #endregion
-
-                synchronizingObject = value;
-            }
-        }
-
-         
-        public int Period
-        {
-            get
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                #endregion
-
-                return period;
-            }
-            set
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-                else if(value < Capabilities.periodMin || value > Capabilities.periodMax)
-                {
-                    throw new ArgumentOutOfRangeException("Period", value,
-                        "Multimedia Timer period out of range.");
-                }
-
-                #endregion
-
-                period = value;
-
-                if(IsRunning)
-                {
-                    Stop();
-                    Start();
-                }
-            }
-        }
-
-       
-        public int Resolution
-        {
-            get
-            {
-                
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-                
-                return resolution;
-            }
-            set
-            {               
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-                else if(value < 0)
-                {
-                    throw new ArgumentOutOfRangeException("Resolution", value,
-                        "timer resolution out of range.");
-                }
-
-                resolution = value;
-
-                if(IsRunning)
-                {
-                    Stop();
-                    Start();
-                }
-            }
-        }
-        
-        public Mode Mode
-        {
-            get
-            {
-                
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                
-                return mode;
-            }
-            set
-            {
-               
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                 
-                mode = value;
-
-                if(IsRunning)
-                {
-                    Stop();
-                    Start();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether the Timer is running.
-        /// </summary>
-        public bool IsRunning
-        {
-            get
-            {
-                return running;
-            }
-        }
-
-        /// <summary>
-        /// Gets the timer capabilities.
-        /// </summary>
-        public static TimerCaps Capabilities
-        {
-            get
-            {
-                return caps;
-            }
-        }
-
-      
-      
-      
-        public event System.EventHandler Disposed;
-
-        public ISite Site
-        {
-            get
-            {
-                return site;
-            }
-            set
-            {
-                site = value;
-            }
-        }
-
-       
-        public void Dispose()
-        {
-            
-            if(disposed)
-            {
-                return;
-            }
-            
-            if(IsRunning)
-            {
-                Stop();
-            }
-
-            disposed = true;
-
-            OnDisposed(EventArgs.Empty);
-        }
-
-        
-    }
-
-    
-    public class TimerException : ApplicationException
-    {       
-        public TimerException(string message) : base(message)
-        {
-        }
-    }
-}

Results/Entities/TestRslt.cs

@@ -26,8 +26,9 @@ namespace Results.Entities
 		public virtual int FlowSetTime { get; set; }        /// [s]     Measurement time in seconds
 		public virtual double TestTime { get; set; }        /// [s]     Measurement time in seconds
 		public virtual double PulsesMaster { get; set; }
-		public virtual double ConstMaster { get; set; }     /// [pls/l] Pulses per liter master flow meter
-		public virtual double MassStartRaw { get; set; }	/// [kg]
+        public virtual double ConstMasterRaw { get; set; }  /// [l/pls] Liters per pulse of the master flow meter uncorrected
+        public virtual double ConstMaster { get; set; }     /// [l/pls] Liters per pulse of the master flow meter
+        public virtual double MassStartRaw { get; set; }	/// [kg]
 		public virtual double MassStart { get; set; }		/// [kg]
 		public virtual double MassEndRaw { get; set; }		/// [kg]
 		public virtual double MassEnd { get; set; }			/// [kg]
@@ -128,9 +129,10 @@ namespace Results.Entities
 		public virtual double TargetVolume() { return TestData.TargetVolume; }
 		public virtual double TargetTime()	 { return TestData.TargetTime; }
 		public virtual string Method()		 { return TestData.Method; }
-        public virtual bool IsPMaxTest()     { return (MethodClass != null) && (MethodClass.Contains("PMaxTest") || MethodClass.Contains("LeakTest")); }
-        public virtual bool IsStartStop()    { return (MethodClass != null) && MethodClass.Contains("FixedStart"); }
-        public virtual bool IsDiverter()     { return (MethodClass != null) && MethodClass.Contains("FlyingStart") && MethodClass.Contains("MassColl"); }
+        public virtual bool IsRelErrTest()   { return (MethodClass != null) ? (MethodClass.Contains("FixedStart") || MethodClass.Contains("FlyingStart") || MethodClass.Contains("CombinedWithDetection")) : true; }
+        public virtual bool IsPMaxTest()     { return (MethodClass != null) ? (MethodClass.Contains("PMaxTest") || MethodClass.Contains("LeakTest")) : true; }
+        public virtual bool IsStartStop()    { return (MethodClass != null) ? MethodClass.Contains("FixedStart") : true; }
+        public virtual bool IsDiverter()     { return (MethodClass != null) ? (MethodClass.Contains("FlyingStart") && MethodClass.Contains("MassColl")) : true; }
 
 		public virtual double ErrLimLo()
         {
@@ -215,6 +217,7 @@ namespace Results.Entities
 		    FlowSetTime = src.FlowSetTime;
 		    TestTime = src.TestTime;
 		    PulsesMaster = src.PulsesMaster;
+            ConstMasterRaw = src.ConstMasterRaw;
 		    ConstMaster = src.ConstMaster;
 		    MassStartRaw = src.MassStartRaw;
 		    MassStart = src.MassStart;

Results/ItemID.cs

@@ -68,7 +68,7 @@ namespace Results
         WM_Position,                    /// 58
         End_state,                      /// 59
         Pulses,                         /// 60
-        Pulses__liter,                  /// 61  Water meter constant (pulses per liter) specific for one test
+        Pulse__liter,                   /// 61  Water meter constant (pulses per liter) specific for one test
         Reference_pulses_ni,            /// 62  Reference pulses gated for specific meter (synchro method)
         Reference_energy,				/// 63
         Test_bench_ID,                  /// 64
@@ -243,7 +243,14 @@ namespace Results
         Timestamp_end,                      /// 211
         P_PMax_test_mean,                   /// 212  PMax test pressure mean of (Pup + Pdown)/2
 
-        Medium,                             /// 213  Woda zimna/tepla
+        Medium,                         /// 213  Woda zimna/ciepla
+
+        Flow_ctv,                       /// 214
+        Flow_ctv_min,                   /// 215
+        Flow_ctv_max,                   /// 216
+        Flow_ctv_start,                 /// 217
+        Flow_ctv_end,                   /// 218
+        ConstMasterRaw,                 /// 219  ConstMaster (like 194) uncorrected
 
         Count,
     }

Results/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.18.877.0")]
-[assembly: AssemblyFileVersion("2.18.877.0")]
+[assembly: AssemblyVersion("2.18.918.0")]
+[assembly: AssemblyFileVersion("2.18.918.0")]

Results/Results.csproj

@@ -18,7 +18,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TORINO50;LANG_IT</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <PlatformTarget>x86</PlatformTarget>
@@ -27,7 +27,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TORINO50;LANG_IT</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>

Results/Utils.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2016 Sensus Metering Systems
+/// Copyright (c) 2016-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Text;
@@ -31,110 +31,6 @@ namespace Results
             }
         }
 
-		
-        /// <summary>
-        /// Converts float number to a string with the specified number of significant digits
-        /// </summary>
-        /// <param name="value">Float value to be converted to a string</param>
-        /// <param name="validDigits">Number of significant digits: 4, 3, or 2 (otherwise a full precision number is printed)</param>
-        /// <returns>String representation of the float number</returns>
-        public static string DoubleToStr(double value, int validDigits)
-        {
-			if (-float.Epsilon <= value && value <= float.Epsilon)
-			{
-				return "0";
-			}
-            else if (validDigits == 4)
-            {
-                if (value >= 999.5 || value < -999.5) return value.ToString("F0");
-                else if (value >= 99.95 || value < -99.95) return value.ToString("F1");
-                else if (value >= 9.995 || value < -9.995) return value.ToString("F2");
-                else if (value >= 0.9995 || value < -0.9995) return value.ToString("F3");
-                else if (value >= 0.09995 || value < -0.09995) return value.ToString("F4");
-                else if (value >= 0.009995 || value < -0.009995) return value.ToString("F5");
-                else return value.ToString("F6");
-            }
-            else if (validDigits == 3)
-            {
-                if (value >= 99.5 || value < -99.5) return value.ToString("F0");
-                else if (value >= 9.95 || value < -9.95) return value.ToString("F1");
-                else if (value >= 0.995 || value < -0.995) return value.ToString("F2");
-                else if (value >= 0.0995 || value < -0.0995) return value.ToString("F3");
-                else if (value >= 0.00995 || value < -0.00995) return value.ToString("F4");
-                else if (value >= 0.000995 || value < -0.000995) return value.ToString("F5");
-                else return value.ToString("F6");
-            }
-            else if (validDigits == 2)
-            {
-                if (value >= 9.5 || value < -9.5) return value.ToString("F0");
-                else if (value >= 0.95 || value < -0.95) return value.ToString("F1");
-                else if (value >= 0.095 || value < -0.095) return value.ToString("F2");
-                else if (value >= 0.0095 || value < -0.0095) return value.ToString("F3");
-                else if (value >= 0.00095 || value < -0.00095) return value.ToString("F4");
-                else return value.ToString("F5");
-            }
-            else return value.ToString();
-        }
-
-
-        public static string SignificantDigitsToFmt(double value, int sigDigits)
-        {
-            if (sigDigits == 5)
-            {
-                if (value >= 9999.5 || value < -9999.5) return "F0";
-                else if (value >= 999.95 || value < -999.95) return "F1";
-                else if (value >= 99.995 || value < -99.995) return "F2";
-                else if (value >= 9.9995 || value < -9.9995) return "F3";
-                else if (value >= 0.99995 || value < -0.99995) return "F4";
-                else if (value >= 0.099995 || value < -0.099995) return "F5";
-                else if (value >= 0.0099995 || value < -0.0099995) return "F6";
-                else if (value >= 0.00099995 || value < -0.00099995) return "F7";
-                else if (value >= 0.000099995 || value < -0.000099995) return "F8";
-                else return "F9";
-            }
-            else if (sigDigits == 4)
-            {
-                if (value >= 999.5 || value < -999.5) return "F0";
-                else if (value >= 99.95 || value < -99.95) return "F1";
-                else if (value >= 9.995 || value < -9.995) return "F2";
-                else if (value >= 0.9995 || value < -0.9995) return "F3";
-                else if (value >= 0.09995 || value < -0.09995) return "F4";
-                else if (value >= 0.009995 || value < -0.009995) return "F5";
-                else if (value >= 0.0009995 || value < -0.0009995) return "F6";
-                else if (value >= 0.00009995 || value < -0.00009995) return "F7";
-                else return "F8";
-            }
-            else if (sigDigits == 3)
-            {
-                if (value >= 99.5 || value < -99.5) return "F0";
-                else if (value >= 9.95 || value < -9.95) return "F1";
-                else if (value >= 0.995 || value < -0.995) return "F2";
-                else if (value >= 0.0995 || value < -0.0995) return "F3";
-                else if (value >= 0.00995 || value < -0.00995) return "F4";
-                else if (value >= 0.000995 || value < -0.000995) return "F5";
-                else if (value >= 0.0000995 || value < -0.0000995) return "F6";
-                else return "F7";
-            }
-            else if (sigDigits == 2)
-            {
-                if (value >= 9.5 || value < -9.5) return "F0";
-                else if (value >= 0.95 || value < -0.95) return "F1";
-                else if (value >= 0.095 || value < -0.095) return "F2";
-                else if (value >= 0.0095 || value < -0.0095) return "F3";
-                else if (value >= 0.00095 || value < -0.00095) return "F4";
-                else if (value >= 0.000095 || value < -0.000095) return "F5";
-                else return "F6";
-            }
-            else /// if (sigDigits == 1)
-            {
-                if (value >= 0.95 || value < -0.95) return "F0";
-                else if (value >= 0.095 || value < -0.095) return "F1";
-                else if (value >= 0.0095 || value < -0.0095) return "F2";
-                else if (value >= 0.00095 || value < -0.00095) return "F3";
-                else if (value >= 0.000095 || value < -0.000095) return "F4";
-                else return "F5";
-            }
-        }
 
         /// <summary>
         /// Converts ErrorFlags integer to string. Supports up to 31 flags (E1..E31).
@@ -170,6 +66,5 @@ namespace Results
             return (useRedGreenColor) ? (passed ? "OK|Green" : "NOK|Red")        : (passed ? "OK|White" : "NOK|White");
 #endif
         }
-
     }
 }

Results/WMeterRsltItemSpec.cs

@@ -176,7 +176,7 @@ namespace Results
 			AllItems.Add(new WMeterRsltItemSpec(ItemID.Density,            Strings.Density + " ()",                         Quantity.Density, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V4", w.GetTestRslt(t).DensityLine)));
 			AllItems.Add(new WMeterRsltItemSpec(ItemID.Density_correction, Strings.Density_correction + " ()",              Quantity.Density, ItemCategory.TestResult, (w, t, u, f, p) => FormatDbl(u, f, p, "V3", (w.Batch.DensityCorr))));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Rho_Wa_calc,        string.Format("{0} of sample", Strings.Density), Quantity.Density, ItemCategory.TestResult, (w, t, u, f, p) => FormatDbl(u, f, p, "V4", RealDensity)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.RhoDistilledWtrAtMeLineTemp, string.Format("{0} of distilled water at T line", Strings.Density), Quantity.Density, ItemCategory.TestResult, (w, t, u, f, p) => FormatDbl(u, f, p, "V4", (w.GetTestRslt(t) == null) ? 0 : Config.Formulas.DistilledWaterDensityFromTemp(w.GetTestRslt(t).AmbTempMean))));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.RhoDistilledWtrAtMeLineTemp, string.Format("{0} of distilled water at T line", Strings.Density), Quantity.Density, ItemCategory.TestResult, (w, t, u, f, p) => FormatDbl(u, f, p, "V4", (w.GetTestRslt(t) == null) ? 0 : Config.Formulas.DistilledWaterDensityFromTemp((w.GetTestRslt(t).TempUpMean + w.GetTestRslt(t).TempDownMean) / 2))));
 
 			///
             /// Date and time 
@@ -187,33 +187,39 @@ namespace Results
             ///
             /// Time (duration) 
             ///
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_time,              Strings.T_s + "()",                                    Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).IsPMaxTest() ? 0 : w.GetTestRslt(t).TestTime)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_time_ni,           Strings.T_s + "_ni()",                                 Quantity.Time, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null || w.GetTestRslt(t).IsPMaxTest()) ? "" : FormatDbl(u, f, p, "V3", w.GetMeterTestRslt(t).TestTime)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.PMax_test_time,         "Pressure test time ()",     "Pressure test time",     Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null || !w.GetTestRslt(t).IsPMaxTest()) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).TestTime)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Diverter_start_time,    "Diverter start time ()",    "Diverter start time",    Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).IsDiverter() ? w.GetTestRslt(t).DiverterStart : 0)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Diverter_end_time,      "Diverter end time ()",      "Diverter end time",      Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).IsDiverter() ? w.GetTestRslt(t).DiverterEnd : 0)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Start_valve_open_time,  "Start valve open time ()",  "Start valve open time",  Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).IsStartStop() ? w.GetTestRslt(t).DiverterStart : 0)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Start_valve_close_time, "Start valve close time ()", "Start valve close time", Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).IsStartStop() ? w.GetTestRslt(t).DiverterEnd : 0)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Timestamp_start,        "Timestamp start ()",                                  Quantity.Time, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V4", w.GetMeterTestRslt(t).TimestampStart)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Timestamp_end,          "Timestamp end ()",                                    Quantity.Time, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V4", w.GetMeterTestRslt(t).TimestampEnd)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Timestamp_start,        "Timestamp start ()",                                  Quantity.Time, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null || !w.GetTestRslt(t).IsRelErrTest()) ? "" : FormatDbl(u, f, p, "V4", w.GetMeterTestRslt(t).TimestampStart)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Timestamp_end,          "Timestamp end ()",                                    Quantity.Time, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null || !w.GetTestRslt(t).IsRelErrTest()) ? "" : FormatDbl(u, f, p, "V4", w.GetMeterTestRslt(t).TimestampEnd)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_time_ni,           Strings.T_s + "_ni()",                                 Quantity.Time, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null || !w.GetTestRslt(t).IsRelErrTest()) ? "" : FormatDbl(u, f, p, "V3", w.GetMeterTestRslt(t).TestTime)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_time,              Strings.T_s + "()",                                    Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null      || !w.GetTestRslt(t).IsRelErrTest()) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).TestTime)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.PMax_test_time,         "Pressure test time ()",     "Pressure test time",     Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null      || !w.GetTestRslt(t).IsPMaxTest())   ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).TestTime)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Diverter_start_time,    "Diverter start time ()",    "Diverter start time",    Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null      || !w.GetTestRslt(t).IsDiverter())   ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).DiverterStart)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Diverter_end_time,      "Diverter end time ()",      "Diverter end time",      Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null      || !w.GetTestRslt(t).IsDiverter())   ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).DiverterEnd)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Start_valve_open_time,  "Start valve open time ()",  "Start valve open time",  Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null      || !w.GetTestRslt(t).IsStartStop())  ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).DiverterStart)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Start_valve_close_time, "Start valve close time ()", "Start valve close time", Quantity.Time, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null      || !w.GetTestRslt(t).IsStartStop())  ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).DiverterEnd)));
 
             ///
             /// Flow
             ///
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_from,      string.Format("{0} {1}", Strings.VName_Flow, Strings.from),               Quantity.Flow, ItemCategory.TestData,    (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).Qfrom())));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_to,        string.Format("{0} {1}", Strings.VName_Flow, Strings.to),                 Quantity.Flow, ItemCategory.TestData,    (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).Qto())));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow,        string.Format("{0} v r", Strings.VName_Flow),      Strings.Tooltip_Q_v_r, Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowVolume)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Qc,          string.Format("Qc"), "Calculated water meter flow",                       Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).VolumeCTV / w.GetMeterTestRslt(t).TestTime * 3.6 * w.GetMeterTestRslt(t).PulsesMaster / w.GetTestRslt(t).PulsesMaster)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_mean,  string.Format("{0} rim ()", Strings.VName_Flow),   Strings.Tooltip_Q_rim, Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowMean)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_min,   string.Format("{0} ref min ()", Strings.VName_Flow), Strings.Tooltip_Q_min, Quantity.Flow, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowMin)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_max,   string.Format("{0} ref max ()", Strings.VName_Flow), Strings.Tooltip_Q_max, Quantity.Flow, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowMax)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_start, string.Format("{0} ref start ()", Strings.VName_Flow), Strings.Tooltip_Q_start, Quantity.Flow, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowStart)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_end,   string.Format("{0} ref end ()", Strings.VName_Flow), Strings.Tooltip_Q_end, Quantity.Flow, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowEnd)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_rise,      string.Format("{0} {1}", Strings.VName_Flow, Strings.rise), Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QRise == 0) ? "-" : FormatDbl(u, f, p, "V3", w.QRise)) : ""));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_fall,      string.Format("{0} {1}", Strings.VName_Flow, Strings.fall),               Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QFall == 0) ? "-" : FormatDbl(u, f, p, "V3", w.QFall)) : ""));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_sensitivity, string.Format("{0} {1}", Strings.VName_Flow, Strings.sensitivity),      Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QRise == 0) ? "-" : FormatDbl(u, f, p, "V3", w.QRise)) : ""));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_from,      string.Format("{0} {1}", Strings.VName_Flow, Strings.from),                   Quantity.Flow, ItemCategory.TestData,    (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).Qfrom())));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_to,        string.Format("{0} {1}", Strings.VName_Flow, Strings.to),                     Quantity.Flow, ItemCategory.TestData,    (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).Qto())));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow,        string.Format("{0} v r", Strings.VName_Flow),      Strings.Tooltip_Q_v_r,     Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowVolume)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Qc,          string.Format("Qc"), "Calculated water meter flow",                           Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).VolumeCTV / w.GetMeterTestRslt(t).TestTime * 3.6 * w.GetMeterTestRslt(t).PulsesMaster / w.GetTestRslt(t).PulsesMaster)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_mean,  string.Format("{0} rim ()", Strings.VName_Flow),   Strings.Tooltip_Q_rim,     Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowMean)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_min,   string.Format("{0} ref min ()", Strings.VName_Flow), Strings.Tooltip_Q_min,   Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowMin)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_max,   string.Format("{0} ref max ()", Strings.VName_Flow), Strings.Tooltip_Q_max,   Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowMax)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_start, string.Format("{0} ref start ()",Strings.VName_Flow),Strings.Tooltip_Q_start, Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowStart)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_end,   string.Format("{0} ref end ()", Strings.VName_Flow), Strings.Tooltip_Q_end,   Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).FlowEnd)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow_ctv,    string.Format("{0} ctv min ()", Strings.VName_Flow), "Mean CTV of the flow",  Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", (w.GetTestRslt(t).TestTime == 0) ? 0 : w.GetTestRslt(t).VolumeCTV / w.GetTestRslt(t).TestTime)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow_ctv_min, string.Format("{0} ctv min ()", Strings.VName_Flow), "Min. CTV of the flow", Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", (w.GetTestRslt(t).VolumeMaster == 0) ? 0 : w.GetTestRslt(t).VolumeCTV * w.GetTestRslt(t).FlowMin / w.GetTestRslt(t).VolumeMaster)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow_ctv_max, string.Format("{0} ctv max ()", Strings.VName_Flow), "Max. CTV of the flow", Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", (w.GetTestRslt(t).VolumeMaster == 0) ? 0 : w.GetTestRslt(t).VolumeCTV * w.GetTestRslt(t).FlowMax / w.GetTestRslt(t).VolumeMaster)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow_ctv_start, string.Format("{0} ctv start ()", Strings.VName_Flow), "Start flow CTV",   Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", (w.GetTestRslt(t).VolumeMaster == 0) ? 0 : w.GetTestRslt(t).VolumeCTV * w.GetTestRslt(t).FlowStart / w.GetTestRslt(t).VolumeMaster)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow_ctv_end, string.Format("{0} ctv end ()", Strings.VName_Flow), "End flow CTV",         Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", (w.GetTestRslt(t).VolumeMaster == 0) ? 0 : w.GetTestRslt(t).VolumeCTV * w.GetTestRslt(t).FlowEnd / w.GetTestRslt(t).VolumeMaster)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_rise, string.Format("{0} {1}", Strings.VName_Flow, Strings.rise),                        Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QRise == 0) ? "-" : FormatDbl(u, f, p, "V3", w.QRise)) : ""));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_fall,      string.Format("{0} {1}", Strings.VName_Flow, Strings.fall),                   Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QFall == 0) ? "-" : FormatDbl(u, f, p, "V3", w.QFall)) : ""));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_sensitivity, string.Format("{0} {1}", Strings.VName_Flow, Strings.sensitivity),          Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QRise == 0) ? "-" : FormatDbl(u, f, p, "V3", w.QRise)) : ""));
 
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.ConstMaster, string.Format("k MID ()"), "Const. of the reference flow meter [imp/l]", Quantity.PulsePerLtr, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).ConstMaster)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.ConstMaster,    string.Format("k MID ()"), "Const. of the reference flow meter",           Quantity.PulsePerLtr, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", ((w.GetTestRslt(t).ConstMaster < float.Epsilon) ? 0 : (1 / w.GetTestRslt(t).ConstMaster)))));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.ConstMasterRaw, string.Format("k MID raw ()"), "Const. of the ref. flow meter uncorrected",Quantity.PulsePerLtr, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", ((w.GetTestRslt(t).ConstMasterRaw < float.Epsilon) ? 0 : (1 / w.GetTestRslt(t).ConstMasterRaw)))));
 
             ///
             /// Temperature
@@ -244,14 +250,14 @@ namespace Results
             AllItems.Add(new WMeterRsltItemSpec(ItemID.T_div_max,    string.Format("{0} DI max ()", Strings.VName_Temp), Strings.Tooltip_T_di_max, Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).TempDivMax)));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.T_rho_0,      string.Format("{0} RO0",       Strings.VName_Temp), Strings.Tooltip_T_rho_0,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => FormatDbl(u, f, p, "V3", AtTemperature)));
 #if HEAT_METERS
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_mean,  string.Format("{0} hi me", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (w.GetTestRslt(t).Custom1).ToString(GetPr(p, "F3"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_start, string.Format("{0} hi st", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (w.GetTestRslt(t).Custom2).ToString(GetPr(p, "F3"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_end,   string.Format("{0} hi en", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (w.GetTestRslt(t).Custom3).ToString(GetPr(p, "F3"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_avg,   string.Format("{0} hi av", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : ((w.GetTestRslt(t).Custom2 + w.GetTestRslt(t).Custom3) / 2).ToString(GetPr(p, "F3"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_mean,  string.Format("{0} lo me", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (w.GetTestRslt(t).Custom6).ToString(GetPr(p, "F3"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_start, string.Format("{0} lo st", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (w.GetTestRslt(t).Custom7).ToString(GetPr(p, "F3"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_end,   string.Format("{0} lo en", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (w.GetTestRslt(t).Custom8).ToString(GetPr(p, "F3"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_avg,   string.Format("{0} lo av", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : ((w.GetTestRslt(t).Custom7 + w.GetTestRslt(t).Custom8) / 2).ToString(GetPr(p, "F3"))));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_mean,  string.Format("{0} hi me", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).Custom1)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_start, string.Format("{0} hi st", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).Custom2)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_end,   string.Format("{0} hi en", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).Custom3)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_avg,   string.Format("{0} hi av", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", (w.GetTestRslt(t).Custom2 + w.GetTestRslt(t).Custom3) / 2)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_mean,  string.Format("{0} lo me", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).Custom6)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_start, string.Format("{0} lo st", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).Custom7)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_end,   string.Format("{0} lo en", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", w.GetTestRslt(t).Custom8)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_avg,   string.Format("{0} lo av", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F3", (w.GetTestRslt(t).Custom7 + w.GetTestRslt(t).Custom8) / 2)));
 #endif
 
             ///
@@ -277,7 +283,7 @@ namespace Results
             AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_max,   string.Format("{0} DE max ()", Strings.VName_Press), Strings.Tooltip_P_de_max, Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).PressDeltaMax)));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_mean_per_mtr, string.Format("{0} DE ME per mtr.()", Strings.VName_Press), "P delta mean per one meter", Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).PressDeltaMean / Math.Max(1, w.GetTestRslt(t).Batch.WaterMeters.Count))));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_mean_from_up_down, string.Format("{0} UP-DW ME ()", Strings.VName_Press), "P delta mean from UP/DW", Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).PressUpMean - w.GetTestRslt(t).PressDownMean)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_mean_from_up_down_per_mtr, string.Format("{0} UP-DW ME per mtr ()", Strings.VName_Press), "P delta mean from UP/DW per one meter", Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", w.GetTestRslt(t).PressUpMean - w.GetTestRslt(t).PressDownMean / Math.Max(1, w.GetTestRslt(t).Batch.WaterMeters.Count))));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_mean_from_up_down_per_mtr, string.Format("{0} UP-DW ME per mtr ()", Strings.VName_Press), "P delta mean from UP/DW per one meter", Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V3", (w.GetTestRslt(t).PressUpMean - w.GetTestRslt(t).PressDownMean) / Math.Max(1, w.GetTestRslt(t).Batch.WaterMeters.Count))));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.P_PMax_test_mean, string.Format("{0} PMax mean ()", Strings.VName_Press), "Mean PMax test pressure", Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null || !w.GetTestRslt(t).IsPMaxTest()) ? "" : FormatDbl(u, f, p, "V3", (w.GetTestRslt(t).PressUpMean + w.GetTestRslt(t).PressDownMean) / 2)));
 
             ///
@@ -298,7 +304,7 @@ namespace Results
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Error_limit_Hi,  Strings.ErrLimHi + "()",    Quantity.Error, ItemCategory.TestData, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V2", w.GetTestRslt(t).ErrLimHi())));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Uncertainty,     Strings.Uncertainty + "()", Quantity.Error, ItemCategory.TestData, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V2", w.GetTestRslt(t).Uncertainty())));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Reference_error, string.Format("{0} rel.ref. ()", Strings.VName_Error), Strings.Tooltip_E_rel_ref, Quantity.Error, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V2", w.GetTestRslt(t).ErrorMaster)));
-#if TURA_IPERL || TURA_SPECIAL 
+#if TURA_IPERL || TURA_SPECIAL
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Error, string.Format("{0} rel. ()", Strings.VName_Error), Strings.Tooltip_E_rel, Quantity.Error, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "0" : FormatDbl(u, f, p, "V2", w.GetMeterTestRslt(t).Error)));
 #else
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Error, string.Format("{0} rel. ()", Strings.VName_Error), Strings.Tooltip_E_rel, Quantity.Error, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V2", w.GetMeterTestRslt(t).Error)));
@@ -353,7 +359,7 @@ namespace Results
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Camera_angle_end, "End angle ()", "End angle measured by a camera", Quantity.Pulses, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "F0", w.GetMeterTestRslt(t).IsCamera() ? w.GetMeterTestRslt(t).VolumeEnd * w.GetMeterTestRslt(t).PulsesPerLiter : 0)));
 
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Pulses_per_liter, Strings.PulsesLiter,        Quantity.PulsePerLtr, ItemCategory.MeterData, (w, t, u, f, p) => FormatDbl(u, f, p, "V4", w.WaterMeterData.PulsesPerLtr)));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Pulses__liter,    Strings.PulsesLiter + "()", Quantity.PulsePerLtr, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V4", w.GetMeterTestRslt(t).IsCamera() ? 0 : w.GetMeterTestRslt(t).PulsesPerLiter)));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Pulse__liter,     Strings.PulsesLiter + "()", Quantity.PulsePerLtr, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V4", w.GetMeterTestRslt(t).IsCamera() ? 0 : w.GetMeterTestRslt(t).PulsesPerLiter)));
             AllItems.Add(new WMeterRsltItemSpec(ItemID.Degree__liter,    "Degree per liter ()",      Quantity.PulsePerLtr, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : FormatDbl(u, f, p, "V4", w.GetMeterTestRslt(t).IsCamera() ? w.GetMeterTestRslt(t).PulsesPerLiter : 0)));
 
 			/// Water meters results (combined)
@@ -386,8 +392,8 @@ namespace Results
 			AllItems.Add(new WMeterRsltItemSpec(ItemID.Meter_type,  Strings.Meter_type,  Quantity.String, ItemCategory.Other,       (w, t, u, f, p) => FormatStr(f, w.WaterMeterData.Compound ? Strings.Compound : (w.WaterMeterData.HeatMeter ? Strings.Heat_meter : Strings.Single))));
 
 #if HEAT_METERS
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Energy,              Strings.Energy + "()",      Quantity.Energy,        ItemCategory.Other,	(w, t, u, f, p) => (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy) == null) ? "" : (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy).VolumeMeter).ToString(GetPr(p, "F1"))));
-            AllItems.Add(new WMeterRsltItemSpec(ItemID.Reference_energy,    Strings.Energy_ref + "()",  Quantity.Energy,        ItemCategory.Other,	(w, t, u, f, p) => (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy) == null) ? "" : (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy).VolumeRef).ToString(GetPr(p, "F1"))));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Energy,              Strings.Energy + "()",      Quantity.Energy,        ItemCategory.Other,	(w, t, u, f, p) => (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy) == null) ? "" : FormatDbl(u, f, p, "F1", (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy).VolumeMeter))));
+            AllItems.Add(new WMeterRsltItemSpec(ItemID.Reference_energy,    Strings.Energy_ref + "()",  Quantity.Energy,        ItemCategory.Other,	(w, t, u, f, p) => (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy) == null) ? "" : FormatDbl(u, f, p, "F1", (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy).VolumeRef))));
 #endif
 
 #if IPERL
@@ -459,7 +465,7 @@ namespace Results
                 int significantDigits;
                 if (int.TryParse(precision.Substring(1), out significantDigits))
                 {
-                    precision = Utils.SignificantDigitsToFmt(val, significantDigits);
+                    precision = Config.Utils.SignificantDigitsToFmt(val, significantDigits);
                 }
             }
 
@@ -497,7 +503,7 @@ namespace Results
                 int significantDigits;
                 if (int.TryParse(precision.Substring(1), out significantDigits))
                 {
-                    precision = Utils.SignificantDigitsToFmt(val1, significantDigits);
+                    precision = Config.Utils.SignificantDigitsToFmt(val1, significantDigits);
                 }
             }
 

ResultsBrowser/Resources/Strings.pl.resx

@@ -637,7 +637,7 @@
     <value>zimna</value>
   </data>
   <data name="hot" xml:space="preserve">
-    <value>gorąca</value>
+    <value>ciepła</value>
   </data>
   <data name="Product_name" xml:space="preserve">
     <value>Nazwa produktu</value>

ResultsBrowser/ResultsBrowser.csproj

@@ -21,7 +21,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TORINO50;LANG_IT</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
@@ -31,7 +31,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TORINO50;LANG_IT</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
@@ -207,12 +207,17 @@
     <EmbeddedResource Include="Resources\Strings.cs.resx" />
     <EmbeddedResource Include="Resources\Strings.de.resx" />
     <EmbeddedResource Include="Resources\Strings.it.resx" />
-    <EmbeddedResource Include="Resources\Strings.pl.resx" />
+    <EmbeddedResource Include="Resources\Strings.pl.resx">
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
     <EmbeddedResource Include="Resources\Strings.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>Strings1.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Resources\Strings.ru.resx">
+      <SubType>Designer</SubType>
     </EmbeddedResource>
-    <EmbeddedResource Include="Resources\Strings.ru.resx" />
     <EmbeddedResource Include="ResultsBrowserWnd.resx">
       <DependentUpon>ResultsBrowserWnd.cs</DependentUpon>
     </EmbeddedResource>

TBF.sln

@@ -28,6 +28,9 @@ EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dirichlet.Numerics", "Dirichlet.Numerics\Dirichlet.Numerics.csproj", "{439D0878-C76E-452B-B17D-209A89E91D36}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Users", "Users\Users.csproj", "{6E5CB0E9-E1B6-4E5D-AC6E-B1049E180F2B}"
+	ProjectSection(ProjectDependencies) = postProject
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697} = {8B10D15A-39DE-4B56-8DD1-710C1EB3A697}
+	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UserManagement", "UserManagement\UserManagement.csproj", "{B2CD81B3-AF09-4978-996C-02EDB5F819B7}"
 	ProjectSection(ProjectDependencies) = postProject
@@ -35,9 +38,14 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UserManagement", "UserManag
 	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphLib", "GraphLib\GraphLib.csproj", "{0C0A1F4D-1363-4544-A7C5-196C76D26CCA}"
+	ProjectSection(ProjectDependencies) = postProject
+		{743DF7DB-C7B6-42EB-986D-0F485E5588E4} = {743DF7DB-C7B6-42EB-986D-0F485E5588E4}
+	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MonitoringDB", "MonitoringDB\MonitoringDB.csproj", "{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GemCard", "GemCard\GemCard.csproj", "{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -154,6 +162,18 @@ Global
 		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|x86.ActiveCfg = Release|Any CPU
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Debug|x86.ActiveCfg = Debug|x86
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Debug|x86.Build.0 = Debug|x86
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Release|Mixed Platforms.ActiveCfg = Release|x86
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Release|Mixed Platforms.Build.0 = Release|x86
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Release|x86.ActiveCfg = Release|x86
+		{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

TBF/BenchControl/Ambient/Comet/AmbientCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.Ambient.Comet
     public class AmbientCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(AmbientCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new AmbientCfgCtrl(); }
 

TBF/BenchControl/Ambient/Comet/AmbientCfgCtrl.cs

@@ -4,15 +4,13 @@
 using System;
 using System.Windows.Forms;
 using System.IO.Ports;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.Ambient.Comet
 {
 	public partial class AmbientCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(AmbientCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		AmbientCfg config;

TBF/BenchControl/Ambient/Greco/AmbientCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.Ambient.Greco
     public class AmbientCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(AmbientCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new AmbientCfgCtrl(); }
 

TBF/BenchControl/Ambient/Greco/AmbientCfgCtrl.cs

@@ -4,15 +4,13 @@
 using System;
 using System.Windows.Forms;
 using System.IO.Ports;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.Ambient.Greco
 {
 	public partial class AmbientCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(AmbientCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		AmbientCfg config;

TBF/BenchControl/BenchInfo/Extended/Component.cs

@@ -1,6 +1,5 @@
 ///
-/// Copyright (c) 2013-2016 Sensus Metering Systems
-/// Author: Milan Hanajík
+/// Copyright (c) 2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -10,7 +9,7 @@ using Config.Entities;
 using TBF.BenchControl;
 using TBF.BenchControl.Generic;
 
-namespace TBF.BenchControl.BenchInfo.Polska
+namespace TBF.BenchControl.BenchInfo.Extended
 {
 	/// <summary>
 	/// Holds information identifying the test bench.
@@ -20,10 +19,11 @@ namespace TBF.BenchControl.BenchInfo.Polska
         private static readonly ILog log = LogManager.GetLogger(typeof(Component));
 		public override string ToString() { return string.Format("BenchInfoEx({0})", Cfg.ToString(1)); }
 
-        public readonly ComponentCfg BenchInfoCfg;
+        readonly ComponentCfg myCfg;
 
-		public string TestBenchName { get { return BenchInfoCfg.TestBenchName; } }
-		public int TestBenchId { get { return BenchInfoCfg.TestBenchId; } }
+		public string TestBenchName { get { return myCfg.TestBenchName; } }
+		public int TestBenchId { get { return myCfg.TestBenchId; } }
+        public RemoteDBUse RemoteDBUse { get { return myCfg.RemoteDBUse; } }
 
 		public Component()
 		{
@@ -32,7 +32,7 @@ namespace TBF.BenchControl.BenchInfo.Polska
 		public Component(Generic.IComponentCfg cfg)
 			: base(cfg)
 		{
-			BenchInfoCfg = cfg as ComponentCfg;
+			myCfg = cfg as ComponentCfg;
             log.Debug(this.ToString());
         }
 	}

TBF/BenchControl/BenchInfo/Extended/ComponentCfg.cs

@@ -0,0 +1,223 @@
+///
+/// Copyright (c) 2018 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+using Config.Entities;
+using TBF.BenchControl.Generic;
+
+namespace TBF.BenchControl.BenchInfo.Extended
+{
+	/// <summary>
+	/// Holds information identifying the test bench - serializable configuration.
+	/// </summary>
+	public class ComponentCfg : ComponentCfgBase, Generic.IComponentCfg, Config.Entities.IParamsProvider
+	{
+		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ComponentCfg) })[0];
+        public override XmlSerializer GetSerializer() { return Serializer; }
+
+		public IComponentCfgCtrl GetControl() { return new Configs.ParamsProvider.ComponentCfgCtrl(this, null); }
+
+		///
+		/// Serialized parameters 
+		///
+		public string TestBenchName;
+		public int TestBenchId;
+		public string Address1;
+		public string Address2;
+		public string Address3;
+		public string Address4;
+		public string Address5;
+		public string ApprovalId;
+		public string ApprovalDate;
+		public string ApprovedBy;
+        public RemoteDBUse RemoteDBUse;
+
+		/// Private parameterless constructor invoked by all other (public) constructors
+		ComponentCfg() {}
+
+        public ComponentCfg(IComponentFactory factory)
+            : this()
+        {
+            Factory = factory;
+            Name = "BenchInfoEx";
+            ParentName = string.Empty;
+            InitializeAll();
+        }
+
+        public string ToString(char a)
+        {
+            return string.Format("Name={0}, Parent={1}, ...", Name, ParentName);
+        }
+
+        public string ComponentName { get { return Name; } }
+
+ 		public void InitializeAll()
+		{
+            TestBenchName = "1";
+            TestBenchId = 1;
+
+            Address1 = string.Empty;
+            Address2 = string.Empty;
+            Address3 = string.Empty;
+            Address4 = string.Empty;
+            Address5 = string.Empty;
+
+            ApprovalId = string.Empty;
+            ApprovalDate = string.Empty;
+            ApprovedBy = string.Empty;
+
+            RemoteDBUse = RemoteDBUse.LocalDBOnly;
+        }
+
+        string[] paramNames = new string[]
+		{
+            "Test bench name",
+            "Test bench ID",
+            "Address 1",
+            "Address 2",
+            "Address 3",
+            "Address 4",
+            "Address 5",
+            "Approval",
+            "Approval date",
+            "Approved by",
+            "Remote DB use",
+        };
+        public string ParamName(int i) { return paramNames[i]; }
+        public int ParamsCount() { return paramNames.Length; }
+
+        public IList<string> ParamValues(int i)
+        {
+            if (i == 10)
+            {
+                IList<string> list = new List<string>();
+                for (RemoteDBUse rdbu = 0; rdbu < RemoteDBUse.Count; rdbu++) list.Add(rdbu.ToDescription());
+                return list;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public string ToString(int i)
+        {
+            switch (i)
+            {
+                case 0: return TestBenchName;
+                case 1: return TestBenchId.ToString();
+                case 2: return Address1;
+                case 3: return Address2;
+                case 4: return Address3;
+                case 5: return Address4;
+                case 6: return Address5;
+                case 7: return ApprovalId;
+                case 8: return ApprovalDate;
+                case 9: return ApprovedBy;
+                case 10: return RemoteDBUse.ToDescription();
+                default: return string.Empty;
+            }
+        }
+
+        public CfgUpdateFlags UpdateParam(int i, string strValue)
+        {
+            switch (i)
+            {
+                case 0: TestBenchName = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 1: TestBenchId = int.Parse(strValue); return CfgUpdateFlags.RestartRqrd;
+                case 2: Address1 = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 3: Address2 = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 4: Address3 = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 5: Address4 = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 6: Address5 = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 7: ApprovalId = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 8: ApprovalDate = strValue; return CfgUpdateFlags.RestartRqrd;
+                case 9: ApprovedBy = strValue; return CfgUpdateFlags.RestartRqrd;
+
+                case 10:
+                    for (RemoteDBUse rdbu = 0; rdbu < RemoteDBUse.Count; rdbu++)
+                    {
+                        if (strValue == rdbu.ToDescription())
+                        {
+                            if (RemoteDBUse != rdbu)
+                            {
+                                RemoteDBUse = rdbu;
+                                return CfgUpdateFlags.RestartRqrd;
+                            }
+                            else
+                            {
+                                return CfgUpdateFlags.None;
+                            }
+                        }
+                    }
+                    return CfgUpdateFlags.Error;
+
+                default: return CfgUpdateFlags.None;
+            }
+        }
+
+        public bool ValidateParam(int i, string strValue, out string message)
+        {
+            message = string.Empty;
+            int idummy;
+
+            switch (i)
+            {
+                case 0:
+                case 2:
+                case 3:
+                case 4:
+                case 5:
+                case 6:
+                case 7:
+                case 8:
+                case 9:
+                    return true;
+                case 1:
+                    if (int.TryParse(strValue, out idummy) && (idummy >= 0)) return true;
+                    break;
+                case 10:
+                    for (RemoteDBUse rdbu = 0; rdbu < RemoteDBUse.Count; rdbu++)
+                    {
+                        if (strValue == rdbu.ToDescription()) return true;
+                    }
+                    return false;
+                default:
+                    message = "Invalid index";
+                    return false;
+            }
+
+            message = ParamName(i) + " is invalid";
+            return false;
+        }
+
+        void CopyContentTo(ComponentCfg prms)
+        {
+            prms.TestBenchName = this.TestBenchName;
+            prms.TestBenchId = this.TestBenchId;
+            prms.Address1 = this.Address1;
+            prms.Address2 = this.Address2;
+            prms.Address3 = this.Address3;
+            prms.Address4 = this.Address4;
+            prms.Address5 = this.Address5;
+            prms.ApprovalId = this.ApprovalId;
+            prms.ApprovalDate = this.ApprovalDate;
+            prms.ApprovedBy = this.ApprovedBy;
+            prms.RemoteDBUse = this.RemoteDBUse;
+        }
+
+        public Config.Entities.IParamsProvider Clone()
+        {
+            ComponentCfg pars = new ComponentCfg();
+            CopyContentTo(pars);
+            return pars;
+        }
+
+        public void UpdateEmbeddedDbEntity()
+        {
+            /// Do nothing
+        }
+    }
+}

TBF/BenchControl/BenchInfo/Extended/ComponentFactory.cs

@@ -1,10 +1,10 @@
 ///
-/// Copyright (c) 2015-2016 Sensus Metering Systems
+/// Copyright (c) 2018 Sensus Slovensko a.s.
 ///
 using System.Collections.Generic;
 using TBF.BenchControl.Generic;
 
-namespace TBF.BenchControl.BenchInfo.Polska
+namespace TBF.BenchControl.BenchInfo.Extended
 {
 	public class ComponentFactory : IComponentFactory
 	{

TBF/BenchControl/BenchInfo/Munich/Component.cs

@@ -1,6 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-/// Author: Milan Hanajík
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -24,6 +23,7 @@ namespace TBF.BenchControl.BenchInfo.Munich
 
 		public string TestBenchName { get { return benchInfoCfg.TestBenchName; } }
 		public int TestBenchId { get { return benchInfoCfg.TestBenchId; } }
+        public RemoteDBUse RemoteDBUse { get { return RemoteDBUse.LocalDBOnly; } }
 
 		public Component()
 		{

TBF/BenchControl/BenchInfo/Munich/ComponentCfg.cs

@@ -15,7 +15,7 @@ namespace TBF.BenchControl.BenchInfo.Munich
 	public class ComponentCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ComponentCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new ComponentCfgCtrl(); }
 

TBF/BenchControl/BenchInfo/Munich/ComponentCfgCtrl.cs

@@ -4,7 +4,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -12,8 +12,6 @@ namespace TBF.BenchControl.BenchInfo.Munich
 {
 	public partial class ComponentCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(ComponentCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		ComponentCfg config;

TBF/BenchControl/BenchInfo/Polska/ComponentCfg.cs

@@ -1,66 +0,0 @@
-///
-/// Copyright (c) 2015-2016 Sensus Metering Systems
-/// Author: Milan Hanajík
-///
-using System;
-using System.Collections.Generic;
-using System.Xml.Serialization;
-using TBF.BenchControl.Generic;
-
-namespace TBF.BenchControl.BenchInfo.Polska
-{
-	/// <summary>
-	/// Holds information identifying the test bench - serializable configuration.
-	/// </summary>
-	public class ComponentCfg : ComponentCfgBase, Generic.IComponentCfg
-	{
-		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ComponentCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
-
-		public IComponentCfgCtrl GetControl() { return new ComponentCfgCtrl(); }
-
-		///
-		/// Serialized parameters 
-		///
-		public string TestBenchName;
-		public int TestBenchId;
-		public string Address1;
-		public string Address2;
-		public string Address3;
-		public string Address4;
-		public string Address5;
-		public string ApprovalId;
-		public string ApprovalDate;
-		public string ApprovedBy;
-
-		/// Private parameterless constructor invoked by all other (public) constructors
-		ComponentCfg()
-		{
-            Name = "BenchInfoEx";
-            ParentName = string.Empty;
-			TestBenchName = "1";
-			TestBenchId = 1;
-
-			Address1 = string.Empty;
-			Address2 = string.Empty;
-			Address3 = string.Empty;
-			Address4 = string.Empty;
-			Address5 = string.Empty;
-
-			ApprovalId = string.Empty;
-			ApprovalDate = string.Empty;
-			ApprovedBy = string.Empty;
-        }
-
-        public ComponentCfg(IComponentFactory factory)
-            : this()
-        {
-            this.Factory = factory;
-        }
-
-        public string ToString(int i)
-        {
-            return string.Format("Name={0}, Bench name={1}, Bench Id={2}", Name, TestBenchName, TestBenchId);
-        }
-	}
-}

TBF/BenchControl/BenchInfo/Polska/ComponentCfgCtrl.cs

@@ -1,130 +0,0 @@
-///
-/// Copyright (c) 2015-2016 Sensus Metering Systems
-/// Author: Milan Hanajík
-///
-using System;
-using System.Windows.Forms;
-using log4net;
-using TBF.BenchControl.Generic;
-using TBF.Resources;
-
-namespace TBF.BenchControl.BenchInfo.Polska
-{
-	public partial class ComponentCfgCtrl : UserControl, IComponentCfgCtrl
-	{
-		static readonly ILog log = LogManager.GetLogger(typeof(ComponentCfgCtrl));
-
-		public bool ShowMore { get { return false; } }
-
-		ComponentCfg config;
-		public IComponentCfg Config
-		{
-			get { return config as IComponentCfg; }
-			set
-			{
-				config = value as ComponentCfg;
-				Redraw();
-			}
-		}
-
-		public ComponentCfgCtrl()
-		{
-			InitializeComponent();
-		}
-
-		private void EntryFormCfgCtrl_Load(object sender, EventArgs e)
-		{
-			nameLabel.Text = Strings.Name;
-			benchNameLabel.Text = Strings.Test_bench_name;
-			benchIdLabel.Text = Strings.Test_bench_number;
-
-			address1Label.Text = Strings.Address + " 1";
-			address2Label.Text = Strings.Address + " 2";
-			address3Label.Text = Strings.Address + " 3";
-			address4Label.Text = Strings.Address + " 4";
-			address5Label.Text = Strings.Address + " 5";
-
-			approvalIdLabel.Text = Strings.Approval_ID;
-			approvalDateLabel.Text = Strings.Approval_date;
-			approvedByLabel.Text = Strings.Approved_by;
-			Redraw();
-		}
-
-		public void Closing()
-		{
-		}
-
-		void Redraw()
-		{
-			if (config == null) return;			/// Control was not loaded, settings were not changed
-
-			classNameLabel.Text = config.Factory.ClassName;
-			nameTextBox.Text = config.Name;
-			benchNameTextBox.Text = config.TestBenchName;
-			benchIdTextBox.Text = config.TestBenchId.ToString();
-
-			address1TextBox.Text = config.Address1;
-			address2TextBox.Text = config.Address2;
-			address3TextBox.Text = config.Address3;
-			address4TextBox.Text = config.Address4;
-			address5TextBox.Text = config.Address5;
-
-			approvalIdTextBox.Text = config.ApprovalId;
-			approvalDateTextBox.Text = config.ApprovalDate;
-			approvedByTextBox.Text = config.ApprovedBy;
-		}
-
-		public void Unlock()
-		{
-			nameTextBox.Enabled = true;
-			benchNameTextBox.Enabled = true;
-			benchIdTextBox.Enabled = true;
-
-			address1TextBox.Enabled = true;
-			address2TextBox.Enabled = true;
-			address3TextBox.Enabled = true;
-			address4TextBox.Enabled = true;
-			address5TextBox.Enabled = true;
-
-			approvalIdTextBox.Enabled = true;
-			approvalDateTextBox.Enabled = true;
-			approvedByTextBox.Enabled = true;
-		}
-
-		public CfgUpdateFlags VerifyCfg(ref string message)
-		{
-			CfgUpdateFlags flags = CfgUpdateFlags.None;
-
-			int dummy;
-			if (!int.TryParse(benchIdTextBox.Text, out dummy) || dummy < 0)
-			{
-				flags = CfgUpdateFlags.Error;
-				message = string.Format("Invalid {0} parameter", Strings.Test_bench_number);
-			}
-			return flags;
-		}
-
-		public CfgUpdateFlags UpdateCfg()
-		{
-            CfgUpdateFlags flags = CfgUpdateFlags.RestartRqrd;
-
-			if (config == null) return CfgUpdateFlags.Error;	/// Control was not loaded, settings were not changed
-																/// 
-			config.Name = nameTextBox.Text;
-			config.TestBenchName = benchNameTextBox.Text;
-			config.TestBenchId = int.Parse(benchIdTextBox.Text);
-
-			config.Address1 = address1TextBox.Text;
-			config.Address2 = address2TextBox.Text;
-			config.Address3 = address3TextBox.Text;
-			config.Address4 = address4TextBox.Text;
-			config.Address5 = address5TextBox.Text;
-
-			config.ApprovalId = approvalIdTextBox.Text;
-			config.ApprovalDate = approvalDateTextBox.Text;
-			config.ApprovedBy = approvedByTextBox.Text;
-
-			return flags;
-		}
-	}
-}

TBF/BenchControl/BenchInfo/Polska/ComponentCfgCtrl.designer.cs

@@ -1,316 +0,0 @@
-///
-/// Copyright (c) 2015 Sensus Metering Systems
-///
-namespace TBF.BenchControl.BenchInfo.Polska
-{
-	partial class ComponentCfgCtrl
-	{
-		/// <summary> 
-		/// Required designer variable.
-		/// </summary>
-		private System.ComponentModel.IContainer components = null;
-
-		/// <summary> 
-		/// Clean up any resources being used.
-		/// </summary>
-		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-		protected override void Dispose(bool disposing)
-		{
-			if (disposing && (components != null))
-			{
-				components.Dispose();
-			}
-			base.Dispose(disposing);
-		}
-
-		#region Component Designer generated code
-
-		/// <summary> 
-		/// Required method for Designer support - do not modify 
-		/// the contents of this method with the code editor.
-		/// </summary>
-		private void InitializeComponent()
-		{
-			this.nameTextBox = new System.Windows.Forms.TextBox();
-			this.nameLabel = new System.Windows.Forms.Label();
-			this.classNameLabel = new System.Windows.Forms.Label();
-			this.benchIdLabel = new System.Windows.Forms.Label();
-			this.benchIdTextBox = new System.Windows.Forms.TextBox();
-			this.address1TextBox = new System.Windows.Forms.TextBox();
-			this.address1Label = new System.Windows.Forms.Label();
-			this.address2TextBox = new System.Windows.Forms.TextBox();
-			this.address2Label = new System.Windows.Forms.Label();
-			this.address3TextBox = new System.Windows.Forms.TextBox();
-			this.address3Label = new System.Windows.Forms.Label();
-			this.address4TextBox = new System.Windows.Forms.TextBox();
-			this.address4Label = new System.Windows.Forms.Label();
-			this.address5TextBox = new System.Windows.Forms.TextBox();
-			this.address5Label = new System.Windows.Forms.Label();
-			this.approvedByTextBox = new System.Windows.Forms.TextBox();
-			this.approvedByLabel = new System.Windows.Forms.Label();
-			this.approvalDateTextBox = new System.Windows.Forms.TextBox();
-			this.approvalDateLabel = new System.Windows.Forms.Label();
-			this.approvalIdTextBox = new System.Windows.Forms.TextBox();
-			this.approvalIdLabel = new System.Windows.Forms.Label();
-			this.benchNameTextBox = new System.Windows.Forms.TextBox();
-			this.benchNameLabel = new System.Windows.Forms.Label();
-			this.SuspendLayout();
-			// 
-			// nameTextBox
-			// 
-			this.nameTextBox.Enabled = false;
-			this.nameTextBox.Location = new System.Drawing.Point(113, 24);
-			this.nameTextBox.Name = "nameTextBox";
-			this.nameTextBox.Size = new System.Drawing.Size(180, 20);
-			this.nameTextBox.TabIndex = 2;
-			// 
-			// nameLabel
-			// 
-			this.nameLabel.AutoSize = true;
-			this.nameLabel.Location = new System.Drawing.Point(6, 27);
-			this.nameLabel.Name = "nameLabel";
-			this.nameLabel.Size = new System.Drawing.Size(35, 13);
-			this.nameLabel.TabIndex = 1;
-			this.nameLabel.Text = "Name";
-			// 
-			// classNameLabel
-			// 
-			this.classNameLabel.AutoSize = true;
-			this.classNameLabel.Location = new System.Drawing.Point(110, 6);
-			this.classNameLabel.Name = "classNameLabel";
-			this.classNameLabel.Size = new System.Drawing.Size(60, 13);
-			this.classNameLabel.TabIndex = 0;
-			this.classNameLabel.Text = "ClassName";
-			// 
-			// benchIdLabel
-			// 
-			this.benchIdLabel.AutoSize = true;
-			this.benchIdLabel.Location = new System.Drawing.Point(6, 66);
-			this.benchIdLabel.Name = "benchIdLabel";
-			this.benchIdLabel.Size = new System.Drawing.Size(99, 13);
-			this.benchIdLabel.TabIndex = 5;
-			this.benchIdLabel.Text = "Test bench number";
-			// 
-			// benchIdTextBox
-			// 
-			this.benchIdTextBox.Enabled = false;
-			this.benchIdTextBox.Location = new System.Drawing.Point(113, 64);
-			this.benchIdTextBox.Name = "benchIdTextBox";
-			this.benchIdTextBox.Size = new System.Drawing.Size(57, 20);
-			this.benchIdTextBox.TabIndex = 6;
-			// 
-			// address1TextBox
-			// 
-			this.address1TextBox.Enabled = false;
-			this.address1TextBox.Location = new System.Drawing.Point(73, 86);
-			this.address1TextBox.Name = "address1TextBox";
-			this.address1TextBox.Size = new System.Drawing.Size(220, 20);
-			this.address1TextBox.TabIndex = 8;
-			// 
-			// address1Label
-			// 
-			this.address1Label.AutoSize = true;
-			this.address1Label.Location = new System.Drawing.Point(6, 89);
-			this.address1Label.Name = "address1Label";
-			this.address1Label.Size = new System.Drawing.Size(54, 13);
-			this.address1Label.TabIndex = 7;
-			this.address1Label.Text = "Address 1";
-			// 
-			// address2TextBox
-			// 
-			this.address2TextBox.Enabled = false;
-			this.address2TextBox.Location = new System.Drawing.Point(73, 106);
-			this.address2TextBox.Name = "address2TextBox";
-			this.address2TextBox.Size = new System.Drawing.Size(220, 20);
-			this.address2TextBox.TabIndex = 10;
-			// 
-			// address2Label
-			// 
-			this.address2Label.AutoSize = true;
-			this.address2Label.Location = new System.Drawing.Point(6, 109);
-			this.address2Label.Name = "address2Label";
-			this.address2Label.Size = new System.Drawing.Size(54, 13);
-			this.address2Label.TabIndex = 9;
-			this.address2Label.Text = "Address 2";
-			// 
-			// address3TextBox
-			// 
-			this.address3TextBox.Enabled = false;
-			this.address3TextBox.Location = new System.Drawing.Point(73, 126);
-			this.address3TextBox.Name = "address3TextBox";
-			this.address3TextBox.Size = new System.Drawing.Size(220, 20);
-			this.address3TextBox.TabIndex = 12;
-			// 
-			// address3Label
-			// 
-			this.address3Label.AutoSize = true;
-			this.address3Label.Location = new System.Drawing.Point(6, 129);
-			this.address3Label.Name = "address3Label";
-			this.address3Label.Size = new System.Drawing.Size(54, 13);
-			this.address3Label.TabIndex = 11;
-			this.address3Label.Text = "Address 3";
-			// 
-			// address4TextBox
-			// 
-			this.address4TextBox.Enabled = false;
-			this.address4TextBox.Location = new System.Drawing.Point(73, 146);
-			this.address4TextBox.Name = "address4TextBox";
-			this.address4TextBox.Size = new System.Drawing.Size(220, 20);
-			this.address4TextBox.TabIndex = 14;
-			// 
-			// address4Label
-			// 
-			this.address4Label.AutoSize = true;
-			this.address4Label.Location = new System.Drawing.Point(6, 149);
-			this.address4Label.Name = "address4Label";
-			this.address4Label.Size = new System.Drawing.Size(54, 13);
-			this.address4Label.TabIndex = 13;
-			this.address4Label.Text = "Address 4";
-			// 
-			// address5TextBox
-			// 
-			this.address5TextBox.Enabled = false;
-			this.address5TextBox.Location = new System.Drawing.Point(73, 166);
-			this.address5TextBox.Name = "address5TextBox";
-			this.address5TextBox.Size = new System.Drawing.Size(220, 20);
-			this.address5TextBox.TabIndex = 16;
-			// 
-			// address5Label
-			// 
-			this.address5Label.AutoSize = true;
-			this.address5Label.Location = new System.Drawing.Point(6, 169);
-			this.address5Label.Name = "address5Label";
-			this.address5Label.Size = new System.Drawing.Size(54, 13);
-			this.address5Label.TabIndex = 15;
-			this.address5Label.Text = "Address 5";
-			// 
-			// approvedByTextBox
-			// 
-			this.approvedByTextBox.Enabled = false;
-			this.approvedByTextBox.Location = new System.Drawing.Point(113, 227);
-			this.approvedByTextBox.Name = "approvedByTextBox";
-			this.approvedByTextBox.Size = new System.Drawing.Size(180, 20);
-			this.approvedByTextBox.TabIndex = 22;
-			// 
-			// approvedByLabel
-			// 
-			this.approvedByLabel.AutoSize = true;
-			this.approvedByLabel.Location = new System.Drawing.Point(6, 230);
-			this.approvedByLabel.Name = "approvedByLabel";
-			this.approvedByLabel.Size = new System.Drawing.Size(67, 13);
-			this.approvedByLabel.TabIndex = 21;
-			this.approvedByLabel.Text = "Approved by";
-			// 
-			// approvalDateTextBox
-			// 
-			this.approvalDateTextBox.Enabled = false;
-			this.approvalDateTextBox.Location = new System.Drawing.Point(113, 207);
-			this.approvalDateTextBox.Name = "approvalDateTextBox";
-			this.approvalDateTextBox.Size = new System.Drawing.Size(180, 20);
-			this.approvalDateTextBox.TabIndex = 20;
-			// 
-			// approvalDateLabel
-			// 
-			this.approvalDateLabel.AutoSize = true;
-			this.approvalDateLabel.Location = new System.Drawing.Point(6, 210);
-			this.approvalDateLabel.Name = "approvalDateLabel";
-			this.approvalDateLabel.Size = new System.Drawing.Size(73, 13);
-			this.approvalDateLabel.TabIndex = 19;
-			this.approvalDateLabel.Text = "Approval date";
-			// 
-			// approvalIdTextBox
-			// 
-			this.approvalIdTextBox.Enabled = false;
-			this.approvalIdTextBox.Location = new System.Drawing.Point(113, 187);
-			this.approvalIdTextBox.Name = "approvalIdTextBox";
-			this.approvalIdTextBox.Size = new System.Drawing.Size(180, 20);
-			this.approvalIdTextBox.TabIndex = 18;
-			// 
-			// approvalIdLabel
-			// 
-			this.approvalIdLabel.AutoSize = true;
-			this.approvalIdLabel.Location = new System.Drawing.Point(6, 190);
-			this.approvalIdLabel.Name = "approvalIdLabel";
-			this.approvalIdLabel.Size = new System.Drawing.Size(61, 13);
-			this.approvalIdLabel.TabIndex = 17;
-			this.approvalIdLabel.Text = "Approval Id";
-			// 
-			// benchNameTextBox
-			// 
-			this.benchNameTextBox.Enabled = false;
-			this.benchNameTextBox.Location = new System.Drawing.Point(113, 44);
-			this.benchNameTextBox.Name = "benchNameTextBox";
-			this.benchNameTextBox.Size = new System.Drawing.Size(180, 20);
-			this.benchNameTextBox.TabIndex = 4;
-			// 
-			// benchNameLabel
-			// 
-			this.benchNameLabel.AutoSize = true;
-			this.benchNameLabel.Location = new System.Drawing.Point(6, 46);
-			this.benchNameLabel.Name = "benchNameLabel";
-			this.benchNameLabel.Size = new System.Drawing.Size(90, 13);
-			this.benchNameLabel.TabIndex = 3;
-			this.benchNameLabel.Text = "Test bench name";
-			// 
-			// ComponentCfgCtrl
-			// 
-			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-			this.Controls.Add(this.benchNameTextBox);
-			this.Controls.Add(this.benchNameLabel);
-			this.Controls.Add(this.approvedByTextBox);
-			this.Controls.Add(this.approvedByLabel);
-			this.Controls.Add(this.approvalDateTextBox);
-			this.Controls.Add(this.approvalDateLabel);
-			this.Controls.Add(this.approvalIdTextBox);
-			this.Controls.Add(this.approvalIdLabel);
-			this.Controls.Add(this.address5TextBox);
-			this.Controls.Add(this.address5Label);
-			this.Controls.Add(this.address4TextBox);
-			this.Controls.Add(this.address4Label);
-			this.Controls.Add(this.address3TextBox);
-			this.Controls.Add(this.address3Label);
-			this.Controls.Add(this.address2TextBox);
-			this.Controls.Add(this.address2Label);
-			this.Controls.Add(this.address1TextBox);
-			this.Controls.Add(this.address1Label);
-			this.Controls.Add(this.benchIdTextBox);
-			this.Controls.Add(this.benchIdLabel);
-			this.Controls.Add(this.nameTextBox);
-			this.Controls.Add(this.nameLabel);
-			this.Controls.Add(this.classNameLabel);
-			this.Name = "ComponentCfgCtrl";
-			this.Size = new System.Drawing.Size(300, 250);
-			this.Load += new System.EventHandler(this.EntryFormCfgCtrl_Load);
-			this.ResumeLayout(false);
-			this.PerformLayout();
-
-		}
-
-		#endregion
-
-		private System.Windows.Forms.TextBox nameTextBox;
-		private System.Windows.Forms.Label nameLabel;
-		private System.Windows.Forms.Label classNameLabel;
-		private System.Windows.Forms.Label benchIdLabel;
-		private System.Windows.Forms.TextBox benchIdTextBox;
-		private System.Windows.Forms.TextBox address1TextBox;
-		private System.Windows.Forms.Label address1Label;
-		private System.Windows.Forms.TextBox address2TextBox;
-		private System.Windows.Forms.Label address2Label;
-		private System.Windows.Forms.TextBox address3TextBox;
-		private System.Windows.Forms.Label address3Label;
-		private System.Windows.Forms.TextBox address4TextBox;
-		private System.Windows.Forms.Label address4Label;
-		private System.Windows.Forms.TextBox address5TextBox;
-		private System.Windows.Forms.Label address5Label;
-		private System.Windows.Forms.TextBox approvedByTextBox;
-		private System.Windows.Forms.Label approvedByLabel;
-		private System.Windows.Forms.TextBox approvalDateTextBox;
-		private System.Windows.Forms.Label approvalDateLabel;
-		private System.Windows.Forms.TextBox approvalIdTextBox;
-		private System.Windows.Forms.Label approvalIdLabel;
-		private System.Windows.Forms.TextBox benchNameTextBox;
-		private System.Windows.Forms.Label benchNameLabel;
-	}
-}

TBF/BenchControl/ComponentCfgBase.cs

@@ -94,7 +94,7 @@ namespace TBF.BenchControl
         }
 
 
-		protected virtual XmlSerializer GetSerializer() { return new XmlSerializer(GetType()); }
+		public virtual XmlSerializer GetSerializer() { return new XmlSerializer(GetType()); }
 		
         public Component CreateDbEntity()
         {
@@ -124,56 +124,146 @@ namespace TBF.BenchControl
             }
         }
 
-		/// <summary>
-		/// Default implementation returning null - no test aprameters.
-		/// In case there are any test parameters, this function override should return
-		/// a reference to a class that implements IParamsProvider and ITestParams.
-		/// </summary>
-		/// <returns>Test parameters obtained by the last UpdateTestParams(test)</returns>
-		public virtual IParamsProvider GetTestParams()
-		{
-			return null;
-		}
 
-		/// <summary>
-		/// Default implementation returning null - no procedure parameters.
-		/// In case there are any procedure parameters, this function override should return
-		/// a reference to a class that implements IParamsProvider and IProcedureParams.
-		/// </summary>
-		/// <returns>Procedure parameters obtained by the last UpdateProcedureParams(procedure)</returns>
-		public virtual IParamsProvider GetProcedureParams()
+		public void LoadTestParamsFromDB(Test test)
 		{
-			return null;
-		}
-
-
-		public void UpdateTestParams(Test test)
-		{
-			ITestParams tstPrms = (GetTestParams() as ITestParams);
+			ITestParams tstPrms = (GetRuntimeTestParamsProvider() as ITestParams);
 			if (tstPrms != null)
 			{
-				tstPrms.UpdateTestParams(Name, test);
+				tstPrms.FromDbEntity(Name, test);
 			}
 		}
 
-		public void UpdateProcedureParams(Procedure procedure)
+
+		public void LoadProcedureParamsFromDB(Procedure procedure)
 		{
-			IProcedureParams procPrms = (GetProcedureParams() as IProcedureParams);
+			IProcedureParams procPrms = (GetRuntimeProcParamsProvider() as IProcedureParams);
 			if (procPrms != null)
 			{
-				procPrms.UpdateProcedureParams(Name, procedure);
+				procPrms.FromDbEntity(Name, procedure);
 			}
 		}
 
 
-		public virtual IParamsProvider CreateTestParams(Test test)
-		{
-			return null;
-		}
+        /// <summary>
+        /// If there are any procedure parameters, this function should be overriden
+        /// by one returning a reference to a newly created object
+        /// implementing IParamsProvider and IProcedureParams.
+        /// 
+        /// This default implementation returns null = no procedure parameters.
+        /// </summary>
+        /// <returns>Procedure parameters provider for this component or null</returns>
+        public virtual IParamsProvider CreateProcParamsProvider()
+        {
+            return null;
+        }
 
-		public virtual IParamsProvider CreateProcedureParams(Procedure procedure)
-		{
-			return null;
-		}
+        /// <summary>
+        /// If there are any procedure parameters, this function should be overriden
+        /// by one returning a reference to an object
+        /// implementing IParamsProvider and IProcedureParams used in runtime.
+        /// 
+        /// This default implementation returns null = no procedure parameters.
+        /// </summary>
+        /// <returns>Procedure parameters provider for this component or null</returns>
+        public virtual IParamsProvider GetRuntimeProcParamsProvider()
+        {
+            return null;
+        }
+
+        public virtual IParamsProvider GetUIProcParamsProvider(Procedure procedure)
+        {
+            if (GetRuntimeProcParamsProvider() == null)
+            {
+                /// Component has no test parametes
+                return null;
+            }
+
+            ComponentProcedure procParamsEntity = procedure.GetProcedureParamsEntity(Name);
+
+            if (procParamsEntity != null)
+            {
+                if (procParamsEntity.GetParamsProvider() != null)
+                {
+                    /// Parameters provider for this entity already fetched - return it
+                    return procParamsEntity.GetParamsProvider();
+                }
+                else
+                {
+                    /// Parameters provider for this entity will be created and updated from the entity later on
+                    IParamsProvider paramsProvider = CreateProcParamsProvider();
+                    (paramsProvider as IProcedureParams).UpdateFromDbEntity(procParamsEntity);
+                    procParamsEntity.SetParamsProvider(paramsProvider);
+                    return paramsProvider;
+                }
+            }
+            else
+            {
+                IParamsProvider paramsProvider = CreateProcParamsProvider();
+                (paramsProvider as IProcedureParams).FromDbEntity(Name, procedure);
+                return paramsProvider;
+            }
+        }
+
+
+        /// <summary>
+        /// If there are any procedure parameters, this function should be overriden
+        /// by one returning a reference to a newly created object
+        /// implementing IParamsProvider and ITestParams.
+        /// 
+        /// This default implementation returns null = no test parameters.
+        /// </summary>
+        /// <returns>Procedure parameters provider for this component or null</returns>
+        public virtual IParamsProvider CreateTestParamsProvider()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// If there are any test parameters, this function should be overriden
+        /// by one returning a reference to an object
+        /// implementing IParamsProvider and ITestParams used in runtime.
+        /// 
+        /// This default implementation returns null = no test parameters.
+        /// </summary>
+        /// <returns>Test parameters provider for this component or null</returns>
+        public virtual IParamsProvider GetRuntimeTestParamsProvider()
+        {
+            return null;
+        }
+
+        public virtual IParamsProvider GetUITestParamsProvider(Test test)
+        {
+            if (GetRuntimeTestParamsProvider() == null)
+            {
+                /// Component has no test parametes
+                return null;
+            }
+
+            ComponentTest testParamsEntity = test.GetTestParamsEntity(Name);
+
+            if (testParamsEntity != null)
+            {
+                if (testParamsEntity.GetParamsProvider() != null)
+                {
+                    /// Parameters provider for this entity already fetched - return it
+                    return testParamsEntity.GetParamsProvider();
+                }
+                else
+                {
+                    /// Parameters provider for this entity will be created and updated from the entity later on
+                    IParamsProvider paramsProvider = CreateTestParamsProvider();
+                    (paramsProvider as ITestParams).UpdateFromDbEntity(testParamsEntity);
+                    testParamsEntity.SetParamsProvider(paramsProvider);
+                    return paramsProvider;
+                }
+            }
+            else
+            {
+                IParamsProvider paramsProvider = CreateTestParamsProvider();
+                (paramsProvider as ITestParams).FromDbEntity(Name, test);
+                return paramsProvider;
+            }
+        }
 	}
 }

TBF/BenchControl/Configs/NameOnly/TestMethodCfg.cs

@@ -9,7 +9,7 @@ namespace TBF.BenchControl.Configs.NameOnly
 	public class TestMethodCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(TestMethodCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new TestMethodCfgCtrl(); }
 

TBF/BenchControl/Configs/NameOnly/TestMethodCfgCtrl.cs

@@ -3,15 +3,13 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.Configs.NameOnly
 {
 	public partial class TestMethodCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(TestMethodCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		TestMethodCfg config;

TBF/BenchControl/Configs/ParamsProvider/ComponentCfgCtrl.cs

@@ -0,0 +1,193 @@
+///
+/// Copyright (c) 2018 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using log4net;
+using Config.Entities;
+using TBF.BenchControl.Generic;
+using TBF.Resources;
+
+namespace TBF.BenchControl.Configs.ParamsProvider
+{
+	public partial class ComponentCfgCtrl : UserControl, IComponentCfgCtrl
+	{
+        static readonly ILog log = LogManager.GetLogger(typeof(ComponentCfgCtrl));
+
+		public bool ShowMore { get { return false; } }
+
+
+		IParamsProvider paramsProvider;
+        /// 
+        public IComponentCfg Config
+		{
+			get
+            {
+                return paramsProvider as IComponentCfg;
+            }
+			set
+			{
+                paramsProvider = value as IParamsProvider;
+				Redraw();
+			}
+		}
+
+        IList<string> parents;
+        Control[] editors;
+        CfgUpdateFlags flags;
+
+        public ComponentCfgCtrl()
+		{
+			InitializeComponent();
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="paramsProvider">Parameters provider implementing IComponentCfg and IParamsProvider</param>
+        /// <param name="parents">A list of parents or null, null hides parentComboBox</param>
+        public ComponentCfgCtrl(IParamsProvider paramsProvider, IList<string> parents)
+            : this()
+        {
+            this.paramsProvider = paramsProvider;
+            this.parents = parents;
+
+            if (parents == null)
+            {
+                parentLabel.Visible = false;
+                parentComboBox.Visible = false;
+            }
+
+            editors = new Control[paramsProvider.ParamsCount()];
+            for (int i = 0; i < paramsProvider.ParamsCount(); i++)
+            {
+                IList<string> values = paramsProvider.ParamValues(i);
+                if (values == null)
+                {
+                    editors[i] = new TextBox();
+                }
+                else
+                {
+                    ComboBox cb = new ComboBox(); 
+                    foreach (var v in values) cb.Items.Add(v);
+                    editors[i] = cb;
+                }
+                editors[i].Visible = false;
+                this.Controls.Add(editors[i]);
+            }
+
+            flags = CfgUpdateFlags.None;
+
+            paramsListViewEx.SubItemClicked += new Results.Forms.SubItemEventHandler(paramsListViewEx_SubItemClicked);
+            paramsListViewEx.SubItemEndEditing += new Results.Forms.SubItemEndEditingEventHandler(paramsListViewEx_SubItemEndEditing);
+        }
+
+        void Localize()
+        {
+            componentClassLabel.Text = Strings.Component_class;
+            nameLabel.Text = Strings.Name;
+            parentLabel.Text = Strings.Parent_name;
+        }
+
+		private void EntryFormCfgCtrl_Load(object sender, EventArgs e)
+		{
+            Localize();
+            paramsListViewEx.Columns.Add(Strings.Parameter, 210);
+            paramsListViewEx.Columns.Add(Strings.Value, 210);
+            if (parents != null)
+            {
+                foreach (var p in parents) parentComboBox.Items.Add(p);
+            }
+			Redraw();
+		}
+
+		public void Closing()
+		{
+            /// Close CmdResponse handlers here
+		}
+
+		void Redraw()
+		{
+			if (paramsProvider == null) return;			/// Control was not loaded, settings were not changed
+
+			componentClassTextBox.Text = Config.Factory.ClassName;
+			nameTextBox.Text = Config.Name;
+
+            if (parents != null) parentComboBox.Text = Config.ParentName;
+
+            paramsListViewEx.Items.Clear();
+            for (int i = 0; i < paramsProvider.ParamsCount(); i++)
+            {
+                ListViewItem lvi = new ListViewItem(paramsProvider.ParamName(i));
+                lvi.SubItems.Add(paramsProvider.ToString(i));
+                lvi.Tag = i;
+                paramsListViewEx.Items.Add(lvi);
+            }
+		}
+
+		public void Unlock()
+		{
+			nameTextBox.Enabled = true;
+            if (parents != null) parentComboBox.Enabled = true;
+            paramsListViewEx.Enabled = true;
+		}
+
+		public CfgUpdateFlags VerifyCfg(ref string message)
+		{
+            if (parents == null) return CfgUpdateFlags.None;
+
+            /// Verify the parent
+            foreach (var item in parentComboBox.Items)
+            {
+                if (parentComboBox.Text == item.ToString()) return CfgUpdateFlags.None;
+            }
+
+            message += Environment.NewLine + string.Format(Strings.Invalid_0, parentLabel.Text);
+            return CfgUpdateFlags.Error;
+		}
+
+		public CfgUpdateFlags UpdateCfg()
+		{
+            if (paramsProvider == null) return CfgUpdateFlags.Error;	/// Control was not loaded, settings were not changed
+
+            CfgUpdateFlags f = this.flags;
+
+            if (Config.Name != nameTextBox.Text)
+            {
+                Config.Name = nameTextBox.Text;
+                f |= CfgUpdateFlags.RestartRqrd;
+            }
+
+            if (parents != null)
+            {
+                if (Config.ParentName != parentComboBox.Text)
+                {
+                    Config.ParentName = parentComboBox.Text;
+                    f |= CfgUpdateFlags.RestartRqrd;
+                }
+            }
+
+			return f;
+		}
+
+        private void paramsListViewEx_SubItemClicked(object sender, Results.Forms.SubItemEventArgs e)
+        {
+            if (e.SubItem != 1) return;
+            int itemNr = (int)e.Item.Tag;
+            paramsListViewEx.StartEditing(editors[itemNr], e.Item, e.SubItem);
+        }
+
+        private void paramsListViewEx_SubItemEndEditing(object sender, Results.Forms.SubItemEndEditingEventArgs e)
+        {
+            if (e.SubItem != 1) return;
+            int itemNr = (int)e.Item.Tag;
+
+            string message;
+            if (paramsProvider.ValidateParam(itemNr, e.DisplayText, out message))
+            {
+                flags |= paramsProvider.UpdateParam(itemNr, e.DisplayText);
+            }
+        }
+	}
+}

TBF/BenchControl/Configs/ParamsProvider/ComponentCfgCtrl.designer.cs

@@ -0,0 +1,171 @@
+///
+/// Copyright (c) 2018 Sensus Slovensko a.s.
+///
+namespace TBF.BenchControl.Configs.ParamsProvider
+{
+	partial class ComponentCfgCtrl
+	{
+		/// <summary> 
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary> 
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Component Designer generated code
+
+		/// <summary> 
+		/// Required method for Designer support - do not modify 
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+            this.nameTextBox = new System.Windows.Forms.TextBox();
+            this.nameLabel = new System.Windows.Forms.Label();
+            this.splitContainer1 = new System.Windows.Forms.SplitContainer();
+            this.parentComboBox = new System.Windows.Forms.ComboBox();
+            this.parentLabel = new System.Windows.Forms.Label();
+            this.componentClassLabel = new System.Windows.Forms.Label();
+            this.componentClassTextBox = new System.Windows.Forms.TextBox();
+            this.paramsListViewEx = new Results.Forms.ListViewEx();
+            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
+            this.splitContainer1.Panel1.SuspendLayout();
+            this.splitContainer1.Panel2.SuspendLayout();
+            this.splitContainer1.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // nameTextBox
+            // 
+            this.nameTextBox.Enabled = false;
+            this.nameTextBox.Location = new System.Drawing.Point(161, 30);
+            this.nameTextBox.Name = "nameTextBox";
+            this.nameTextBox.Size = new System.Drawing.Size(262, 20);
+            this.nameTextBox.TabIndex = 5;
+            // 
+            // nameLabel
+            // 
+            this.nameLabel.AutoSize = true;
+            this.nameLabel.Location = new System.Drawing.Point(6, 33);
+            this.nameLabel.Name = "nameLabel";
+            this.nameLabel.Size = new System.Drawing.Size(35, 13);
+            this.nameLabel.TabIndex = 4;
+            this.nameLabel.Text = "Name";
+            // 
+            // 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";
+            this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal;
+            // 
+            // splitContainer1.Panel1
+            // 
+            this.splitContainer1.Panel1.Controls.Add(this.parentComboBox);
+            this.splitContainer1.Panel1.Controls.Add(this.parentLabel);
+            this.splitContainer1.Panel1.Controls.Add(this.componentClassLabel);
+            this.splitContainer1.Panel1.Controls.Add(this.componentClassTextBox);
+            this.splitContainer1.Panel1.Controls.Add(this.nameLabel);
+            this.splitContainer1.Panel1.Controls.Add(this.nameTextBox);
+            // 
+            // splitContainer1.Panel2
+            // 
+            this.splitContainer1.Panel2.Controls.Add(this.paramsListViewEx);
+            this.splitContainer1.Size = new System.Drawing.Size(444, 353);
+            this.splitContainer1.SplitterDistance = 80;
+            this.splitContainer1.TabIndex = 6;
+            // 
+            // parentComboBox
+            // 
+            this.parentComboBox.Enabled = false;
+            this.parentComboBox.FormattingEnabled = true;
+            this.parentComboBox.Location = new System.Drawing.Point(161, 52);
+            this.parentComboBox.Name = "parentComboBox";
+            this.parentComboBox.Size = new System.Drawing.Size(262, 21);
+            this.parentComboBox.TabIndex = 9;
+            // 
+            // parentLabel
+            // 
+            this.parentLabel.AutoSize = true;
+            this.parentLabel.Location = new System.Drawing.Point(6, 55);
+            this.parentLabel.Name = "parentLabel";
+            this.parentLabel.Size = new System.Drawing.Size(38, 13);
+            this.parentLabel.TabIndex = 8;
+            this.parentLabel.Text = "Parent";
+            // 
+            // componentClassLabel
+            // 
+            this.componentClassLabel.AutoSize = true;
+            this.componentClassLabel.Location = new System.Drawing.Point(6, 11);
+            this.componentClassLabel.Name = "componentClassLabel";
+            this.componentClassLabel.Size = new System.Drawing.Size(89, 13);
+            this.componentClassLabel.TabIndex = 7;
+            this.componentClassLabel.Text = "Component Class";
+            // 
+            // componentClassTextBox
+            // 
+            this.componentClassTextBox.Enabled = false;
+            this.componentClassTextBox.Location = new System.Drawing.Point(161, 8);
+            this.componentClassTextBox.Name = "componentClassTextBox";
+            this.componentClassTextBox.Size = new System.Drawing.Size(262, 20);
+            this.componentClassTextBox.TabIndex = 6;
+            // 
+            // paramsListViewEx
+            // 
+            this.paramsListViewEx.AllowColumnReorder = true;
+            this.paramsListViewEx.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.paramsListViewEx.DoubleClickActivation = false;
+            this.paramsListViewEx.Enabled = false;
+            this.paramsListViewEx.FullRowSelect = true;
+            this.paramsListViewEx.GridLines = true;
+            this.paramsListViewEx.LabelWrap = false;
+            this.paramsListViewEx.Location = new System.Drawing.Point(0, 0);
+            this.paramsListViewEx.Name = "paramsListViewEx";
+            this.paramsListViewEx.Size = new System.Drawing.Size(444, 269);
+            this.paramsListViewEx.TabIndex = 0;
+            this.paramsListViewEx.UseCompatibleStateImageBehavior = false;
+            this.paramsListViewEx.View = System.Windows.Forms.View.Details;
+            this.paramsListViewEx.SubItemClicked += new Results.Forms.SubItemEventHandler(this.paramsListViewEx_SubItemClicked);
+            this.paramsListViewEx.SubItemEndEditing += new Results.Forms.SubItemEndEditingEventHandler(this.paramsListViewEx_SubItemEndEditing);
+            // 
+            // ComponentCfgCtrl
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.splitContainer1);
+            this.Name = "ComponentCfgCtrl";
+            this.Size = new System.Drawing.Size(444, 353);
+            this.Load += new System.EventHandler(this.EntryFormCfgCtrl_Load);
+            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.ResumeLayout(false);
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.TextBox nameTextBox;
+        private System.Windows.Forms.Label nameLabel;
+        private System.Windows.Forms.SplitContainer splitContainer1;
+        private System.Windows.Forms.ComboBox parentComboBox;
+        private System.Windows.Forms.Label parentLabel;
+        private System.Windows.Forms.Label componentClassLabel;
+        private System.Windows.Forms.TextBox componentClassTextBox;
+        private Results.Forms.ListViewEx paramsListViewEx;
+	}
+}

TBF/BenchControl/DB/SensusOracle/DatabaseCfg.cs

@@ -31,7 +31,7 @@ namespace TBF.BenchControl.DB.SensusOracle
 	public class DatabaseCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(DatabaseCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new DatabaseCfgCtrl(); }
 

TBF/BenchControl/DB/SensusOracle/DatabaseCfgCtrl.cs

@@ -4,15 +4,13 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.DB.SensusOracle
 {
 	public partial class DatabaseCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(DatabaseCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		DatabaseCfg config;

TBF/BenchControl/Danfoss/VLT2800/PumpCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.Danfoss.VLT2800
     public class PumpCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(PumpCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new PumpCfgCtrl(); }
 

TBF/BenchControl/Danfoss/VLT2800/PumpCfgCtrl.cs

@@ -4,15 +4,13 @@
 using System;
 using System.Windows.Forms;
 using System.IO.Ports;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.Danfoss.VLT2800
 {
 	public partial class PumpCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(PumpCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		PumpCfg config;

TBF/BenchControl/DataEntry/Combined/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.Combined
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/Combined/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -11,8 +11,6 @@ namespace TBF.BenchControl.DataEntry.Combined
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/HeatMeters12/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/HeatMeters12/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 using Config;
@@ -12,8 +12,6 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/HeatMeters6/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/HeatMeters6/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 using Config;
@@ -12,8 +12,6 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/Munich/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.Munich
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/Munich/EntryFormCfgCtrl.cs

@@ -3,15 +3,13 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.DataEntry.Munich
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/Munich3/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.Munich3
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/Munich3/EntryFormCfgCtrl.cs

@@ -3,15 +3,13 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.DataEntry.Munich3
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/Standard12/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.Standard12
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/Standard12/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -11,8 +11,6 @@ namespace TBF.BenchControl.DataEntry.Standard12
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/Standard12/TestStartEndForm.cs

@@ -216,6 +216,8 @@ namespace TBF.BenchControl.DataEntry.Standard12
 
 		private void okButton_Click(object sender, EventArgs eArgs)
 		{
+            log.Debug("okButton_Click(..)");
+
             try
             {
 				if (endStates)
@@ -240,7 +242,7 @@ namespace TBF.BenchControl.DataEntry.Standard12
 					}
 				}
 			}
-            catch(Exception e)
+            catch (Exception e)
             {
 				log.ErrorFormat("Exception: {0}", e.Message);
                 return;

TBF/BenchControl/DataEntry/Standard24/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.Standard24
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/Standard24/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -11,8 +11,6 @@ namespace TBF.BenchControl.DataEntry.Standard24
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/Standard48/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.Standard48
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/Standard48/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -11,8 +11,6 @@ namespace TBF.BenchControl.DataEntry.Standard48
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/Standard6/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.Standard6
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/Standard6/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -11,8 +11,6 @@ namespace TBF.BenchControl.DataEntry.Standard6
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/Standard6/TestStartEndForm.cs

@@ -70,10 +70,10 @@ namespace TBF.BenchControl.DataEntry.Standard6
 
 			this.WaterMetersCount = waterMetersCount;
 			this.regReaders = regReaders;
-			this.WMStartStateStr = wmStartStateStr;
-			if (wmStartStateStr == null || wmStartStateStr.Length != waterMetersCount)
+			if (wmStartStateStr == null || wmStartStateStr.Length < waterMetersCount)
 				throw (new Exception("Invalid 'wmStartStateStr' argument"));
-			this.disabled = disabled;
+            this.WMStartStateStr = wmStartStateStr;
+            this.disabled = disabled;
             this.refVolume = refVolume;
             this.warningLimLo = 2 * errLimLo;
             this.warningLimHi = 2 * errLimHi;
@@ -153,55 +153,34 @@ namespace TBF.BenchControl.DataEntry.Standard6
 			okButton.Text = Strings.OkBtnText;
 		}
 
-		private void okButton_Click(object sender, EventArgs e)
+		private void okButton_Click(object sender, EventArgs eArgs)
 		{
+            log.Debug("okButton_Click(..)");
+
             try
             {
 				if (endStates)
 				{
-					if (wmEndStateTextBox1.Enabled) WMEndState[0] = Utils.ParseUDouble(wmEndStateTextBox1.Text);
-					if (wmEndStateTextBox2.Enabled) WMEndState[1] = Utils.ParseUDouble(wmEndStateTextBox2.Text);
-					if (wmEndStateTextBox3.Enabled) WMEndState[2] = Utils.ParseUDouble(wmEndStateTextBox3.Text);
-					if (wmEndStateTextBox4.Enabled) WMEndState[3] = Utils.ParseUDouble(wmEndStateTextBox4.Text);
-					if (wmEndStateTextBox5.Enabled) WMEndState[4] = Utils.ParseUDouble(wmEndStateTextBox5.Text);
-					if (wmEndStateTextBox6.Enabled) WMEndState[5] = Utils.ParseUDouble(wmEndStateTextBox6.Text);
+                    if (wmEndStateTextBox1.Enabled && WaterMetersCount >= 1) WMEndState[0] = Utils.ParseUDouble(wmEndStateTextBox1.Text);
+                    if (wmEndStateTextBox2.Enabled && WaterMetersCount >= 2) WMEndState[1] = Utils.ParseUDouble(wmEndStateTextBox2.Text);
+                    if (wmEndStateTextBox3.Enabled && WaterMetersCount >= 3) WMEndState[2] = Utils.ParseUDouble(wmEndStateTextBox3.Text);
+                    if (wmEndStateTextBox4.Enabled && WaterMetersCount >= 4) WMEndState[3] = Utils.ParseUDouble(wmEndStateTextBox4.Text);
+                    if (wmEndStateTextBox5.Enabled && WaterMetersCount >= 5) WMEndState[4] = Utils.ParseUDouble(wmEndStateTextBox5.Text);
+                    if (wmEndStateTextBox6.Enabled && WaterMetersCount >= 6) WMEndState[5] = Utils.ParseUDouble(wmEndStateTextBox6.Text);
 				}
 				else
 				{
-					if (wmStartStateTextBox1.Enabled)
-					{
-						WMStartStateStr[0] = wmStartStateTextBox1.Text;
-						WMStartState[0] = Utils.ParseUDouble(wmStartStateTextBox1.Text);
-					}
-					if (wmStartStateTextBox2.Enabled)
-					{
-						WMStartStateStr[1] = wmStartStateTextBox2.Text;
-						WMStartState[1] = Utils.ParseUDouble(wmStartStateTextBox2.Text);
-					}
-					if (wmStartStateTextBox3.Enabled)
-					{
-						WMStartStateStr[2] = wmStartStateTextBox3.Text;
-						WMStartState[2] = Utils.ParseUDouble(wmStartStateTextBox3.Text);
-					}
-					if (wmStartStateTextBox4.Enabled)
-					{
-						WMStartStateStr[3] = wmStartStateTextBox4.Text;
-						WMStartState[3] = Utils.ParseUDouble(wmStartStateTextBox4.Text);
-					}
-					if (wmStartStateTextBox5.Enabled)
-					{
-						WMStartStateStr[4] = wmStartStateTextBox5.Text;
-						WMStartState[4] = Utils.ParseUDouble(wmStartStateTextBox5.Text);
-					}
-					if (wmStartStateTextBox6.Enabled)
-					{
-						WMStartStateStr[5] = wmStartStateTextBox6.Text;
-						WMStartState[5] = Utils.ParseUDouble(wmStartStateTextBox6.Text);
-					}
+                    if (wmStartStateTextBox1.Enabled && WaterMetersCount >= 1) { WMStartStateStr[0] = wmStartStateTextBox1.Text; WMStartState[0] = Utils.ParseUDouble(wmStartStateTextBox1.Text); }
+                    if (wmStartStateTextBox2.Enabled && WaterMetersCount >= 2) { WMStartStateStr[1] = wmStartStateTextBox2.Text; WMStartState[1] = Utils.ParseUDouble(wmStartStateTextBox2.Text); }
+                    if (wmStartStateTextBox3.Enabled && WaterMetersCount >= 3) { WMStartStateStr[2] = wmStartStateTextBox3.Text; WMStartState[2] = Utils.ParseUDouble(wmStartStateTextBox3.Text); }
+                    if (wmStartStateTextBox4.Enabled && WaterMetersCount >= 4) { WMStartStateStr[3] = wmStartStateTextBox4.Text; WMStartState[3] = Utils.ParseUDouble(wmStartStateTextBox4.Text); }
+                    if (wmStartStateTextBox5.Enabled && WaterMetersCount >= 5) { WMStartStateStr[4] = wmStartStateTextBox5.Text; WMStartState[4] = Utils.ParseUDouble(wmStartStateTextBox5.Text); }
+                    if (wmStartStateTextBox6.Enabled && WaterMetersCount >= 6) { WMStartStateStr[5] = wmStartStateTextBox6.Text; WMStartState[5] = Utils.ParseUDouble(wmStartStateTextBox6.Text); }
 				}
 			}
-            catch
+            catch (Exception e)
             {
+                log.ErrorFormat("Exception: {0}", e.Message);
                 return;
             }
 

TBF/BenchControl/DataEntry/StandardCamera/EntryFormCfg.cs

@@ -10,7 +10,7 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/StandardCamera/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -11,8 +11,6 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/WMStates/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.WMStates
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/WMStates/EntryFormCfgCtrl.cs

@@ -3,15 +3,13 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.DataEntry.WMStates
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/DataEntry/iPerl/EntryFormCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.DataEntry.iPerl
 	public class EntryFormCfg : ComponentCfgBase, Generic.IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(EntryFormCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new EntryFormCfgCtrl(); }
 

TBF/BenchControl/DataEntry/iPerl/EntryFormCfgCtrl.cs

@@ -3,7 +3,7 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 using TBF.Resources;
 
@@ -11,8 +11,6 @@ namespace TBF.BenchControl.DataEntry.iPerl
 {
 	public partial class EntryFormCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(EntryFormCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		EntryFormCfg config;

TBF/BenchControl/Dummy/Diverter/Component.cs

@@ -27,7 +27,10 @@ namespace TBF.BenchControl.Dummy.Diverter
             log.Debug(this.ToString());
         }
 
-		bool state;
-		public bool State { get { return state; } }
-	}
+        public int DiverterNr { get { return 0; } }
+		public bool State { get { return false; } }
+        public int ThresholdGate { get { return 50; } }
+        public int ThresholdLo { get { return 10; } }
+        public int ThresholdHi { get { return 90; } }
+    }
 }

TBF/BenchControl/Dummy/FlowMeter/FlowMeterCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.Dummy.FlowMeter
     public class FlowMeterCfg : ComponentCfgBase, IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(FlowMeterCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new FlowMeterCfgCtrl(); }
 

TBF/BenchControl/Dummy/FlowMeter/FlowMeterCfgCtrl.cs

@@ -4,15 +4,13 @@
 using System;
 using System.Globalization;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.Dummy.FlowMeter
 {
 	public partial class FlowMeterCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-        static readonly ILog log = LogManager.GetLogger(typeof(FlowMeterCfgCtrl));
-
 		ComponentParametersDlg parent;
 
 		public bool ShowMore { get { return false; } }

TBF/BenchControl/Dummy/RegulValve/RegulValveCfg.cs

@@ -9,7 +9,7 @@ namespace TBF.BenchControl.Dummy.RegulValve
     public class RegulValveCfg : ComponentCfgBase, IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(RegulValveCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new RegulValveCfgCtrl(); }
 

TBF/BenchControl/Dummy/RegulValve/RegulValveCfgCtrl.cs

@@ -3,15 +3,13 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.Dummy.RegulValve
 {
 	public partial class RegulValveCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(RegulValveCfgCtrl));
-
 		ComponentParametersDlg parent;
 
 		public bool ShowMore { get { return true; } }

TBF/BenchControl/Elde/Common.cs

@@ -19,7 +19,7 @@ namespace TBF.BenchControl.Elde
         EnduranceCycleStop = 13,
     }
 
-#if FUZHOU300 || PT200IL || TORINO50 || BADGER_MALA_TRAT || BADGER_STREDNA_TRAT || TURA_IPERL || TURA_SPECIAL || BADGER_VELKA_TRAT || PUCHONG_PT200 || SLM_50 || GENESIS || MALTA_WSD25 || SLM_END || WARSAW_END || BERLIN || SLM_150 || PETERSBURG_50 || PETERSBURG_200 || KEMPNO_50 || BAHRAIN_50 || RUM_MOB || KRAKOW_50 || JUZNA_AFRIKA_50
+#if FUZHOU300 || PT200IL || TORINO50 || BADGER_MALA_TRAT || BADGER_STREDNA_TRAT || TURA_IPERL || TURA_SPECIAL || BADGER_VELKA_TRAT || PUCHONG_PT200 || SLM_50 || GENESIS || MALTA_WSD25 || SLM_END || WARSAW_END || BERLIN || SLM_150 || PETERSBURG_50 || PETERSBURG_200 || KEMPNO_50 || BAHRAIN_50 || RUM_MOB || KRAKOW_50 || JUZNA_AFRIKA_50 || ZAMBIA || SENTEC
     public enum StatusP : ulong
     {
         RefFlowMeterMask  = 0x7,                /// bits 0,1,2

TBF/BenchControl/Elde/ControlBoardCfg.cs

@@ -11,7 +11,7 @@ namespace TBF.BenchControl.Elde
     public class ControlBoardCfg : ComponentCfgBase, IComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ControlBoardCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new ControlBoardCfgCtrl(); }
 

TBF/BenchControl/Elde/ControlBoardCfgCtrl.cs

@@ -3,15 +3,13 @@
 ///
 using System;
 using System.Windows.Forms;
-using log4net;
+using Config.Entities;
 using TBF.BenchControl.Generic;
 
 namespace TBF.BenchControl.Elde
 {
 	public partial class ControlBoardCfgCtrl : UserControl, IComponentCfgCtrl
 	{
-		static readonly ILog log = LogManager.GetLogger(typeof(ControlBoardCfgCtrl));
-
 		public bool ShowMore { get { return false; } }
 
 		ControlBoardCfg config;

TBF/BenchControl/Elde/ControlBoardDev.cs

@@ -58,7 +58,7 @@ namespace TBF.BenchControl.Elde
 		public uint BeginState(int wmNr0)                 { return controlCom.BeginState(wmNr0); }
 		public double ReferenceFlow                 { get { return controlCom.ReferenceFlow; } }
 		public float RValvePosition(int rvNr1)            { return controlCom.RValvePosition(rvNr1); }
-		public float DivSamples(int ms)                   { return controlCom.DivSamples(ms); }
+        public float DivSamples(int time, int divIx0)     { return controlCom.DivSamples(time, divIx0); }     /// Time unit is 2 ms
 		public int ScopeSamples(int i, int j, int k)      { return controlCom.ScopeSamples(i, j, k); }
 		public ulong DigitalInputs                  { get { return controlCom.DigitalInputs; } }
 		public float AnalogInput(int adcNr0)              { return controlCom.AnalogInput(adcNr0); }
@@ -126,7 +126,7 @@ namespace TBF.BenchControl.Elde
 		public uint[] DiverterEdge;			/// Created and initialized in this.Initialize() 
 
         // Array length is the reference flowmeters count plus one
-#if DN100 || FUZHOU150 || FUZHOU300 || PT200IL || PUCHONG_PT200 || SLM_150
+#if DN100 || FUZHOU150 || FUZHOU300 || PT200IL || PUCHONG_PT200 || SLM_150 || SENTEC
         public uint[,] RegValveCalib = new uint[8,2] {{100,500},{100,500},{100,500},{100,500},{100,500},{100,500},{100,500},{100,500}};
 		public byte[] MeretRS485Address = new byte[4];
         public float[] EtCalib = new float[6] { 1, 1, 1, 1, 1, 1 };
@@ -137,7 +137,7 @@ namespace TBF.BenchControl.Elde
 														 {100,500}, {100,500}, {100,500}, {100,500} };
         public byte[] MeretRS485Address = new byte[4];
         public float[] EtCalib = new float[7] { 1, 1, 1, 1, 1, 1, 1 };
-#elif MUNICH || TORINO50 || BADGER_MALA_TRAT || BADGER_STREDNA_TRAT || TORUN_PT50_2015 || CEVAK_PT40_272 || TURA_IPERL || TURA_SPECIAL || MURES_PT40 || FUZHOU_40 || SLM_50 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50 || JUZNA_AFRIKA_50
+#elif MUNICH || TORINO50 || BADGER_MALA_TRAT || BADGER_STREDNA_TRAT || TORUN_PT50_2015 || CEVAK_PT40_272 || TURA_IPERL || TURA_SPECIAL || MURES_PT40 || FUZHOU_40 || SLM_50 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50 || JUZNA_AFRIKA_50 || ZAMBIA
         public uint[,] RegValveCalib = new uint[8,2] {{100,500},{100,500},{100,500},{100,500},{100,500},{100,500},{100,500},{100,500}};
 		public byte[] MeretRS485Address = new byte[4];
 		public float[] EtCalib = new float[5] { 1, 1, 1, 1, 1 };
@@ -317,9 +317,10 @@ namespace TBF.BenchControl.Elde
 			DiverterEdge = new uint[divertersCount * 2];
 			for (int i = 0; i < divertersCount; i++)
 			{
-				DiverterEdge[2 * i] = (uint)BenchControl.Elde.Diverter.Diverter.DivStartingLevelPct[i];
-				DiverterEdge[2 * i + 1] = (uint)BenchControl.Elde.Diverter.Diverter.DivStoppingLevelPct[i];
-                controlCom.SetDivLimit(i, 10, 90);
+				DiverterEdge[2 * i]     = (uint)BenchControl.Elde.Diverter.Diverter.Diverters[i].ThresholdGate;
+                DiverterEdge[2 * i + 1] = (uint)BenchControl.Elde.Diverter.Diverter.Diverters[i].ThresholdGate;
+                controlCom.SetDivLimit(i, (uint)BenchControl.Elde.Diverter.Diverter.Diverters[i].ThresholdLo,
+                                          (uint)BenchControl.Elde.Diverter.Diverter.Diverters[i].ThresholdHi);
 			}
 
 			controlCom.SendCalibData(RegValveCalib,
@@ -598,14 +599,20 @@ namespace TBF.BenchControl.Elde
         }
 
         /// <summary>
-        /// Starts the measurement.
-        /// Events: MeasurementStarted
+        /// Read diverter samples from the control board and calculated the transition time.
+        /// Events: Event.None
         /// </summary>
-        /// <param name="flowMeter">Flow meter</param>
-        /// <param name="readers">An array of register readers</param>
-        /// <param name="refPulses">Number of reference pulses to complete the test</param>
+        /// <param name="div">Diverter</param>
+        /// <param name="runsCountWhenSendingCmd">State machine ticks from test start/end when diverter read command is issued (obsolete)</param>
+        /// <param name="runsCountWhenReadingDiv">State machine ticks from test start/end when diverter samples are read</param>
+        /// <param name="transitionTimeSec">FloatBox for the resulting transition time in s</param>
+        /// <param name="plotter">Statistics for plotting diverter transitions</param>
+        /// <param name="batchNr">Batch number</param>
+        /// <param name="testName">Test name (without repetitions)</param>
+        /// <param name="repetition">Repetition number</param>
         /// <returns>Created operation</returns>
-        public IOperation ReadDiverterTransitionOp(int runsCountWhenSendingCmd, int runsCountWhenReadingDiv, TBF.Boxes.FloatBox tStart, TBF.Boxes.FloatBox tEnd)
+        public IOperation ReadDiverterTransitionOp(IDiverter div, int runsCountWhenSendingCmd, int runsCountWhenReadingDiv, TBF.Boxes.FloatBox transitionTimeSec,
+                                                   Sequences.Statistics plotter, int batchNr, string testName, int repetition)
         {
             if (controlBoardCfg.DebugLevel == DebugMode.Simulate)
             {
@@ -613,7 +620,7 @@ namespace TBF.BenchControl.Elde
             }
             else
             {
-                return new ReadDiverterTransitionOp(this, runsCountWhenSendingCmd, runsCountWhenReadingDiv, tStart, tEnd);
+                return new ReadDiverterTransitionOp(this, div, runsCountWhenSendingCmd, runsCountWhenReadingDiv, transitionTimeSec, plotter, batchNr, testName, repetition);
             }
         }
 

TBF/BenchControl/Elde/ControlComSim.cs

@@ -65,7 +65,7 @@ namespace TBF.BenchControl.Elde
 		public float ReferenceFlow { get { return referenceFlow; } }
 
 		public float RValvePosition(int rvNr1) { return 0; }
-		public float DivSamples(int ms) { return 0; }
+		public float DivSamples(int ms, int divIx0) { return 0; }
 		public int ScopeSamples(int i, int j, int k) { return 0; }
 		public ulong DigitalInputs { get { return 0; } }
 		public float AnalogInput(int adcNr0) { return 0; }

TBF/BenchControl/Elde/ControlComWrap.cs

@@ -18,6 +18,7 @@ namespace TBF.BenchControl.Elde
         /// Properties
         ///
 		public StatusP StatusP { get { return (StatusP)ctrlBrdComponent.StatusP; } }
+
 #if DN100 || MUNICH || FUZHOU150
         public float ReferenceFreq { get { return 1000.0f * ctrlBrdComponent.referenceFreq; } }     /// In [Hz] 0..2500, nom.=2000
 #else /// all newer benches
@@ -31,12 +32,15 @@ namespace TBF.BenchControl.Elde
         /// </summary>
         public float ReferenceFreq { get { return 1000.0f * ctrlBrdComponent.referenceFreq[0]; } }  /// In [Hz] 0..2500, nom.=2000
 #endif
+
 		public int EtPulses(int wmNr1) { return (int)ctrlBrdComponent.etPulses[wmNr1]; }
-#if GENESIS || BERLIN || SLM_150 || PETERSBURG_50 || PETERSBURG_200 || KEMPNO_50 || BAHRAIN_50 || RUM_MOB || KRAKOW_50 || JUZNA_AFRIKA_50
+
+#if GENESIS || BERLIN || SLM_150 || PETERSBURG_50 || PETERSBURG_200 || KEMPNO_50 || BAHRAIN_50 || RUM_MOB || KRAKOW_50 || JUZNA_AFRIKA_50 || ZAMBIA || SENTEC
         public int EtPulsesK { get { return (int)ctrlBrdComponent.etPulsesK; }  }
 #else
         public int EtPulsesK { get { return 1; }  }
 #endif
+
         public UInt16 WMeterPulses(int wmNr1) { return (UInt16)ctrlBrdComponent.wMeterPuls[wmNr1]; }
 		public int WMeterReference(int wmNr0) { return (int)ctrlBrdComponent.wMeterReference[wmNr0]; }
 		public uint RegulValveDAC { get { return ctrlBrdComponent.StavDA; } }
@@ -49,7 +53,7 @@ namespace TBF.BenchControl.Elde
         public UInt128 RRoute { get { return ctrlBrdComponent.rRoute; } }
 #endif
 
-#if GENESIS || KEMPNO_50 || KRAKOW_50 || BAHRAIN_50 || BADGER_STREDNA_TRAT || JUZNA_AFRIKA_50
+#if GENESIS || KEMPNO_50 || KRAKOW_50 || BAHRAIN_50 || BADGER_STREDNA_TRAT || JUZNA_AFRIKA_50 || ZAMBIA || SENTEC
         public uint DivTime(int id) { return ctrlBrdComponent.divTime[id]; }
         public void SetDivLimit(int divNo, uint limLoPct, uint limHiPct)
         {
@@ -80,7 +84,7 @@ namespace TBF.BenchControl.Elde
             //return ctrlBrdComponent.RValvePosition[rvNr1 - 1];
             return ctrlBrdComponent.Analogy[rvNr1 - 1];             /// Fixes bug: RValvePosition returns 0 all the time
         }
-		public float DivSamples(int ms) { return ctrlBrdComponent.DIVSamples[ms, 0]; }
+        public float DivSamples(int time, int divIx0) { return ctrlBrdComponent.DIVSamples[time, divIx0]; } /// Time unit is 2 ms
 		public int ScopeSamples(int i, int j, int k) { return ctrlBrdComponent.ScopeSamples[i, j, k]; }
 		public ulong DigitalInputs { get { return (ulong)ctrlBrdComponent.Vstupy; } }
 		public float AnalogInput(int adcNr0) { return ctrlBrdComponent.Analogy[adcNr0]; }
@@ -102,7 +106,7 @@ namespace TBF.BenchControl.Elde
 		public uint[] WMeterCont { get { return new uint[3]; } }				/// Dummy
 #endif
 
-#if KEMPNO_50 || KRAKOW_50 || JUZNA_AFRIKA_50
+#if KEMPNO_50 || KRAKOW_50 || JUZNA_AFRIKA_50 || ZAMBIA
 		public float ValveOpenCloseTime { get { return ctrlBrdComponent.ValveMoveTime[0]; } }
 #else
         public float ValveOpenCloseTime { get { return 0.001f; } }
@@ -223,12 +227,14 @@ namespace TBF.BenchControl.Elde
 			for (int i = 0; i < divEdge.Length; i++) log.FatalFormat("   divEdge[{0}] = {1}", i, divEdge[i]);
 			for (int i = 0; i < balanceRange.Length; i++) log.FatalFormat("   balanceRange[{0}] = {1}", i, balanceRange[i]);
 
-//#if (DN100)
             ctrlBrdComponent.ExternalCom = true;
-//#endif
-            ctrlBrdComponent.SendCalibData(rvCalib, meretA, (byte)usedCom, tempCalib, etCalib, divEdge, balanceRange);
-		}
 
+#if SENTEC
+            ctrlBrdComponent.SendCalibData(rvCalib, meretA, (byte)usedCom, tempCalib, etCalib, divEdge, balanceRange, (byte)123);
+#else
+            ctrlBrdComponent.SendCalibData(rvCalib, meretA, (byte)usedCom, tempCalib, etCalib, divEdge, balanceRange);
+#endif
+		}
 
 		/// <summary>
 		/// Control of regulating valves.
@@ -257,17 +263,12 @@ namespace TBF.BenchControl.Elde
         ///
         private void DoValveMove(int valveNo, RegulValveMode valveMode, float[] valveValue, int stableTime)
 		{
-            //TBF.UiBridge.Bridge.OnLog(this, string.Format("{0} ValveMove({1}, {2}, [{3}, {4}])\r\n",
-            //                                              DateTime.Now.ToLongTimeString(),
-            //                                              valveNo,
-            //                                              valveMode,
-            //                                              valveValue[0],
-            //                                              valveValue[1]));
-            log.InfoFormat("ValveMove(#={0}, md={1}, [{2}, {3}])", valveNo, valveMode, valveValue[0], valveValue[1]);
 #if DN100 || MUNICH || FUZHOU150
+            log.InfoFormat("ValveMove(#={0}, md={1}, [{2}, {3}])", valveNo, valveMode, valveValue[0], valveValue[1]);
             ctrlBrdComponent.ValveMove((byte)valveNo, (byte)valveMode, valveValue);
 #else /// all newer benches
-			ctrlBrdComponent.ValveMove((byte)valveNo, (byte)valveMode, valveValue, stableTime);
+            log.InfoFormat("ValveMove(#={0}, md={1}, [{2}, {3}], {4})", valveNo, valveMode, valveValue[0], valveValue[1], stableTime);
+            ctrlBrdComponent.ValveMove((byte)valveNo, (byte)valveMode, valveValue, stableTime);
 #endif
 		}
 
@@ -371,7 +372,7 @@ namespace TBF.BenchControl.Elde
             uint[] pulsesArr = new uint[] { (uint)totalRefPulses, (uint)massRefPulses };
             ctrlBrdComponent.SendCommand((uint)cmd, (byte)refFlowMeterNr, (ulong)(route & (UInt128)0xFFFFFFFFFFFFFFFF), (ulong)(route >> 64), pulsesArr, (uint)testMethods,
                                          Convert.ToSingle(filterConstants[0]), fmFreq, (uint)regConst, (uint)shortImp, (uint)stopDevs);
-#elif JUZNA_AFRIKA_50
+#elif JUZNA_AFRIKA_50 || ZAMBIA || SENTEC
             uint[] pulsesArr = new uint[] { (uint)totalRefPulses, (uint)massRefPulses };
             ctrlBrdComponent.SendCommand((uint)cmd, (byte)refFlowMeterNr, (ulong)route, pulsesArr, (uint)testMethods,
                                          filterConstants, fmFreq, (uint)regConst, (uint)shortImp, (uint)stopDevs);

TBF/BenchControl/Elde/CoverTest/CoverTestCfg.cs

@@ -12,7 +12,7 @@ namespace TBF.BenchControl.Elde.CoverTest
     public class CoverTestCfg : ComponentCfgBase, IChildComponentCfg
 	{
 		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(CoverTestCfg) })[0];
-		protected override XmlSerializer GetSerializer() { return Serializer; }
+		public override XmlSerializer GetSerializer() { return Serializer; }
 
 		public IComponentCfgCtrl GetControl() { return new CoverTestCfgCtrl(); }