From e878bcd4dbc2577ed75e54e52d30dc56f97e7965 Mon Sep 17 00:00:00 2001
From: Samuele Locatelli <samuele@steamware.net>
Date: Tue, 14 Jun 2022 19:31:53 +0200
Subject: [PATCH] Ancora update x adapter OPC UA

---
 MP.MONO.ADAPTER.OLD.sln                       |   31 +
 .../MP.MONO.ADAPTER.OLD.csproj                |    2 +-
 MP.MONO.ADAPTER.OLD/Resources/ChangeLog.html  |    2 +-
 MP.MONO.ADAPTER.OLD/Resources/VersNum.txt     |    2 +-
 MP.MONO.ADAPTER.OLD/Resources/manifest.xml    |    2 +-
 MP.MONO.ADAPTER.OLD/UAClient.cs               |  298 ++--
 MP.MONO.ADAPTER.OPC.sln                       |    6 +-
 .../MpMonoAdapterClient.Config.xml}           |    0
 MP.MONO.ADAPTER.OPC/CONF/Multiax.json         |  204 +++
 MP.MONO.ADAPTER.OPC/IobGeneric.cs             |  722 +++++++++
 MP.MONO.ADAPTER.OPC/IobOpcUa.cs               | 1360 +++++++++++++++++
 .../MP.MONO.ADAPTER.OPC.csproj                |   25 +-
 MP.MONO.ADAPTER.OPC/OpcUaDataItemExt.cs       |   78 +
 MP.MONO.ADAPTER.OPC/Program.cs                |  317 +++-
 MP.MONO.ADAPTER.OPC/UAClient.cs               |  925 ++++++++---
 .../UAClient.old.cs                           |  375 +++--
 MP.MONO.ADAPTER.OPC/appsettings.json          |   49 +
 .../MP - Backup.MONO.ADAPTER.OPC.csproj       |   45 -
 .../MP.MONO.ADAPTER.OPC.Config.xml            |   89 --
 .../MP.MONO.ADAPTER.OPC.csproj                |   45 -
 MP.MONO.ADAPTER.OPC2/Program.cs               |  186 ---
 MP.MONO.ADAPTER.OPC2/dotnettrace.cmd          |    3 -
 MP.MONO.ADAPTER.OPC2/targets.props            |   44 -
 MP.MONO.ALL.sln                               |   14 +
 MP.MONO.ANALYZER/MP.MONO.ANALYZER.csproj      |    2 +-
 MP.MONO.ANALYZER/Resources/ChangeLog.html     |    2 +-
 MP.MONO.ANALYZER/Resources/VersNum.txt        |    2 +-
 MP.MONO.ANALYZER/Resources/manifest.xml       |    2 +-
 MP.MONO.Core/CONF/MachDataItem.cs             |   51 +
 MP.MONO.Core/Enums.cs                         |   10 +
 MP.MONO.DECODER/MP.MONO.DECODER.csproj        |    2 +-
 MP.MONO.DECODER/Resources/ChangeLog.html      |    2 +-
 MP.MONO.DECODER/Resources/VersNum.txt         |    2 +-
 MP.MONO.DECODER/Resources/manifest.xml        |    2 +-
 MP.MONO.SIM/MP.MONO.SIM.csproj                |    2 +-
 MP.MONO.SIM/Resources/ChangeLog.html          |    2 +-
 MP.MONO.SIM/Resources/VersNum.txt             |    2 +-
 MP.MONO.SIM/Resources/manifest.xml            |    2 +-
 MP.MONO.UI/MP.MONO.UI.csproj                  |    2 +-
 MP.MONO.UI/Resources/ChangeLog.html           |    2 +-
 MP.MONO.UI/Resources/VersNum.txt              |    2 +-
 MP.MONO.UI/Resources/manifest.xml             |    2 +-
 42 files changed, 3857 insertions(+), 1060 deletions(-)
 create mode 100644 MP.MONO.ADAPTER.OLD.sln
 rename MP.MONO.ADAPTER.OPC/{Quickstarts.ReferenceClient.Config.xml => CONF/MpMonoAdapterClient.Config.xml} (100%)
 create mode 100644 MP.MONO.ADAPTER.OPC/CONF/Multiax.json
 create mode 100644 MP.MONO.ADAPTER.OPC/IobGeneric.cs
 create mode 100644 MP.MONO.ADAPTER.OPC/IobOpcUa.cs
 create mode 100644 MP.MONO.ADAPTER.OPC/OpcUaDataItemExt.cs
 rename MP.MONO.ADAPTER.OPC2/UAClient.cs => MP.MONO.ADAPTER.OPC/UAClient.old.cs (93%)
 create mode 100644 MP.MONO.ADAPTER.OPC/appsettings.json
 delete mode 100644 MP.MONO.ADAPTER.OPC2/MP - Backup.MONO.ADAPTER.OPC.csproj
 delete mode 100644 MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.Config.xml
 delete mode 100644 MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.csproj
 delete mode 100644 MP.MONO.ADAPTER.OPC2/Program.cs
 delete mode 100644 MP.MONO.ADAPTER.OPC2/dotnettrace.cmd
 delete mode 100644 MP.MONO.ADAPTER.OPC2/targets.props
 create mode 100644 MP.MONO.Core/CONF/MachDataItem.cs

diff --git a/MP.MONO.ADAPTER.OLD.sln b/MP.MONO.ADAPTER.OLD.sln
new file mode 100644
index 0000000..9118d22
--- /dev/null
+++ b/MP.MONO.ADAPTER.OLD.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.2.32519.379
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MP.MONO.ADAPTER.OPC", "MP.MONO.ADAPTER.OPC\MP.MONO.ADAPTER.OPC.csproj", "{458FD824-7804-4CF9-8C43-463C1F5659DA}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MP.MONO.ADAPTER.OLD", "MP.MONO.ADAPTER.OLD\MP.MONO.ADAPTER.OLD.csproj", "{84F0ABFE-ADD6-426D-BD9B-E4E9086EE169}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{458FD824-7804-4CF9-8C43-463C1F5659DA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{458FD824-7804-4CF9-8C43-463C1F5659DA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{458FD824-7804-4CF9-8C43-463C1F5659DA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{458FD824-7804-4CF9-8C43-463C1F5659DA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{84F0ABFE-ADD6-426D-BD9B-E4E9086EE169}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{84F0ABFE-ADD6-426D-BD9B-E4E9086EE169}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{84F0ABFE-ADD6-426D-BD9B-E4E9086EE169}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{84F0ABFE-ADD6-426D-BD9B-E4E9086EE169}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3811E8B4-1DD3-4841-9840-1B1A08782CD3}
+	EndGlobalSection
+EndGlobal
diff --git a/MP.MONO.ADAPTER.OLD/MP.MONO.ADAPTER.OLD.csproj b/MP.MONO.ADAPTER.OLD/MP.MONO.ADAPTER.OLD.csproj
index 3531e0d..148f2b8 100644
--- a/MP.MONO.ADAPTER.OLD/MP.MONO.ADAPTER.OLD.csproj
+++ b/MP.MONO.ADAPTER.OLD/MP.MONO.ADAPTER.OLD.csproj
@@ -5,7 +5,7 @@
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <Version>1.12206.1410</Version>
+    <Version>1.12206.1416</Version>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/MP.MONO.ADAPTER.OLD/Resources/ChangeLog.html b/MP.MONO.ADAPTER.OLD/Resources/ChangeLog.html
index ecdcea3..b2b32cf 100644
--- a/MP.MONO.ADAPTER.OLD/Resources/ChangeLog.html
+++ b/MP.MONO.ADAPTER.OLD/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>MAPO-MONO</i>
-    <h4>Version: 1.12206.1410</h4>
+    <h4>Version: 1.12206.1416</h4>
     <br /> Release Note:
     <ul>
         <li>
diff --git a/MP.MONO.ADAPTER.OLD/Resources/VersNum.txt b/MP.MONO.ADAPTER.OLD/Resources/VersNum.txt
index 3720595..d360aeb 100644
--- a/MP.MONO.ADAPTER.OLD/Resources/VersNum.txt
+++ b/MP.MONO.ADAPTER.OLD/Resources/VersNum.txt
@@ -1 +1 @@
-1.12206.1410
+1.12206.1416
diff --git a/MP.MONO.ADAPTER.OLD/Resources/manifest.xml b/MP.MONO.ADAPTER.OLD/Resources/manifest.xml
index 23bb8cd..81a6875 100644
--- a/MP.MONO.ADAPTER.OLD/Resources/manifest.xml
+++ b/MP.MONO.ADAPTER.OLD/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.12206.1410</version>
+  <version>1.12206.1416</version>
   <url>http://nexus.steamware.net/repository/SWS/MP.MONO.ADAPTER/stable/LAST/MP.Mon.zip</url>
   <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.ADAPTER/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>
diff --git a/MP.MONO.ADAPTER.OLD/UAClient.cs b/MP.MONO.ADAPTER.OLD/UAClient.cs
index cd8fb8e..b7c76b5 100644
--- a/MP.MONO.ADAPTER.OLD/UAClient.cs
+++ b/MP.MONO.ADAPTER.OLD/UAClient.cs
@@ -1,12 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Collections;
+using NLog;
 using Opc.Ua;
 using Opc.Ua.Client;
-using NLog;
+using System.Collections;
 
 namespace MP.MONO.ADAPTER
 {
@@ -15,20 +10,6 @@ namespace MP.MONO.ADAPTER
     /// </summary>
     public class opcUaMonitItemChange : EventArgs
     {
-        #region Private Fields
-
-        /// <summary>
-        /// Monitored Item da notificare
-        /// </summary>
-        private readonly MonitoredItem _monitoredItem;
-
-        /// <summary>
-        /// Valore notifica
-        /// </summary>
-        private readonly MonitoredItemNotification _notification;
-
-        #endregion Private Fields
-
         #region Public Constructors
 
         /// <summary>
@@ -62,34 +43,27 @@ namespace MP.MONO.ADAPTER
         }
 
         #endregion Public Properties
+
+        #region Private Fields
+
+        /// <summary>
+        /// Monitored Item da notificare
+        /// </summary>
+        private readonly MonitoredItem _monitoredItem;
+
+        /// <summary>
+        /// Valore notifica
+        /// </summary>
+        private readonly MonitoredItemNotification _notification;
+
+        #endregion Private Fields
     }
+
     /// <summary>
     /// OPC UA Client with examples of basic functionality.
     /// </summary>
     public class UAClient
     {
-        #region Private Fields
-
-        private readonly string currIob;
-        private readonly Action<IList, IList> m_validateResponse;
-        private ApplicationConfiguration m_configuration;
-        private Session m_session;
-
-        #endregion Private Fields
-
-        #region Protected Fields
-
-        protected static Logger lg;
-        protected static bool isLogVerbose = false;
-
-
-        /// <summary>
-        /// The user identity to use when creating the session.
-        /// </summary>
-        public IUserIdentity CurrUserIdentity { get; set; } = new UserIdentity();
-
-        #endregion Protected Fields
-
         #region Public Constructors
 
         /// <summary>
@@ -126,6 +100,11 @@ namespace MP.MONO.ADAPTER
 
         #region Public Properties
 
+        /// <summary>
+        /// The user identity to use when creating the session.
+        /// </summary>
+        public IUserIdentity CurrUserIdentity { get; set; } = new UserIdentity();
+
         /// <summary>
         /// Gets or sets the server URL.
         /// </summary>
@@ -138,105 +117,6 @@ namespace MP.MONO.ADAPTER
 
         #endregion Public Properties
 
-        #region Private Methods
-
-        /// <summary>
-        /// Handles the certificate validation event.
-        /// This event is triggered every time an untrusted certificate is received from the server.
-        /// </summary>
-        private void CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
-        {
-            bool certificateAccepted = true;
-
-            // ****
-            // Implement a custom logic to decide if the certificate should be
-            // accepted or not and set certificateAccepted flag accordingly.
-            // The certificate can be retrieved from the e.Certificate field
-            // ***
-
-            ServiceResult error = e.Error;
-            while (error != null)
-            {
-                lgError($"{error.StatusCode} | {error.Code} | {error.LocalizedText}");
-                error = error.InnerResult;
-            }
-
-            if (certificateAccepted)
-            {
-                lgInfo($"Untrusted Certificate accepted. SubjectName = {e.Certificate.SubjectName}");
-            }
-
-            e.AcceptAll = certificateAccepted;
-        }
-
-        /// <summary>
-        /// Handle DataChange notifications from Server
-        /// </summary>
-        private void OnMonitoredItemNotification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
-        {
-            try
-            {
-                // Log MonitoredItem Notification event
-                MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
-
-                // sollevo evento notifica vaziazione MonitoredItem
-                if (eh_MonItChange != null)
-                {
-                    eh_MonItChange(this, new opcUaMonitItemChange(monitoredItem, notification));
-                }
-                lgTrace($"Notification Received | Variable: {monitoredItem.DisplayName} | Value: {notification.Value}");
-            }
-            catch (Exception ex)
-            {
-                lgError($"OnMonitoredItemNotification error: {ex.Message}");
-            }
-        }
-
-        #endregion Private Methods
-
-        #region Protected Methods
-
-        /// <summary>
-        /// Effettua logging ERROR corretto impostanto anche la variabile IOB prima di scrivere...
-        /// </summary>
-        /// <param name="message"></param>
-        protected void lgError(string message)
-        {
-            lg.Factory.Configuration.Variables["codIOB"] = currIob;
-            lg.Error(message);
-        }
-
-        /// <summary>
-        /// Effettua logging INFO corretto impostanto anche la variabile IOB prima di scrivere...
-        /// </summary>
-        /// <param name="message"></param>
-        protected void lgInfo(string message)
-        {
-            lg.Factory.Configuration.Variables["codIOB"] = currIob;
-            lg.Info(message);
-        }
-
-        /// <summary>
-        /// Effettua logging DEBUG corretto impostanto anche la variabile IOB prima di scrivere...
-        /// </summary>
-        /// <param name="message"></param>
-        protected void lgDebug(string message)
-        {
-            lg.Factory.Configuration.Variables["codIOB"] = currIob;
-            lg.Info(message);
-        }
-        /// <summary>
-        /// Effettua logging TRACE corretto impostanto anche la variabile IOB prima di scrivere...
-        /// </summary>
-        /// <param name="message"></param>
-        protected void lgTrace(string message)
-        {
-            lg.Factory.Configuration.Variables["codIOB"] = currIob;
-            lg.Trace(message);
-        }
-
-        #endregion Protected Methods
-
         #region Public Methods
 
         /// <summary>
@@ -384,14 +264,11 @@ namespace MP.MONO.ADAPTER
 
             try
             {
-                // Define the UA Method to call
-                // Parent node - Objects\CTT\Methods
-                // Method node - Objects\CTT\Methods\Add
+                // Define the UA Method to call Parent node - Objects\CTT\Methods Method node - Objects\CTT\Methods\Add
                 NodeId objectId = new NodeId("ns=2;s=Methods");
                 NodeId methodId = new NodeId("ns=2;s=Methods_Add");
 
-                // Define the method parameters
-                // Input argument requires a Float and an UInt32 value
+                // Define the method parameters Input argument requires a Float and an UInt32 value
                 object[] inputArguments = new object[] { (float)10.5, (uint)10 };
                 IList<object> outputArguments = null;
 
@@ -428,8 +305,8 @@ namespace MP.MONO.ADAPTER
                 {
                     lgInfo("Connecting...");
 
-                    // Get the endpoint by connecting to server's discovery endpoint.
-                    // Try to find the first endopint without security.
+                    // Get the endpoint by connecting to server's discovery endpoint. Try to find
+                    // the first endopint without security.
                     EndpointDescription endpointDescription = CoreClientUtils.SelectEndpoint(ServerUrl, false);
 
                     EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_configuration);
@@ -572,7 +449,6 @@ namespace MP.MONO.ADAPTER
             return answ;
         }
 
-
         /// <summary>
         /// Read a SINGLE of nodes value (RAW) from Server
         /// </summary>
@@ -589,7 +465,6 @@ namespace MP.MONO.ADAPTER
 
             try
             {
-
                 #region Read the Value attribute of a node by calling the Session.ReadValue method
 
                 try
@@ -613,8 +488,6 @@ namespace MP.MONO.ADAPTER
             return answ;
         }
 
-
-
         /// <summary>
         /// Read a list of nodes from Server
         /// </summary>
@@ -812,8 +685,7 @@ namespace MP.MONO.ADAPTER
             return monItList;
         }
 
-        /// Write a list of nodes to the Server
-        /// </summary>
+        /// Write a list of nodes to the Server </summary>
         public void WriteNodes(List<WriteValue> node2Write)
         {
             if (m_session == null || m_session.Connected == false)
@@ -1001,5 +873,119 @@ namespace MP.MONO.ADAPTER
         }
 
         #endregion Public Methods
+
+        #region Protected Fields
+
+        protected static bool isLogVerbose = false;
+        protected static Logger lg;
+
+        #endregion Protected Fields
+
+        #region Protected Methods
+
+        /// <summary>
+        /// Effettua logging DEBUG corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgDebug(string message)
+        {
+            lg.Factory.Configuration.Variables["codIOB"] = currIob;
+            lg.Info(message);
+        }
+
+        /// <summary>
+        /// Effettua logging ERROR corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgError(string message)
+        {
+            lg.Factory.Configuration.Variables["codIOB"] = currIob;
+            lg.Error(message);
+        }
+
+        /// <summary>
+        /// Effettua logging INFO corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgInfo(string message)
+        {
+            lg.Factory.Configuration.Variables["codIOB"] = currIob;
+            lg.Info(message);
+        }
+
+        /// <summary>
+        /// Effettua logging TRACE corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgTrace(string message)
+        {
+            lg.Factory.Configuration.Variables["codIOB"] = currIob;
+            lg.Trace(message);
+        }
+
+        #endregion Protected Methods
+
+        #region Private Fields
+
+        private readonly string currIob;
+        private readonly Action<IList, IList> m_validateResponse;
+        private ApplicationConfiguration m_configuration;
+        private Session m_session;
+
+        #endregion Private Fields
+
+        #region Private Methods
+
+        /// <summary>
+        /// Handles the certificate validation event. This event is triggered every time an
+        /// untrusted certificate is received from the server.
+        /// </summary>
+        private void CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
+        {
+            bool certificateAccepted = true;
+
+            // **** Implement a custom logic to decide if the certificate should be accepted or not
+            // and set certificateAccepted flag accordingly. The certificate can be retrieved from
+            // the e.Certificate field ***
+
+            ServiceResult error = e.Error;
+            while (error != null)
+            {
+                lgError($"{error.StatusCode} | {error.Code} | {error.LocalizedText}");
+                error = error.InnerResult;
+            }
+
+            if (certificateAccepted)
+            {
+                lgInfo($"Untrusted Certificate accepted. SubjectName = {e.Certificate.SubjectName}");
+            }
+
+            e.AcceptAll = certificateAccepted;
+        }
+
+        /// <summary>
+        /// Handle DataChange notifications from Server
+        /// </summary>
+        private void OnMonitoredItemNotification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
+        {
+            try
+            {
+                // Log MonitoredItem Notification event
+                MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
+
+                // sollevo evento notifica vaziazione MonitoredItem
+                if (eh_MonItChange != null)
+                {
+                    eh_MonItChange(this, new opcUaMonitItemChange(monitoredItem, notification));
+                }
+                lgTrace($"Notification Received | Variable: {monitoredItem.DisplayName} | Value: {notification.Value}");
+            }
+            catch (Exception ex)
+            {
+                lgError($"OnMonitoredItemNotification error: {ex.Message}");
+            }
+        }
+
+        #endregion Private Methods
     }
-}
+}
\ No newline at end of file
diff --git a/MP.MONO.ADAPTER.OPC.sln b/MP.MONO.ADAPTER.OPC.sln
index f328032..2ca434f 100644
--- a/MP.MONO.ADAPTER.OPC.sln
+++ b/MP.MONO.ADAPTER.OPC.sln
@@ -1,9 +1,9 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.32510.428
+# Visual Studio Version 17
+VisualStudioVersion = 17.2.32519.379
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MP.MONO.ADAPTER.OPC", "MP.MONO.ADAPTER.OPC\MP.MONO.ADAPTER.OPC.csproj", "{458FD824-7804-4CF9-8C43-463C1F5659DA}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MP.MONO.ADAPTER.OPC", "MP.MONO.ADAPTER.OPC\MP.MONO.ADAPTER.OPC.csproj", "{458FD824-7804-4CF9-8C43-463C1F5659DA}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/MP.MONO.ADAPTER.OPC/Quickstarts.ReferenceClient.Config.xml b/MP.MONO.ADAPTER.OPC/CONF/MpMonoAdapterClient.Config.xml
similarity index 100%
rename from MP.MONO.ADAPTER.OPC/Quickstarts.ReferenceClient.Config.xml
rename to MP.MONO.ADAPTER.OPC/CONF/MpMonoAdapterClient.Config.xml
diff --git a/MP.MONO.ADAPTER.OPC/CONF/Multiax.json b/MP.MONO.ADAPTER.OPC/CONF/Multiax.json
new file mode 100644
index 0000000..f9f4ad9
--- /dev/null
+++ b/MP.MONO.ADAPTER.OPC/CONF/Multiax.json
@@ -0,0 +1,204 @@
+{
+  "BrowseFullVal": "ns=1;s=OSAI-PLC",
+  "BrowseNSIndex": 1,
+  "BrowseValue": 0,
+  "keyPartCount": "1:507_2_WORKPIECE QTY",
+  "keyPartReq": "",
+  "keyPartId": "",
+  "keyProgName": "1:502_1_RECIPE NAME",
+  "keyRunMode": "",
+  "pingAsPowerOn": true,
+  //"Identity": {
+  //  "UserName": "CUSTOMER",
+  //  "Passwd": "BLM"
+  //},
+  "condWork": [
+    {
+      "keyName": "1:1_1_MACHINE STATUS",
+      "targetValue": "ON"
+    }
+  ],
+  "condWorkOpc": {
+    "checkMode": "AND",
+    "checkList": [
+      {
+        "keyName": "MachineStatus(0)",
+        "targetValue": "4"
+      }
+    ]
+  },
+  "condPowerOn": {
+    "checkMode": "OR",
+    "negateValue": true,
+    "checkList": [
+      {
+        "keyName": "1:1_1_MACHINE STATUS",
+        "targetValue": "ON"
+      },
+      {
+        "keyName": "1:500_1_STATUS",
+        "targetValue": "CYCLE"
+      },
+      {
+        "keyName": "1:501_1_MODE",
+        "targetValue": "AUTO"
+      }
+    ]
+  },
+  "condReady": {
+    "checkMode": "OR",
+    "checkList": [
+      //{
+      //  "keyName": "MachineStatus(0)",
+      //  "targetValue": "3"
+      //},
+      //{
+      //  "keyName": "MachineStatus(0)",
+      //  "targetValue": "5"
+      //}
+    ]
+  },
+  "condManual": {
+    "checkMode": "AND",
+    "checkList": [
+      //{
+      //  "keyName": "MachineStatus(0)",
+      //  "targetValue": "8"
+      //}
+    ]
+  },
+  "condEStop": {
+    "checkMode": "AND",
+    "checkList": [
+      //{
+      //  "keyName": "EmergencyState",
+      //  "targetValue": "0"
+      //}
+    ]
+  },
+  "condError": {
+    "checkMode": "AND",
+    "checkList": [
+      //{
+      //  "keyName": "MachineStatus(0)",
+      //  "targetValue": "6"
+      //}
+    ]
+  },
+  "condCountEnabled": {
+    "checkMode": "AND",
+    "checkList": []
+  },
+  "condWarmUpCoolDown": {
+    "checkMode": "OR",
+    "negateValue": true,
+    "checkList": []
+  },
+  "condWarning": {
+    "checkMode": "AND",
+    "checkList": [
+      //{
+      //  "keyName": "MachineStatus(0)",
+      //  "targetValue": "9"
+      //}
+    ]
+  },
+  "condSetup": {
+    "checkMode": "AND",
+    "checkList": [
+      //{
+      //  "keyName": "MachineStatus(0)",
+      //  "targetValue": "7"
+      //}
+    ]
+  },
+  "fluxLogVeto": [],
+  "itemTranslation": {
+    "avail": "Machine Available",
+    "rstat": "Execution Mode",
+    "mode": "Controller Mode",
+    "PartName(0)": "Program Name",
+    "PartDone(0)": "Pezzi Prodotti",
+    "PartToDo(0)": "Qta Richiesta",
+    "MachineStatus(0)": "Stato Macchina principale",
+    "MachineStatus(1)": "Stato Macchina secondario",
+    "EmergencyState": "Emergenza",
+    "fdovrd": "PATH FEED OVERRIDE",
+    "rovrd": "PATH RAPID OVERRIDE"
+  },
+  "subscribedItems": [
+    "ns=1;s=1_1_MACHINE STATUS",
+    "ns=1;s=1_2_MACHINE COUNTER OFF",
+    "ns=1;s=2_1_AXES STATUS",
+    "ns=1;s=2_2_AXES COUNTER OFF",
+    "ns=1;s=3_1_ALARM NC",
+    "ns=1;s=3_2_ALARM PLC 1",
+    "ns=1;s=3_3_ALARM PLC 2",
+    "ns=1;s=3_4_ALARM PLC 3",
+    "ns=1;s=3_5_ALARM PLC 4",
+    "ns=1;s=3_6_ALARM PLC 5",
+    "ns=1;s=3_7_ALARM PLC 6",
+    "ns=1;s=3_8_ALARM PLC 7",
+    "ns=1;s=3_9_ALARM PLC 8",
+    "ns=1;s=3_10_ALARM PLC 9",
+    "ns=1;s=3_11_ALARM PLC 10",
+    "ns=1;s=4_1_TOOL 1 CURRENT LIFE PC",
+    "ns=1;s=4_2_TOOL 2 CURRENT LIFE PC",
+    "ns=1;s=4_3_TOOL 3 CURRENT LIFE PC",
+    "ns=1;s=4_4_TOOL 4 CURRENT LIFE PC",
+    "ns=1;s=4_5_TOOL 11 CURRENT LIFE PC",
+    "ns=1;s=4_6_TOOL 12 CURRENT LIFE PC",
+    "ns=1;s=4_7_TOOL 13 CURRENT LIFE PC",
+    "ns=1;s=4_8_TOOL 14 CURRENT LIFE PC",
+    "ns=1;s=4_9_TOOL 21 CURRENT LIFE PC",
+    "ns=1;s=4_10_TOOL 22 CURRENT LIFE PC",
+    "ns=1;s=4_11_TOOL 23 CURRENT LIFE PC",
+    "ns=1;s=4_12_TOOL 24 CURRENT LIFE PC",
+    "ns=1;s=4_13_TOOL 31 CURRENT LIFE PC",
+    "ns=1;s=4_14_TOOL 32 CURRENT LIFE PC",
+    "ns=1;s=4_15_TOOL 33 CURRENT LIFE PC",
+    "ns=1;s=4_16_TOOL 34 CURRENT LIFE PC",
+    "ns=1;s=500_1_STATUS",
+    "ns=1;s=500_2_COUNTER CYCLE",
+    "ns=1;s=500_3_COUNTER HOLDA",
+    "ns=1;s=500_4_COUNTER ERROR",
+    "ns=1;s=500_5_COUNTER PAUSE",
+    "ns=1;s=501_1_MODE",
+    "ns=1;s=502_1_RECIPE NAME",
+    "ns=1;s=502_2_PROGRESS BAR",
+    "ns=1;s=25_AXIS 1 LOAD PC",
+    "ns=1;s=26_AXIS 2 LOAD PC",
+    "ns=1;s=27_AXIS 3 LOAD PC",
+    "ns=1;s=28_AXIS 4 LOAD PC",
+    "ns=1;s=29_AXIS 5 LOAD PC",
+    "ns=1;s=30_AXIS 6 LOAD PC",
+    "ns=1;s=31_AXIS 7 LOAD PC",
+    "ns=1;s=32_AXIS 8 LOAD PC",
+    "ns=1;s=33_AXIS 9 LOAD PC",
+    "ns=1;s=34_AXIS 10 LOAD PC",
+    "ns=1;s=35_AXIS 11 LOAD PC",
+    "ns=1;s=36_AXIS 12 LOAD PC",
+    "ns=1;s=37_AXIS 13 LOAD PC",
+    "ns=1;s=38_AXIS 14 LOAD PC",
+    "ns=1;s=39_AXIS 15 LOAD PC",
+    "ns=1;s=45_P2 AXIS V SW OVT UPPER",
+    "ns=1;s=46_P2 AXIS V SW OVT LOWER",
+    "ns=1;s=47_P2 AXIS V ACTUAL POSITION",
+    "ns=1;s=48_P3 AXIS W SW OVT UPPER",
+    "ns=1;s=49_P3 AXIS W SW OVT LOWER",
+    "ns=1;s=50_P3 AXIS W ACTUAL POSITION",
+    "ns=1;s=504_PROC 1 P.P. ORDER",
+    "ns=1;s=505_PROC 1 P.P. PROCESSING",
+    "ns=1;s=506_PROC 1 P.P. PROCESSING PHASE",
+    "ns=1;s=510_PROC 1 FEED OVERRIDE",
+    "ns=1;s=511_PROC 1 FEED PROGRAMMED",
+    "ns=1;s=512_PROC 1 FEED ACTUAL",
+    "ns=1;s=513_PROC 1 SPEED OVERRIDE",
+    "ns=1;s=514_PROC 1 SPEED PROGRAMMED",
+    "ns=1;s=515_PROC 1 SPEED ACTUAL",
+    "ns=1;s=516_PROC 1 SPINDLE 1 LOAD PC",
+    "ns=1;s=517_PROC 1 SPINDLE 2 LOAD PC",
+    "ns=1;s=518_PROC 1 SPINDLE 3 LOAD PC",
+    "ns=1;s=519_PROC 1 SPINDLE 4 LOAD PC"
+  ]
+}
\ No newline at end of file
diff --git a/MP.MONO.ADAPTER.OPC/IobGeneric.cs b/MP.MONO.ADAPTER.OPC/IobGeneric.cs
new file mode 100644
index 0000000..a3b85d9
--- /dev/null
+++ b/MP.MONO.ADAPTER.OPC/IobGeneric.cs
@@ -0,0 +1,722 @@
+using Microsoft.Extensions.Configuration;
+using MP.MONO.Core;
+using MP.MONO.Core.CONF;
+using Newtonsoft.Json;
+using NLog;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.NetworkInformation;
+using static MP.MONO.Core.CONF.OpcUaParamConf;
+using static MP.MONO.Core.Enums;
+
+namespace MP.MONO.ADAPTER.OPC
+{
+    public class IobGeneric
+    {
+        #region Public Fields
+
+        /// <summary>
+        /// valore booleano di check se sia stato AVVIATO l'adapter (Running)
+        /// </summary>
+        internal bool adpRunning = false;
+
+        /// <summary>
+        /// Data/ora ultimo avvio adapter
+        /// </summary>
+        internal DateTime dtAvvioAdp = DateTime.Now;
+
+        /// <summary>
+        /// Data/ora ultimo spegnimento adapter
+        /// </summary>
+        internal DateTime dtStopAdp = DateTime.Now;
+
+        /// <summary>
+        /// dataOra ultimo log periodico...
+        /// </summary>
+        internal DateTime lastPeriodicLog;
+
+        /// <summary>
+        /// dataOra ultimo PING inviato verso il PLC...
+        /// </summary>
+        internal DateTime lastPING = DateTime.Now.AddHours(-1);
+        /// <summary>
+        /// indica se serva refresh parametri e quindi PLC...
+        /// </summary>
+        internal bool needRefresh = true;
+
+        /// <summary>
+        /// Struttura memoria PLC x lettura/scrittura da JSON file
+        /// </summary>
+        public plcMemMap memMap;
+
+        #endregion Public Fields
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Avvia generico IOB
+        /// </summary>
+        /// <param name="confPath"></param>
+        /// <param name="config"></param>
+        public IobGeneric(string confPath, IConfigurationRoot? config)
+        {
+            lg = LogManager.GetCurrentClassLogger();
+            connectionOk = false;
+            configPath = confPath;
+            confMan = config;
+            if (confMan != null)
+            {
+                var selection = confMan.GetSection("Endpoint");
+                if (selection.Exists())
+                {
+                    // recupero dati endpoint
+                    cIobConf = selection.Get<EndpointData>();
+                }
+            }
+        }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// Salva verifica stato connessione OK
+        /// </summary>
+        /// <returns></returns>
+        internal virtual bool connectionOk
+        {
+            get
+            {
+                return _connOk;
+            }
+            set
+            {
+                _connOk = value;
+            }
+        }
+
+        /// <summary>
+        /// Fornisce il valore di flusso e valore in formato valido x messa in coda nel formato
+        /// dtEve#flusso#valore#cont <paramref name="flusso">Flusso dati</paramref><paramref
+        /// name="valore">Valore da salvare</paramref>
+        /// </summary>
+        public string qEncodeFLog(string flusso, string valore)
+        {
+            string answ = "";
+            // fixme todo !!! fare
+            // tenere? cambiare? modificare? si dovrebbe cambiare con invio su channel REDIS dei dati ricevuti, eventualmente divisi x canale secondo setup
+#if false
+            try
+            {
+                answ = $"{DateTime.Now:yyyyMMddHHmmssfff}#{flusso}#{valore}#{counterULog}";
+            }
+            catch
+            { } 
+#endif
+            return answ;
+        }
+        /// <summary>
+        /// Accumula in coda i valori Flux Log e logga...
+        /// </summary>
+        /// <param name="val">VALORE RAW (x display)</param>
+        /// <param name="encodedVal">VALORE già processato con qEncodeFLog(...)</param>
+        public void accodaFLog(string val, string encodedVal)
+        {
+            // fixme todo !!! fare
+            // tenere? cambiare? modificare? si dovrebbe cambiare con invio su channel REDIS dei dati ricevuti, eventualmente divisi x canale secondo setup
+#if false
+            // mostro dati variati letti...
+            displayOtherData(val);
+            // --> accodo (valore già formattato)!
+            QueueFLog.Enqueue(encodedVal);
+            // se abilitato controllo coda FLog (superiore a 0...)
+            if (maxQueueFLog > 0)
+            {
+                // se ho una coda superiore a max ammesso
+                if (QueueFLog.Count > maxQueueFLog)
+                {
+                    // elimino valori iniziali fino a tornare al max ammesso...
+                    while (QueueFLog.Count > maxQueueFLog)
+                    {
+                        string currVal = "";
+                        QueueFLog.TryDequeue(out currVal);
+                        lgInfo($"Eliminazione da coda FLog per superamento maxLengh: {currVal}");
+                    }
+                }
+            }
+            // loggo!
+            lgTrace(string.Format("[QUEUE-FLOG] {0}", encodedVal));
+            counterFLog++;
+            if (counterFLog > 9999)
+            {
+                counterFLog = 0;
+            } 
+#endif
+        }
+
+        /// <summary>
+        /// indica se ping disabilitato da optPar
+        /// </summary>
+        public bool pingDisabled
+        {
+            get => getCRB("NO_PING");
+        }
+
+        /// <summary>
+        /// Verifica SE si debba fare log verboso (verboso + ogni tot letture IN)
+        /// </summary>
+        public bool verboseLog
+        {
+            get
+            {
+                bool answ = false;
+                int logEvery = getCRI("logEvery");
+                if (logEvery < 1)
+                {
+                    logEvery = 10;
+                }
+
+                answ = getCRB("verbose") && (nReadIN % logEvery == 0);
+                return answ;
+            }
+        }
+
+        #endregion Public Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Esecuzione dei task richiesti e pulizia coda richieste eseguite
+        /// </summary>
+        /// <param name="task2exe"></param>
+        public virtual Dictionary<string, string> executeTasks(Dictionary<string, string> task2exe)
+        {
+            // Verificare il protocollo: dovrebbe togliere SOLO i task eseguiti...
+            Dictionary<string, string> taskDone = new Dictionary<string, string>();
+            if (task2exe != null)
+            {
+                // controllo se memMap != null...
+                if (memMap != null)
+                {
+                    bool taskOk = false;
+                    string taskVal = "";
+                    // cerco task specifici: se ho startSetup --> imposto bit DBB701.DBB0.4
+                    foreach (var item in task2exe)
+                    {
+                        taskOk = false;
+                        taskVal = "";
+                        // converto richiesta in enum...
+                        taskType tName = taskType.nihil;
+                        Enum.TryParse(item.Key, out tName);
+                        // controllo sulla KEY...
+                        switch (tName)
+                        {
+                            case taskType.setArt:
+                            case taskType.setComm:
+                            case taskType.setProg:
+                            case taskType.setPzComm:
+                                // recupero dati da memMap...
+                                if (memMap != null && memMap.mMapWrite != null)
+                                {
+                                    if (memMap.mMapWrite.ContainsKey(item.Key))
+                                    {
+                                        dataConf currMem = memMap.mMapWrite[item.Key];
+                                        string addr = currMem.memAddr;
+                                        taskVal = $"SET task: {item.Key} --> {item.Value} | mem: {currMem.memAddr} - {currMem.size} byte";
+                                        // salvo il nuovo valore nella memoria... così prox invio lo trasmetterà
+                                        memMap.mMapWrite[item.Key].value = item.Value;
+                                    }
+                                    else
+                                    {
+                                        taskVal = $"NO DATA MEM, SET task: {item.Key} --> {item.Value}";
+                                    }
+                                }
+                                else
+                                {
+                                    taskVal = $"NO MemMap found, SET task: {item.Key} --> {item.Value}";
+                                }
+                                // salvo in currProd..
+                                saveProdData(new KeyValuePair<string, string>(item.Key, item.Value));
+
+                                break;
+
+                            case taskType.forceResetPzCount:
+                                // reset contapezzi inizio setup
+                                taskOk = resetcontapezziPLC();
+                                taskVal = taskOk ? "RESET PZ COUNT OK" : "PZ RESET DISABLED | NO EXEC";
+                                lgInfo($"Chiamata forceResetPzCount: taskOk: {taskOk} | taskVal: {taskVal}");
+                                break;
+
+                            case taskType.startSetup:
+                                // reset contapezzi inizio setup
+                                taskOk = resetcontapezziPLC();
+                                taskVal = taskOk ? "RESET: SETUP START" : "PZ RESET DISABLED | NO EXEC";
+                                lgInfo($"Chiamata startSetup: taskOk: {taskOk} | taskVal: {taskVal}");
+                                break;
+
+                            case taskType.stopSetup:
+                                // reset contapezzi fine setup SE ESPLICITAMENTE IMPOSTATO
+                                if (getCRB("ENABLE_PZ_RESET_stopSetup"))
+                                {
+                                    taskOk = resetcontapezziPLC();
+                                }
+                                taskVal = taskOk ? "RESET: SETUP END" : "PZ RESET DISABLED | NO EXEC";
+                                lgInfo($"Chiamata stopSetup: taskOk: {taskOk} | taskVal: {taskVal}");
+                                break;
+
+                            case taskType.setParameter:
+                                // richiedo da URL i parametri WRITE da popolare
+                                lgInfo("Chiamata setParameter --> processMemWriteRequests");
+                                taskVal = processMemWriteRequests();
+                                // se restituiscce "" faccio altra prova...
+                                if (string.IsNullOrEmpty(taskVal))
+                                {
+                                    // i parametri me li aspetto come stringa composta paramName|paramvalue
+                                    if (item.Value.Contains("|"))
+                                    {
+                                        string[] paramsJob = item.Value.Split('|');
+                                        taskVal = $"REQUEST SET PARAMETERS: {paramsJob[0]} --> {paramsJob[1]}";
+                                    }
+                                    else
+                                    {
+                                        taskVal = $"WRONG REQUEST FOR SET PARAMETERS: {item.Value} doesnt contain pipe for splitting key/value";
+                                    }
+                                }
+                                break;
+
+                            default:
+                                taskVal = $"taskReq: {tName} | key: {item.Key} | val: {item.Value} | SKIPPED | NO EXEC";
+                                lgInfo($"Chiamata senza processing: taskOk: {taskOk} | taskVal: {taskVal}");
+                                break;
+                        }
+                        // aggiungo task!
+                        taskDone.Add(item.Key, taskVal);
+                    }
+                }
+                else
+                {
+                    lgError($"Attenzione! memMap è nullo, non posso eseguire task2exe!");
+                }
+            }
+
+            return taskDone;
+        }
+
+        /// <summary>
+        /// Metodo generico di reset contapezzi...
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool resetcontapezziPLC()
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Salva valori indicati in prod data
+        /// </summary>
+        /// <param name="item">Item KVP di cui salvare i dati in currProdData come chiave/valore</param>
+        /// <returns></returns>
+        public void saveProdData(KeyValuePair<string, string> item)
+        {
+            // imposto i valori...
+            if (currProdData.ContainsKey(item.Key))
+            {
+                currProdData[item.Key] = item.Value;
+            }
+            else
+            {
+                currProdData.Add(item.Key, item.Value);
+            }
+        }
+
+        /// <summary>
+        /// Metodo base connessione...
+        /// </summary>
+        public virtual void tryConnect()
+        {
+            dtAvvioAdp = DateTime.Now;
+        }
+
+        #endregion Public Methods
+
+        #region Internal Properties
+
+        /// <summary>
+        /// COnfiguraizone Endpoint corrente
+        /// </summary>
+        internal EndpointData cIobConf { get; set; } = new EndpointData();
+
+        internal string configPath { get; set; } = "";
+
+        internal IConfigurationRoot? confMan { get; set; } = null!;
+
+        #endregion Internal Properties
+
+        #region Internal Methods
+
+        internal bool getCRB(string keyName)
+        {
+            bool answ = false;
+            answ = confMan.GetValue<bool>(keyName);
+            return answ;
+        }
+
+        internal int getCRI(string keyName)
+        {
+            int answ = -1;
+            answ = confMan.GetValue<int>(keyName);
+            return answ;
+        }
+
+        internal string getCRS(string keyName)
+        {
+            string answ = "";
+            answ = confMan.GetValue<string>(keyName);
+            return answ;
+        }
+
+        #endregion Internal Methods
+
+        #region Protected Fields
+
+        /// <summary>
+        /// wrapper di log
+        /// </summary>
+        protected static Logger lg;
+
+        protected bool _connOk = false;
+
+        /// <summary>
+        /// Dizionario valori impostati x produzione
+        /// </summary>
+        protected Dictionary<string, string> currProdData = new Dictionary<string, string>();
+
+        /// <summary>
+        /// Dizionario ultimi valori (double) delle TSVC
+        /// </summary>
+        protected Dictionary<string, double> LastTSVC = new Dictionary<string, double>();
+
+        /// <summary>
+        /// Dizionario di VC da trattare come TimeSeries (con conf decodificata + processing successivo...)
+        /// </summary>
+        protected Dictionary<string, VCData> TSVC_Data = new Dictionary<string, VCData>();
+
+        #endregion Protected Fields
+
+        #region Protected Properties
+
+        /// <summary>
+        /// Numero letture IN da avvio
+        /// </summary>
+        protected int nReadIN { get; set; }
+
+        /// <summary>
+        /// test ping all'indirizzo PLC/CNC impostato nei parametri
+        /// </summary>
+        /// <returns></returns>
+        protected IPStatus testPingMachine
+        {
+            get
+            {
+                IPStatus answ = IPStatus.Unknown;
+                // se disabilitato salto...
+                if (pingDisabled)
+                {
+                    answ = IPStatus.Success;
+                }
+                else
+                {
+                    IPAddress address;
+                    PingReply reply;
+                    using (Ping pingSender = new Ping())
+                    {
+                        address = IPAddress.Loopback;
+                        int pingMsTimeout = cIobConf.PingMsTimeout;
+                        IPAddress.TryParse(cIobConf.IpAddress, out address);
+                        try
+                        {
+                            // se != null --> uso address...
+                            if (address != null)
+                            {
+                                reply = pingSender.Send(address, pingMsTimeout);
+                            }
+                            else
+                            {
+                                reply = pingSender.Send(cIobConf.IpAddress, pingMsTimeout);
+                            }
+                        }
+                        catch
+                        {
+                            reply = pingSender.Send(IPAddress.Loopback, pingMsTimeout);
+                        }
+                        answ = reply.Status;
+                    }
+                }
+                return answ;
+            }
+        }
+
+        #endregion Protected Properties
+
+        #region Protected Methods
+
+        /// <summary>
+        /// Stringa raw dei parametri da scrivere...
+        /// </summary>
+        /// <returns></returns>
+        protected string getParams2write()
+        {
+            string answ = "";
+            // recuperare da una apposita area REDIS...
+#if false
+            string url2call = $"{urlGetParams2Write}";
+            if (verboseLog)
+            {
+                lgInfo("chiamata URL " + url2call);
+            }
+            answ = utils.callUrlNow(url2call);
+            // se vuoto faccio seconda prova...
+            if (string.IsNullOrEmpty(answ))
+            {
+                answ = utils.callUrlNow(url2call);
+            }
+#endif
+            return answ;
+        }
+
+        /// <summary>
+        /// Effettua logging DEBUG corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgDebug(string message)
+        {
+            lg.Debug(message);
+        }
+
+        /// <summary>
+        /// Effettua logging DEBUG corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        protected void lgDebug(string message, params object[] args)
+        {
+            lg.Debug(message, args);
+        }
+
+        /// <summary>
+        /// Effettua logging ERROR corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgError(string message)
+        {
+            lg.Error(message);
+        }
+
+        /// <summary>
+        /// Effettua logging ERROR corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        protected void lgError(string message, params object[] args)
+        {
+            lg.Error(message, args);
+        }
+
+        /// <summary>
+        /// Effettua logging ERROR corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="exception"></param>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        protected void lgError(Exception exception, string message, params object[] args)
+        {
+            lg.Error(exception, message, args);
+        }
+
+        /// <summary>
+        /// Effettua logging FATAL corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgFatal(string message)
+        {
+            lg.Fatal(message);
+        }
+
+        /// <summary>
+        /// Effettua logging FATAL corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        protected void lgFatal(string message, params object[] args)
+        {
+            lg.Fatal(message, args);
+        }
+
+        /// <summary>
+        /// Effettua logging FATAL corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="exception"></param>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        protected void lgFatal(Exception exception, string message, params object[] args)
+        {
+            lg.Fatal(exception, message, args);
+        }
+
+        /// <summary>
+        /// Effettua logging INFO corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgInfo(string message)
+        {
+            lg.Info(message);
+        }
+
+        /// <summary>
+        /// Effettua logging INFO corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        protected void lgInfo(string message, params object[] args)
+        {
+            lg.Info(message, args);
+        }
+
+        /// <summary>
+        /// Effettua logging INFO corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        protected void lgTrace(string message)
+        {
+            lg.Trace(message);
+        }
+
+        /// <summary>
+        /// Effettua logging INFO corretto impostanto anche la variabile IOB prima di scrivere...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        protected void lgTrace(string message, params object[] args)
+        {
+            lg.Trace(message, args);
+        }
+
+        /// <summary>
+        /// Metodo da overridare x scrivere DAVVERO i parametri sul PLC
+        /// </summary>
+        /// <param name="updatedPar"></param>
+        protected virtual void plcWriteParams(ref List<objItem> updatedPar)
+        {
+            // non faccio nulla di base...
+        }
+
+        /// <summary>
+        /// Processa le richieste di scrittura memoria
+        /// </summary>
+        /// <returns></returns>
+        protected string processMemWriteRequests()
+        {
+            string answ = "";
+            // li salvo nei parametri in memoria locale (ogni adapter DOVREBBE salvare POI sul VERO PLC)
+            List<objItem> writeList = new List<objItem>();
+            List<objItem> updatedPar = new List<objItem>();
+            // recupero elenco delle cose da fare
+            string resp = getParams2write();
+            if (!string.IsNullOrEmpty(resp))
+            {
+                try
+                {
+                    writeList = JsonConvert.DeserializeObject<List<objItem>>(resp);
+                    // se ho da fare chiamo esecuzione..
+                    if (writeList.Count > 0)
+                    {
+                        foreach (var item in writeList)
+                        {
+                            // scrivo in memoria
+                            if (memMap.mMapWrite.ContainsKey(item.uid))
+                            {
+                                memMap.mMapWrite[item.uid].value = item.reqValue;
+                                // accodo in stringa taskVal...
+                                answ += $" | Parameter {item.uid} --> {item.reqValue}";
+                                // sistemo valori
+                                item.value = item.reqValue;
+                                lgInfo($"Richiesta update parametro {item.uid} | actVal = {item.value} | reqVal = {item.reqValue}");
+                                item.reqValue = "";
+                                // salvo in lista da ritrasmettere
+                                updatedPar.Add(item);
+                            }
+                            else
+                            {
+                                answ += $" | Error: parameter {item.uid} not found";
+                            }
+                        }
+                        // richiamo scrittura parametri su PLC
+                        plcWriteParams(ref updatedPar);
+                        // invio su cloud parametri!
+                        string rawData = JsonConvert.SerializeObject(updatedPar);
+                        lgInfo("Notifica a server scrittura parametri");
+#if false
+                        utils.callUrl($"{urlUpdateWriteParams}", rawData);
+#endif
+                    }
+                }
+                catch (Exception exc)
+                {
+                    lgError($"Eccezione in processMemWriteRequests:{Environment.NewLine}{exc}");
+                }
+            }
+            else
+            {
+                lgError("Non è stata ricevuta risposta x task da eseguire");
+            }
+            return answ;
+        }
+
+        /// <summary>
+        /// setup parametri da file di conf
+        /// </summary>
+        protected void setupMemMap()
+        {
+            lgInfo($"setupMemMap | trovati {memMap.mMapRead.Count} parametri Read (TSVC)");
+            lgInfo($"setupMemMap | trovati {memMap.mMapWrite.Count} parametri Write");
+            if (getCRB("verbose"))
+            {
+                string rawMemConf = JsonConvert.SerializeObject(memMap, Formatting.Indented);
+                lgDebug($"setupMemMap | configurazione memoria R/W:{Environment.NewLine}{rawMemConf}");
+            }
+            // se ho variabili read --> genero dati TSVC...
+            if (memMap.mMapRead.Count > 0)
+            {
+                TSVC_Data.Clear();
+                LastTSVC.Clear();
+                VCData currConf;
+                int periodo = 0;
+                VC_func funz = VC_func.POINT;
+                // accodo nella conf...
+                foreach (var item in memMap.mMapRead)
+                {
+                    funz = item.Value.func;
+                    periodo = item.Value.period;
+                    currConf = new VCData()
+                    {
+                        Funzione = funz,
+                        Period = periodo,
+                        DTStart = DateTime.Now.AddHours(-1),
+                        dataArray = new List<double>()
+                    };
+                    TSVC_Data.Add(item.Key, currConf);
+                }
+                // documento...
+                foreach (var item in TSVC_Data)
+                {
+                    lgTrace($"TSVC: {item.Key} | periodo: {item.Value.Period} | funz: {item.Value.Funzione}");
+                    // salvo i valori PREC...
+                    LastTSVC.Add(item.Key, 0);
+                }
+            }
+        }
+
+        #endregion Protected Methods
+    }
+}
\ No newline at end of file
diff --git a/MP.MONO.ADAPTER.OPC/IobOpcUa.cs b/MP.MONO.ADAPTER.OPC/IobOpcUa.cs
new file mode 100644
index 0000000..9285f37
--- /dev/null
+++ b/MP.MONO.ADAPTER.OPC/IobOpcUa.cs
@@ -0,0 +1,1360 @@
+using Microsoft.Extensions.Configuration;
+using MP.MONO.Core;
+using MP.MONO.Core.CONF;
+using Newtonsoft.Json;
+using NLog;
+using Opc.Ua;
+using Opc.Ua.Configuration;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.NetworkInformation;
+using System.Text;
+using System.Threading.Tasks;
+using static MP.MONO.Core.Enums;
+
+namespace MP.MONO.ADAPTER.OPC
+{
+    /// <summary>
+    /// Classe di comunicazione OPC-UA
+    /// </summary>
+    public class IobOpcUa : IobGeneric
+    {
+        private Logger Log = LogManager.GetCurrentClassLogger();
+
+        /// <summary>
+        /// Avvia un oggetto IOB in grado di comunicare con server OPC-UA 
+        /// Impiega il pacchetto Nuget OPC-UA foundation https://github.com/OPCFoundation/UA-.NETStandard
+        /// </summary>
+        /// <param name="confPath"></param>
+        public IobOpcUa(string confPath, IConfigurationRoot? config) : base(confPath , config)
+        {         
+
+            // gestione data filtering...
+            if (!string.IsNullOrEmpty(config.GetValue<string>("ENABLE_DATA_FILTER")))
+            {
+                bool.TryParse(config.GetValue<string>("ENABLE_DATA_FILTER"), out enableDataFilter);
+            }
+            // gestione restart OpcUa client...
+            if (!string.IsNullOrEmpty(config.GetValue<string>("ENABLE_CLI_RESTART")))
+            {
+                bool.TryParse(config.GetValue<string>("ENABLE_CLI_RESTART"), out enableCliRestart);
+            }
+            // init datetime counters
+            DateTime adesso = DateTime.Now;
+            lastCurrent = adesso;
+            // ora leggo il file di conf specifico....
+            string jsonFileName = config.GetValue<string>("OPC_PARAM_CONF");
+            if (!string.IsNullOrEmpty(jsonFileName))
+            {
+                // leggo il file...
+                loadOpcUaConf(jsonFileName);
+            }
+        }
+
+
+        //#region Public Methods
+
+        /// <summary>
+        /// Processo i task richiesti e li elimino dalla coda 1:1
+        /// </summary>
+        /// <param name="task2exe"></param>
+        public override Dictionary<string, string> executeTasks(Dictionary<string, string> task2exe)
+        {
+            // uso metodo base x ora
+            return base.executeTasks(task2exe);
+        }
+
+        ///// <summary>
+        ///// Recupera uno specifico dataItem
+        ///// </summary>
+        ///// <param name="diKey"></param>
+        ///// <returns></returns>
+        //public string getDataItemValue(string diKey)
+        //{
+        //    string answ = "";
+        //    if (string.IsNullOrEmpty(diKey))
+        //    {
+        //        lgError($"Attenzione: richiesta chiave vuota in getDataItemValue{Environment.NewLine}StackTrace: {Environment.StackTrace}");
+        //    }
+        //    else
+        //    {
+        //        DateTime adesso = DateTime.Now;
+        //        if (dataItemMem.Count == 0)
+        //        {
+        //            numErroriCheck++;
+        //            if (vetoCheckStatus < adesso)
+        //            {
+        //                lgError($"Errore in getDataItemValue per {diKey} | dataItemMem NON contiene valori");
+        //                // imposto veto per vetoSeconds...
+        //                vetoCheckStatus = adesso.AddSeconds(vetoSeconds * 2);
+        //            }
+        //        }
+        //        else
+        //        {
+        //            if (!dataItemMem.ContainsKey(diKey))
+        //            {
+        //                if (vetoCheckStatus < adesso)
+        //                {
+        //                    lgError($"Errore in getDataItemValue per {diKey} | dataItemMem non contiene la chiave richiesta ma altri {dataItemMem.Count} valori");
+        //                    // imposto veto per vetoSeconds...
+        //                    vetoCheckStatus = adesso.AddSeconds(vetoSeconds * 2);
+        //                }
+        //                numErroriCheck++;
+        //            }
+        //            else
+        //            {
+        //                try
+        //                {
+        //                    var currDataItem = dataItemMem[diKey];
+        //                    answ = currDataItem.value;
+        //                }
+        //                catch (Exception exc)
+        //                {
+        //                    lgError($"Errore in getDataItemValue per {diKey} | dataItemMem contiene {dataItemMem.Count} valori {Environment.NewLine}{exc}");
+        //                    if (dataItemMem != null)
+        //                    {
+        //                        lgError($"dataItemMem contiene {dataItemMem.Count} valori");
+        //                        int maxNum = 5;
+        //                        foreach (var item in dataItemMem)
+        //                        {
+        //                            maxNum--;
+        //                            if (maxNum < 0)
+        //                            {
+        //                                break;
+        //                            }
+        //                            lgInfo($"{item.Key} --> {item.Value.DisplayName} = {item.Value.value}");
+        //                        }
+        //                    }
+        //                }
+        //            }
+        //        }
+        //        // se supero soglia errori lettura --> disconnetto e resetto
+        //        if (numErroriCheck > maxErroriCheck)
+        //        {
+        //            lgInfo($"numErroriCheck: {numErroriCheck} --> richiesta disconnessione adapter con tryDisconnect");
+
+        //            numErroriCheck = 0;
+        //            tryDisconnect();
+        //        }
+        //    }
+
+        //    return answ;
+        //}
+
+        ///// <summary>
+        ///// Recupero dati dinamici...
+        ///// </summary>
+        //public override Dictionary<string, string> getDynData()
+        //{
+        //    Dictionary<string, string> outVal = new Dictionary<string, string>();
+        //    return outVal;
+        //}
+
+        ///// <summary>
+        ///// Effettua vero processing contapezzi
+        ///// </summary>
+        //public override void processContapezzi()
+        //{
+        //    if (utils.CRB("enableContapezzi"))
+        //    {
+        //        // da ridefinire la gestione base del contapezzi OPC-UA...
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Effettua lettura semafori principale
+        ///// <paramref name="currDispData">Parametri da aggiornare x display in form</paramref>
+        ///// </summary>
+        //public override void readSemafori(ref newDisplayData currDispData)
+        //{
+        //    base.readSemafori(ref currDispData);
+        //    try
+        //    {
+        //        if (verboseLog)
+        //        {
+        //            lgInfo("inizio read semafori");
+        //        }
+
+        //        currDispData.semIn = Semaforo.SV;
+
+        //        // verifico SE sia necessario forzare la lettura RAW
+        //        if (doByteRead)
+        //        {
+        //            if (DateTime.Now.Subtract(lastCurrent).TotalSeconds > lastCurrentMaxElapsed)
+        //            {
+        //                // FIXME TODO !!!
+        //                foreach (var item in dataItemMem)
+        //                {
+        //                    // restituisce i 115 byte da deserializzare... qui HACK!
+        //                    var rawVal = UA_ref.ReadNodeRaw(item.Value.StartNodeId);
+        //                    if (rawVal != null)
+        //                    {
+        //                        byteRawData = getByteRaw((DataValue)rawVal);
+        //                        lastCurrent = DateTime.Now;
+        //                        currReadErrors = 0;
+        //                    }
+        //                    else
+        //                    {
+        //                        currReadErrors++;
+        //                    }
+        //                }
+        //            }
+        //        }
+
+        //        // decodifica e gestione
+        //        decodeToBaseBitmap();
+        //        reportRawInput(ref currDispData);
+        //    }
+        //    catch (Exception exc)
+        //    {
+        //        currDispData.semIn = Semaforo.SR;
+        //        lgError($"Eccezione in readSemafori:{Environment.NewLine}{exc}");
+        //    }
+        //    // se > max errori --> disconnetto
+        //    if (currReadErrors > maxReadErrors)
+        //    {
+        //        lgError($"Superato limite errori Read ({currReadErrors}) --> tryDisconnect");
+        //        currReadErrors = 0;
+        //        tryDisconnect();
+        //    }
+        //    else
+        //    {
+        //        // altrimenti pausa forzata
+        //        Thread.Sleep(300);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Effettua reset del contapezzi, NON POSSIBILE in questa versione
+        ///// </summary>
+        ///// <returns></returns>
+        //public override bool resetcontapezziPLC()
+        //{
+        //    bool answ = false;
+        //    return answ;
+        //}
+
+        ///// <summary>
+        ///// Effettua IMPOSTAZIONE FORZATA del contapezzi, NON POSSIBILE in questa versione
+        ///// </summary>
+        ///// <returns></returns>
+        //public override bool setcontapezziPLC(int newPzCount)
+        //{
+        //    bool answ = false;
+        //    return answ;
+        //}
+
+
+        /// <summary>
+        /// Verifica SE si debba fare log periodico (ogni "verboseLogTOut" sec...)
+        /// </summary>
+        public bool periodicLog
+        {
+            get
+            {
+                bool answ = false;
+                answ = (DateTime.Now.Subtract(lastPeriodicLog).TotalSeconds > getCRI("verboseLogTOut"));
+                if (answ)
+                {
+                    lastPeriodicLog = DateTime.Now;
+                }
+
+                return answ;
+            }
+        }
+
+
+        /// <summary>
+        /// Override connessione
+        /// </summary>
+        public override void tryConnect()
+        {
+            if (!connectionOk)
+            {
+                // controllo che il ping sia stato tentato almeno pingTestSec fa...
+                if (DateTime.Now.Subtract(lastPING).TotalSeconds > getCRI("pingTestSec"))
+                {
+                    if (verboseLog || periodicLog)
+                    {
+                        lgInfo("OpcUa: ConnKO - tryConnect");
+                    }
+                    // in primis salvo data ping...
+                    lastPING = DateTime.Now;
+                    // se passa il ping faccio il resto...
+                    if (testPingMachine == IPStatus.Success)
+                    {
+                        string szStatusConnection = "";
+                        try
+                        {
+                            // ora provo connessione...
+                            var task = Task.Run(async () =>
+                            {
+                                return await doConnect().ConfigureAwait(false);
+                            });
+                            short esitoLink = task.Result; // use returned result from async method here
+                            lgInfo($"szStatusConnection OpcUa, esitoLink: {esitoLink}");
+                            connectionOk = true;
+                            // refresh stato allarmi!!!
+                            if (connectionOk)
+                            {
+                                if (adpRunning)
+                                {
+                                    lgInfo("Connessione OK");
+                                }
+                            }
+                            else
+                            {
+                                lgError("Impossibile procedere, connessione mancante...");
+                            }
+                        }
+                        catch (Exception exc)
+                        {
+                            lgFatal($"Errore nella connessione all'adapter OpcUa: {szStatusConnection}{Environment.NewLine}{exc}");
+                            connectionOk = false;
+                            lgInfo($"Eccezione in TryConnect, Adapter OpcUa NON running, pausa di {getCRI("waitRecMSec")} msec prima di ulteriori tentativi di riconnessione");
+                        }
+                    }
+                    else
+                    {
+                        // loggo no risposta ping ...
+                        connectionOk = false;
+                        if (verboseLog || periodicLog)
+                        {
+                            lgInfo($"Attenzione: OpcUa controllo PING fallito per IP {cIobConf.IpAddress}");
+                        }
+                    } 
+                }
+            }
+            else
+            {
+                needRefresh = true; 
+            }
+            // se non è ancora connesso faccio procesisng memoria caso disconnesso...
+            if (!connectionOk)
+            {
+                // processo semafori ed invio...
+                processMemoryDiscon(); 
+            }
+        }
+
+        /// <summary>
+        /// Processa gestione memoria x invio dati QUANDO IOB è disconnesso da CNC...
+        /// </summary>
+        internal void processMemoryDiscon()
+        {
+            // controllo contatore invio "keepalive"... invio solo a scadenza
+            if (DateTime.Now.Subtract(lastDisconnCheck).TotalSeconds > getCRI("disconMaxSec"))
+            {
+                // FIXME TODO !!! FARE 
+                // da realizzare un sistema x inviare che il server OPC-UA è disonnesso e la macchina è in stato unknown / server disconnesso
+#if false
+                // resetto tutti i valori BYTE IN/PREV/OUT... così invio macchina spenta...
+                B_input = 0;
+                B_output = 0;
+                B_previous = 0;
+                accodaSigIN(ref currDispData); 
+#endif
+                // update controllo
+                lastDisconnCheck = DateTime.Now;
+            }
+        }
+
+        /// <summary>
+        /// dataOra ultima verifica CNC disconnesso...
+        /// </summary>
+        internal DateTime lastDisconnCheck;
+
+        ///// <summary>
+        ///// Override disconnessione
+        ///// </summary>
+        //public override void tryDisconnect()
+        //{
+        //    if (connectionOk)
+        //    {
+        //        if (UA_ref != null)
+        //        {
+        //            string szStatusConnection = "";
+        //            try
+        //            {
+        //                UA_ref.Disconnect();
+        //                connectionOk = false;
+        //                lgInfo(szStatusConnection);
+        //                lgInfo("Effettuata disconnessione adapter OpcUa!");
+        //            }
+        //            catch (Exception exc)
+        //            {
+        //                lgFatal(exc, "Errore nella disconnessione dall'adapter OpcUa");
+        //            }
+        //        }
+        //        else
+        //        {
+        //            lgDebug("IMPOSSIBILE effettuare disconnessione OpcUa: UA_ref non disponibile...");
+        //        }
+        //    }
+        //    else
+        //    {
+        //        lgError("IMPOSSIBILE effettuare disconnessione OpcUa: Connessione non disponibile...");
+        //    }
+        //}
+
+        //#endregion Public Methods
+
+        //#region Internal Methods
+
+        /// <summary>
+        /// Verifica ed invia variazioni
+        /// </summary>
+        /// <param name="MonIt"></param>
+        /// <param name="NotifyValue"></param>
+        /// <param name="forceSend"></param>
+        internal bool checkAndSend(Opc.Ua.Client.MonitoredItem MonIt, string NotifyValue, bool forceSend)
+        {
+            bool changed = false;
+            if (MonIt != null)
+            {
+                if (!string.IsNullOrEmpty(NotifyValue))
+                {
+                    string sVal = "";
+                    string descr = "";
+                    DateTime locTStamp = DateTime.Now;
+                    descr = itemTranslation("OPC", MonIt.DisplayName);
+                    sVal = $"Change: {locTStamp.ToString()} | descr: {descr} | Id: {MonIt.StartNodeId} | Val: {NotifyValue}";
+                    lgInfo(sVal);
+
+                    // verifico se salvare
+                    changed = checkSaveValue(MonIt, NotifyValue, true);
+                    // cerco se non sia un dato filtrato in FLUXLOG...
+                    bool isFiltered = opcUaParams.fluxLogVeto.Contains(MonIt.DisplayName);
+                    if (isFiltered)
+                    {
+                        lgTrace($"NON ACCODATO sample per {MonIt.DisplayName} - trovato VETO in fluxLogVeto", false);
+                    }
+                    else
+                    {
+                        if (changed || forceSend)
+                        {
+                            accodaFLog(sVal, qEncodeFLog(descr, $"{NotifyValue}"));
+                        }
+                        else
+                        {
+                            lgTrace($"NON ACCODATO sample per {MonIt.DisplayName} - verifica variazione ha dato esito negativo", false);
+                        }
+                    }
+                }
+                else
+                {
+                    lgError($"checkAndSend ERROR | MonIt: {MonIt.DisplayName} | NotifyValue Null!!!");
+                }
+            }
+            else
+            {
+                lgError("checkAndSend ERROR: MonIt null");
+            }
+            return changed;
+        }
+
+        /// <summary>
+        /// Verifica ed invia variazioni DAL FORMATO RAW data (byte[])
+        /// </summary>
+        /// <param name="MonIt"></param>
+        /// <param name="NotifyValue"></param>
+        /// <param name="forceSend"></param>
+        internal virtual bool checkAndSendRaw(Opc.Ua.Client.MonitoredItem MonIt, byte[] NotifyValue, bool forceSend)
+        {
+            bool changed = false;
+            if (MonIt != null)
+            {
+                if (NotifyValue != null && NotifyValue.Length > 0)
+                {
+                    // versione base: il valore è la stringa composta da TUTTI i valori in BYTE
+                    // espressi come comma-sep-string
+                    StringBuilder sb = new StringBuilder();
+                    foreach (var bVal in NotifyValue)
+                    {
+                        sb.Append($"{bVal},");
+                    }
+                    string currVal = sb.ToString();
+
+                    string sVal = "";
+                    string descr = "";
+                    DateTime locTStamp = DateTime.Now;
+                    descr = itemTranslation("OPC", MonIt.DisplayName);
+                    sVal = $"Change: {locTStamp.ToString()} | descr: {descr} | Id: {MonIt.StartNodeId} | Val: {currVal}";
+                    lgInfo(sVal);
+
+                    // verifico se salvare
+                    changed = checkSaveValue(MonIt, currVal, true) || forceSend;
+                    // cerco se non sia un dato filtrato in FLUXLOG...
+                    bool isFiltered = opcUaParams.fluxLogVeto.Contains(MonIt.DisplayName);
+                    if (isFiltered)
+                    {
+                        lgTrace($"NON ACCODATO sample per {MonIt.DisplayName} - trovato VETO in fluxLogVeto", false);
+                    }
+                    else
+                    {
+                        if (changed || forceSend)
+                        {
+                            accodaFLog(sVal, qEncodeFLog(descr, $"{NotifyValue}"));
+                        }
+                        else
+                        {
+                            lgTrace($"NON ACCODATO sample per {MonIt.DisplayName} - verifica variazione ha dato esito negativo", false);
+                        }
+                    }
+                }
+                else
+                {
+                    lgError($"checkAndSend ERROR | MonIt: {MonIt.DisplayName} | NotifyValue Null!!!");
+                }
+            }
+            else
+            {
+                lgError("checkAndSend ERROR: MonIt null");
+            }
+            return changed;
+        }
+
+        internal void sendDataItemListToServer(NodeId StartNodeId)
+        {
+            // converto gli attuali nell'elenco dataitem...
+            List<MachDataItem> elencoDataItems = dataItemMem.Select(d => new MachDataItem()
+            {
+                uuid = d.Key,
+                Category = DataItemCategory.EVENT,
+                Name = d.Value.DisplayName,
+                Type = $"{d.Value.NodeClass}",
+                SubType = $"{StartNodeId}"
+            }
+            ).ToList();
+
+            lgInfo($"Richiesta sendDataItemListToServer per {elencoDataItems.Count} dataItems");
+            // aspetta un tempo random da 10-100 ms...
+            Random rnd = new Random();
+            Task.Delay(rnd.Next(10, 100));
+            // invio il dataItem serializzato...
+            sendDataItemsList(elencoDataItems);
+        }
+
+        /// <summary>
+        /// Evento rilevazione modifica valori -->; chiamo checkSend
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        internal virtual void UA_ref_eh_MonItChange(object sender, opcUaMonitItemChange e)
+        {
+            string currVal = "";
+            // da verificare decodifica valore byte...
+            if (doByteRead)
+            {
+                var currNot = e.CurrNotify;
+                if (currNot != null)
+                {
+                    byteRawData = getByteRaw((DataValue)currNot.Value);
+                    checkAndSendRaw(e.CurrMonitoredItem, byteRawData, false);
+                }
+            }
+            else
+            {
+                currVal = $"{e.CurrNotify.Value}";
+                checkAndSend(e.CurrMonitoredItem, currVal, false);
+            }
+            // aggiorno ultima lettura
+            lastCurrent = DateTime.Now;
+        }
+
+        //#endregion Internal Methods
+
+        //#region Protected Fields
+
+        /// <summary>
+        /// Struttura dove vengono memorizzati i dataitem ed i rispettivi valori x processing
+        /// </summary>
+        protected Dictionary<string, OpcUaDataItemExt> dataItemMem = new Dictionary<string, OpcUaDataItemExt>();
+
+        /// <summary>
+        /// Abilitazione restart (da opt par...)
+        /// </summary>
+        protected bool enableCliRestart = false;
+
+        /// <summary>
+        /// Gestione filtraggio dati
+        /// </summary>
+        protected bool enableDataFilter = false;
+
+        /// <summary>
+        /// Determina se ha effettuata lettura items in memoria x confronto...
+        /// </summary>
+        protected bool hasReadItems = false;
+
+        /// <summary>
+        /// Ultimo current received x gestione update periodico...
+        /// </summary>
+        protected DateTime lastCurrent = DateTime.Now;
+
+        /// <summary>
+        /// Oggetto MAIN x connessione OPC-UA
+        /// </summary>
+        protected UAClient UA_ref;
+
+        ///// <summary>
+        ///// Veto controllo status x log...
+        ///// </summary>
+        //protected DateTime vetoCheckStatus = DateTime.Now;
+
+        //protected int WatchDog = 0;
+
+        //#endregion Protected Fields
+
+        //#region Protected Properties
+
+        /// <summary>
+        /// Area dati raw per lettura encoded (SE presente)
+        /// </summary>
+        protected byte[] byteRawData { get; set; } = new byte[1];
+
+        /// <summary>
+        /// Indica se si debba leggere un area di tipo "encoded" (byte raw --> obj)
+        /// </summary>
+        protected bool doByteRead { get; set; } = false;
+
+        ///// <summary>
+        ///// Verifico se abbia ALMENO un errore...
+        ///// </summary>
+        //protected bool hasError
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condError);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se abbia emergenza ARMATA (cond normale)
+        ///// </summary>
+        //protected bool hasEStopArmed
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condEStop);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se abbia stato POWER ON (multicondizione)
+        ///// </summary>
+        //protected virtual bool hasPowerOn
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condPowerOn);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se abbia stato MANUAL (condizioni varie, es stopped)
+        ///// </summary>
+        //protected virtual bool isManual
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condManual);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se abbia stato READY (condizioni varie, es ausiliari OK)
+        ///// </summary>
+        //protected virtual bool isReady
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condReady);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se sia in stato Ssetup
+        ///// </summary>
+        //protected bool isSetup
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condSetup);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se sia in stato WarmUp / CoolDown (riscaldamento/raffreddamento)
+        ///// </summary>
+        //protected bool isWarmUpCoolDown
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condWarmUpCoolDown);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se sia in stato Warning
+        ///// </summary>
+        //protected bool isWarning
+        //{
+        //    get
+        //    {
+        //        return checkMultiCondition(opcUaParams.condWarning);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Indica se abbia stato READY (condizioni varie, es ausiliari OK)
+        ///// </summary>
+        //protected bool isWorking
+        //{
+        //    get
+        //    {
+        //        // cerco SE HO cond OPC Ua o classica... nel caso creo e salvo
+        //        if (opcUaParams.condWorkOpc.checkList == null || opcUaParams.condWorkOpc.checkList.Count == 0)
+        //        {
+        //            opcUaParams.condWorkOpc = new diCheckCondSetup()
+        //            {
+        //                checkList = opcUaParams.condWork,
+        //                checkMode = boolCheckMode.AND,
+        //                negateValue = false
+        //            };
+        //        }
+        //        return checkMultiCondition(opcUaParams.condWorkOpc);
+        //    }
+        //}
+
+        ///// <summary>
+        ///// Periodo massimo (in sec) per letture dati RAW in mancanza di eventi
+        ///// </summary>
+        //protected int lastCurrentMaxElapsed { get; set; } = 120;
+
+        /// <summary>
+        /// Parametri specifici OPC-UA
+        /// </summary>
+        protected OpcUaParamConf opcUaParams { get; set; }
+
+        ///// <summary>
+        ///// URL x salvataggio elenco dataItems OpcUa
+        ///// </summary>
+        //protected string urlSaveDataItems
+        //{
+        //    get
+        //    {
+        //        string answ = "";
+        //        try
+        //        {
+        //            string machineName = Environment.MachineName;
+        //            answ = $@"{cIobConf.serverData.TRANSP}://{cIobConf.serverData.MPIP}{cIobConf.serverData.MPURL}{cIobConf.serverData.CMDALIVE}/saveDataItems/{cIobConf.codIOB}";
+        //        }
+        //        catch (Exception exc)
+        //        {
+        //            lgError(exc, "Errore in composizione urlSaveDataItems");
+        //        }
+        //        return answ;
+        //    }
+        //}
+
+        //#endregion Protected Properties
+
+        //#region Protected Methods
+
+        ///// <summary>
+        ///// Verifica un DataItem e se il valore corrisponde a quello indicato come "true value"
+        ///// restituisce true
+        ///// </summary>
+        ///// <param name="itemName"></param>
+        ///// <param name="trueVal"></param>
+        ///// <returns></returns>
+        //protected bool checkDataItem(string itemName, string trueVal)
+        //{
+        //    bool answ = false;
+        //    OpcUaDataItemExt currValue = null;
+        //    try
+        //    {
+        //        currValue = dataItemMem[itemName];
+        //        answ = (currValue.value.Equals(trueVal));
+        //    }
+        //    catch
+        //    {
+        //        lgError($"Errore in decodifica valore per {itemName} rispetto a {trueVal} | recuperato {currValue} / {currValue.value}");
+        //    }
+        //    return answ;
+        //}
+
+        ///// <summary>
+        ///// Verifica condizione "multipla" secondo setup json
+        ///// </summary>
+        ///// <param name="reqCondition">Set condizioni da validare</param>
+        ///// <returns></returns>
+        //protected bool checkMultiCondition(diCheckCondSetup reqCondition)
+        //{
+        //    bool answ = false;
+        //    int numCondOk = 0;
+        //    int numCond = 0;
+        //    if (reqCondition.checkList != null && reqCondition.checkList.Count > 0)
+        //    {
+        //        numCond = reqCondition.checkList.Count;
+        //        // cerco nell'elenco delle condizioni che indicano lavora se sono ok faccio +1 conteggio......
+        //        foreach (var item in reqCondition.checkList)
+        //        {
+        //            if (string.IsNullOrEmpty(item.keyName))
+        //            {
+        //                lgError($"Attenzione: item vuoto in checkMultiCondition{Environment.NewLine}StackTrace: {Environment.StackTrace}");
+        //            }
+        //            else
+        //            {
+        //                if (getDataItemValue(item.keyName) == item.targetValue)
+        //                {
+        //                    numCondOk++;
+        //                }
+        //            }
+        //        }
+        //        if (reqCondition.checkMode == boolCheckMode.AND)
+        //        {
+        //            answ = (numCond == numCondOk);
+        //        }
+        //        else if (reqCondition.checkMode == boolCheckMode.OR)
+        //        {
+        //            answ = numCondOk > 0;
+        //        }
+        //    }
+        //    else
+        //    {
+        //        answ = true;
+        //    }
+        //    // verifico se devo negare il valore...
+        //    answ = reqCondition.negateValue ? !answ : answ;
+        //    // restituisco
+        //    return answ;
+        //}
+
+        /// <summary>
+        /// Verifica / Salva valore e restitusice SE sia variato (e quindi da inviare...)
+        /// </summary>
+        /// <param name="dataItem"></param>
+        /// <param name="NotifyValue"></param>
+        /// <param name="sendItemList"></param>
+        /// <returns></returns>
+        protected bool checkSaveValue(Opc.Ua.Client.MonitoredItem dataItem, string NotifyValue, bool sendItemList)
+        {
+            bool answ = !enableDataFilter;
+            double oldVal = 0;
+            double newVal = 0;
+            if (dataItem != null)
+            {
+                if (!string.IsNullOrEmpty(NotifyValue))
+                {
+                    lgTrace($"Richiesta checkSaveValue per {dataItem.DisplayName} | id: {dataItem.StartNodeId} | Valore: {NotifyValue}");
+                    // verifico in memoria se ho l'oggetto condition ed il suo valore..
+                    string uuid = $"{dataItem.DisplayName}";
+                    DateTime adesso = DateTime.Now;
+                    if (dataItemMem.ContainsKey(uuid))
+                    {
+                        OpcUaDataItemExt currDataItemMem = dataItemMem[uuid];
+                        // controllo SE SIA scaduto il tempo massimo...
+                        if (Math.Abs(dataItemMem[uuid].valueTimestamp.Subtract(adesso).TotalSeconds) > currDataItemMem.samplePeriod)
+                        {
+                            answ = true;
+                        }
+                        else
+                        {
+                            // ALTRIMENTI controllo SE diverso
+                            if (dataItemMem[uuid].value != $"{NotifyValue}")
+                            {
+                                lgInfo($"Val uuid: {dataItemMem[uuid].value} | NotifyValue: {NotifyValue}");
+                                // controllo SE ho DeadBand...
+                                if (dataItemMem[uuid].thresholdDeadBand > 0)
+                                {
+                                    // recupero i valori e testo DeadBand...
+                                    bool isNum01 = double.TryParse(dataItemMem[uuid].value.Replace(".", ","), out oldVal);
+                                    bool isNum02 = double.TryParse($"{NotifyValue}".Replace(".", ","), out newVal);
+                                    // test deadband!
+                                    if (!(isNum01 && isNum02))
+                                    {
+                                        answ = true;
+                                    }
+                                    else
+                                    {
+                                        if (Math.Abs(newVal - oldVal) > dataItemMem[uuid].thresholdDeadBand)
+                                        {
+                                            // indico da salvare..
+                                            answ = true;
+                                        }
+                                    }
+                                    lgInfo($"Test deadband: oldVal: {oldVal} | newVal: {newVal}");
+                                }
+                            }
+                        }
+                        if (answ)
+                        {
+                            // salvo!
+                            dataItemMem[uuid].value = $"{NotifyValue}";
+                            dataItemMem[uuid].valueTimestamp = adesso;
+                        }
+                    }
+                    else
+                    {
+                        // registro non trovato da aggiungere...
+                        lgInfo($"DataItem non trovato in checkSaveValue: {dataItem.DisplayName}");
+                        // provo a creare oggetto in memoria...
+                        try
+                        {
+                            int dSamplePeriod = 0;
+                            int threshDBand = 0;
+                            uuid = "";
+                            var currDataItem = formatDataItem(ref dSamplePeriod, ref threshDBand, ref uuid, dataItem);
+                            // sistemo valore/periodo
+                            currDataItem.value = $"{NotifyValue}";
+                            currDataItem.valueTimestamp = adesso;
+                            // aggiungo
+                            dataItemMem.Add(uuid, currDataItem);
+                            if (sendItemList)
+                            {
+                                sendDataItemListToServer(dataItem.StartNodeId);
+                            }
+                        }
+                        catch (Exception exc)
+                        {
+                            lgError($"Eccezione in checkSaveSample{Environment.NewLine}{exc}");
+                        }
+                    }
+                }
+                else
+                {
+                    lgError("Attenzione: checkSaveItem con Notify null!");
+                }
+            }
+            else
+            {
+                lgError("Attenzione: checkSaveItem con MonIt null!");
+            }
+            return answ;
+        }
+
+        ///// <summary>
+        ///// Effettua decodifica aree memoria alla bitmap usata x MAPO
+        ///// </summary>
+        //protected virtual void decodeToBaseBitmap()
+        //{
+        //    DateTime adesso = DateTime.Now;
+        //    // init a zero...
+        //    B_input = 0;
+
+        //    /* -----------------------------------------------------
+        //     *  STATE MACHINE 60 STD / SIMULA
+        //     *------------------------------------------------------
+        //     * bitmap MAPO
+        //     * B0: POWER_ON
+        //     * B1: RUN
+        //     * B2: pzCount
+        //     * B3: allarme
+        //     * B4: manuale
+        //     * B5: SlowTC (NON gestito qui)
+        //     * B6: warm-up / cool-down
+        //     * B7: emergenza
+        //     ---------------------------------------------------- */
+
+        //    // se valido il check ping lo eseguo... altrimenti lo do x buono
+        //    bool checkPing = !opcUaParams.pingAsPowerOn;
+        //    string currRun = "";
+        //    if (!checkPing)
+        //    {
+        //        checkPing = (testPingMachine == IPStatus.Success);
+        //    }
+        //    // bit 0 (poweron) imposto a 1 SE pingo + PowerOn=="ON"...
+        //    bool powerOnOk = checkPing && hasPowerOn;
+
+        //    // controllo se sono poweroff e se non ho dati buoni da > lastCurrentMaxElapsed --> disconnetto
+        //    if (!powerOnOk && adesso.Subtract(lastCurrent).TotalSeconds > lastCurrentMaxElapsed)
+        //    {
+        //        tryDisconnect();
+        //    }
+
+        //    // solo se non ho veto check
+        //    int vFactor = 2;
+        //    if (vetoCheckStatus < adesso)
+        //    {
+        //        lgTrace($"Stato variabili checkPing: {testPingMachine}");
+        //        // imposto veto per vetoSeconds...
+        //        vetoCheckStatus = adesso.AddSeconds(vetoSeconds * vFactor);
+        //    }
+
+        //    // se abilitato watchdog...
+        //    if (opcUaParams.WatchDog.IsEnabled)
+        //    {
+        //        lgTrace("WatchDog 01");
+        //        if (adesso.Subtract(lastWatchDogPLC).TotalSeconds > 2)
+        //        {
+        //            lastWatchDogPLC = adesso;
+        //            WatchDog++;
+        //            WatchDog = WatchDog > opcUaParams.WatchDog.MaxVal ? 0 : WatchDog;
+
+        //            lgTrace($"WatchDog val: {WatchDog}");
+        //            try
+        //            {
+        //                WriteValue commWriteVal = new WriteValue();
+        //                commWriteVal.NodeId = new NodeId(opcUaParams.WatchDog.MemConfWrite);
+        //                commWriteVal.AttributeId = Attributes.Value;
+        //                commWriteVal.Value = new DataValue();
+        //                commWriteVal.Value.Value = WatchDog;
+
+        //                List<WriteValue> nodes2Write = new List<WriteValue>();
+        //                nodes2Write.Add(commWriteVal);
+        //                UA_ref.WriteNodes(nodes2Write);
+        //                lgTrace("Effettuata scrittura WatchDog");
+        //            }
+        //            catch (Exception exc)
+        //            {
+        //                lgError($"Eccezione in gestione WatchDog, valore attuale {WatchDog}{Environment.NewLine}{exc}");
+        //            }
+        //        }
+        //    }
+        //    else
+        //    {
+        //        lgTrace("WatchDog disabilitato");
+        //    }
+
+        //    // log opzionale!
+        //    if (verboseLog)
+        //    {
+        //        lgDebug($"Trasformazione checkPing: {checkPing} | hasPowerOn: {hasPowerOn} | B_input: {B_input} | currRun = {currRun}");
+        //    }
+        //}
+
+        protected byte[] getByteRaw(DataValue obj)
+        {
+            if (obj == null)
+                return null;
+
+            byte[] rawByte = new byte[1];
+            if (obj != null)
+            {
+                try
+                {
+                    var wrapVal = ((DataValue)obj).WrappedValue;
+                    //rawByte = ObjectToByteArray(rawVal);
+                    var bodyVal = ((Opc.Ua.ExtensionObject)wrapVal.Value).Body;
+                    rawByte = (byte[])bodyVal;
+                }
+                catch
+                { }
+            }
+            return rawByte;
+        }
+
+        /// <summary>
+        /// Effettua traduzione ITEM da LUT parametrica (key: tipo+id) del file di conf, se non
+        /// trovo uso key
+        /// </summary>
+        /// <param name="tipo"></param>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        protected string itemTranslation(string tipo, string id)
+        {
+            string answ = "";
+            string lemma = id;
+            if (!string.IsNullOrEmpty(tipo))
+            {
+                lemma = $"{tipo}_{id}";
+            }
+            // cerco nel dizionario delle traduzioni SE esiste un valore e prendo quello, altrimenti
+            // uso il lemma...
+            if (opcUaParams.itemTranslation.ContainsKey(lemma))
+            {
+                answ = opcUaParams.itemTranslation[lemma];
+            }
+            else
+            {
+                answ = lemma;
+            }
+            return answ;
+        }
+
+        /// <summary>
+        /// Effettua lettura file di conf specifico OPC-UA da oggetto serializzato json 
+        /// <paramref name="fileName">Nome file da cui leggere i parametri json</paramref>
+        /// </summary>
+        protected void loadOpcUaConf(string fileName)
+        {
+            string jsonFullPath = Path.Combine(configPath, fileName);
+            lgInfo($"Apertura file {jsonFullPath}");
+            using (StreamReader reader = new StreamReader(jsonFullPath))
+            {
+                string jsonData = reader.ReadToEnd().Replace("\n", "").Replace("\r", "");
+                if (!string.IsNullOrEmpty(jsonData))
+                {
+                    lgDebug($"File json composto da {jsonData.Length} caratteri");
+                    try
+                    {
+                        opcUaParams = JsonConvert.DeserializeObject<OpcUaParamConf>(jsonData);
+                        lgDebug($"Decodifica aree OpcUaParamConf: trovati {opcUaParams.paramsEndThresh.Count} valori paramsEndThresh");
+                        // sistemo se ci sono dati memMap...
+                        memMap = new plcMemMap();
+                        if (opcUaParams.mMapWrite != null)
+                        {
+                            memMap.mMapWrite = opcUaParams.mMapWrite;
+                        }
+                        if (opcUaParams.mMapRead != null)
+                        {
+                            memMap.mMapRead = opcUaParams.mMapRead;
+                        }
+                        setupMemMap();
+                    }
+                    catch (Exception exc)
+                    {
+                        lgError($"Eccezione in decodifica conf json OPC-UA:{Environment.NewLine}{exc}");
+                    }
+                }
+                else
+                {
+                    lgError("Errore in loadOpcUaConf: file json vuoto!");
+                }
+            }
+        }
+
+        //#endregion Protected Methods
+
+        //#region Private Fields
+
+        /// <summary>
+        /// Elenco degli items da monitorare come risultato del browse iniziale
+        /// </summary>
+        private Dictionary<string, string> selectedItemList = new Dictionary<string, string>();
+
+        //#endregion Private Fields
+
+        //#region Private Methods
+
+        /// <summary>
+        /// Vera connessione ad OpcUa
+        /// </summary>
+        /// <returns></returns>
+        private async Task<short> doConnect()
+        {
+            short esitoLink = 0;
+            // reset memoria dataItem..
+            dataItemMem = new Dictionary<string, OpcUaDataItemExt>();
+            // ora avvio
+            try
+            {
+                lgInfo("Start init OpcUa Client");
+                // Define the UA Client application
+                ApplicationInstance application = new ApplicationInstance();
+                application.ApplicationName = "EgalWare MP.MONO Adapter Client";
+                application.ApplicationType = ApplicationType.Client;
+
+                // load the application configuration.
+                string confPath = Path.Combine(Directory.GetCurrentDirectory(), "CONF","MpMonoAdapterClient.Config.xml");
+                await application.LoadApplicationConfiguration(confPath, silent: false).ConfigureAwait(false);
+                // check the application certificate.
+                await application.CheckApplicationInstanceCertificate(silent: false, minimumKeySize: 0).ConfigureAwait(false);
+
+                lgInfo($"New UAClient stasrted with std config: {application.ApplicationConfiguration.ApplicationName}");
+                UA_ref = new UAClient(application.ApplicationConfiguration, opcUaParams.Identity.UserName, opcUaParams.Identity.Passwd, ClientBase.ValidateResponse);
+
+                lgInfo($"Call to OpcUa Server at address: opc.tcp://{cIobConf.IpAddress}:{cIobConf.Port}");
+                UA_ref.ServerUrl = $"opc.tcp://{cIobConf.IpAddress}:{cIobConf.Port}";
+
+                var task = Task.Run(async () =>
+                {
+                    return await UA_ref.ConnectAsync().ConfigureAwait(false);
+                });
+                bool connected = task.Result;
+                if (connected)
+                {
+                    // faccio un primo browse dei dati...
+                    Dictionary<string, string> nodeIdNameList = new Dictionary<string, string>();
+                    if (!string.IsNullOrEmpty(opcUaParams.BrowseFullVal))
+                    {
+                        try
+                        {
+                            UA_ref.Browse(opcUaParams.BrowseFullVal, opcUaParams.filterItemsNodeId, ref nodeIdNameList);
+                        }
+                        catch
+                        { }
+                    }
+                    else
+                    {
+                        UA_ref.Browse(opcUaParams.BrowseNSIndex, opcUaParams.BrowseValue, opcUaParams.filterItemsNodeId, ref nodeIdNameList);
+                    }
+                    // loggo elenco degli item sottocrivibili...
+                    lgDebug("---------- AVAILABLE FOR SUBSCRIBE ----------");
+                    foreach (var item in nodeIdNameList)
+                    {
+                        lgDebug(item.Key);
+                    }
+                    lgDebug("---------- END LIST ----------");
+
+                    // se ho un insieme non vuoto degli item sottoscritti carico solo quelli
+                    if (opcUaParams.subscribedItems != null && opcUaParams.subscribedItems.Count > 0)
+                    {
+                        // cerco e aggiungo SOLO quelle indicati
+                        foreach (var currItem in opcUaParams.subscribedItems)
+                        {
+                            var foundItems = nodeIdNameList.Where(x => x.Key.Contains(currItem)).ToList();
+                            if (foundItems != null && foundItems.Count > 0)
+                            {
+                                foreach (var fItem in foundItems)
+                                {
+                                    // verifico di NON duplicare...
+                                    if (!selectedItemList.ContainsKey(fItem.Key))
+                                    {
+                                        selectedItemList.Add(fItem.Key, fItem.Value);
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                lgDebug($"subscribedItems non trovato: {currItem}");
+                            }
+                        }
+                        lgDebug($"Aggiunti {selectedItemList.Count} items!");
+                    }
+                    // altrimenti tutti!
+                    else
+                    {
+                        selectedItemList = nodeIdNameList;
+                    }
+
+                    // loggo elenco degli item sottocrivibili...
+                    lgInfo("---------- SUBSCRIBED NODES ----------");
+                    foreach (var item in selectedItemList)
+                    {
+                        lgInfo(item.Key);
+                    }
+                    lgInfo("---------- END LIST ----------");
+
+                    // sottoscrivo a rilevazione cambio dati solo l'incrocio degli insiemi
+                    List<Opc.Ua.Client.MonitoredItem> subscribedItems = UA_ref.SubscribeToDataChanges(selectedItemList);
+                    // aggiungo come DataItems
+                    int dSamplePeriod = 0;
+                    int threshDBand = 0;
+                    string uuid = "";
+                    foreach (var item in subscribedItems)
+                    {
+                        bool changed = false;
+                        OpcUaDataItemExt newItem = formatDataItem(ref dSamplePeriod, ref threshDBand, ref uuid, item);
+                        // controllo non sia già stato aggiunto
+                        if (dataItemMem.ContainsKey(uuid))
+                        {
+                            lgDebug($"Item ALREADY subscribed: {uuid} | NOT re-adding");
+                        }
+                        else
+                        {
+                            dataItemMem.Add(uuid, newItem);
+                            lgDebug($"Item subscribed: {uuid}");
+                            // verifico se ho i dati complessi by design
+                            string currVal = "";
+                            if (doByteRead)
+                            {
+                                // restituisce i 115 byte da deserializzare... qui HACK!
+                                var rawVal = UA_ref.ReadNodeRaw(item.StartNodeId);
+                                if (rawVal != null)
+                                {
+                                    byteRawData = getByteRaw((DataValue)rawVal);
+                                    changed = checkAndSendRaw(item, byteRawData, true);
+                                }
+                            }
+                            else
+                            {
+                                currVal = UA_ref.ReadNode(item.StartNodeId);
+                                changed = checkAndSend(item, currVal, true);
+                            }
+                        }
+                    }
+                    // gestione eventi change
+                    UA_ref.eh_MonItChange += UA_ref_eh_MonItChange;
+                    lgInfo("eh_MonItChange event registered");
+                }
+
+                esitoLink = 1;
+
+                // fix tempi!
+                DateTime adesso = DateTime.Now;
+                lastCurrent = adesso;
+            }
+            catch (Exception exc)
+            {
+                lgError($"Eccezione in doConnect{Environment.NewLine}{exc}");
+            }
+            return esitoLink;
+        }
+
+        /// <summary>
+        /// Formatta un dataitem x salvataggio in memoria locale
+        /// </summary>
+        /// <param name="dSamplePeriod"></param>
+        /// <param name="threshDBand"></param>
+        /// <param name="uuid"></param>
+        /// <param name="dataItem"></param>
+        /// <returns></returns>
+        private OpcUaDataItemExt formatDataItem(ref int dSamplePeriod, ref int threshDBand, ref string uuid, Opc.Ua.Client.MonitoredItem dataItem)
+        {
+            OpcUaDataItemExt currDataItem;
+            // calcolo parametri
+            uuid = $"{dataItem.DisplayName}";
+            // SOLO SE è abilitato il datafiltering...
+            if (enableDataFilter)
+            {
+                threshDBand = 1;
+                // controllo SE ho conf x deadband...
+                if (opcUaParams.paramsEndThresh.Count > 0)
+                {
+                    // ciclo su tutti i parametri indicati...
+                    foreach (var item in opcUaParams.paramsEndThresh)
+                    {
+                        if (uuid.EndsWith(item.Key))
+                        {
+                            threshDBand = item.Value;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                threshDBand = 0;
+            }
+            dSamplePeriod = 60;
+
+            // salvo oggetto x "uso interno"
+            currDataItem = new OpcUaDataItemExt(dataItem)
+            {
+                uid = uuid,
+                thresholdDeadBand = threshDBand,
+                samplePeriod = dSamplePeriod
+            };
+
+            return currDataItem;
+        }
+
+        /// <summary>
+        /// Effettua invio a MP/IO dell'elenco serializzato dei dataItems
+        /// </summary>
+        /// <param name="dataItems"></param>
+        private void sendDataItemsList(List<MachDataItem> dataItems)
+        {
+            // fixme todo fare !!!
+            // da eliminare che forse avanza?
+#if false
+            string rawData = JsonConvert.SerializeObject(dataItems);
+            try
+            {
+                utils.callUrlNow($"{urlSaveDataItems}", rawData);
+                lgInfo($"Effettuata chiamata sendDataItemsList all'url {urlSaveDataItems}");
+            }
+            catch (Exception exc)
+            {
+                lgError($"Eccezione in sendDataItemsList{Environment.NewLine} - url: {urlSaveDataItems}{Environment.NewLine}- payload:{rawData}{Environment.NewLine}Eccezione:{Environment.NewLine}{exc}");
+            } 
+#endif
+        }
+
+        //#endregion Private Methods
+
+    }
+}
diff --git a/MP.MONO.ADAPTER.OPC/MP.MONO.ADAPTER.OPC.csproj b/MP.MONO.ADAPTER.OPC/MP.MONO.ADAPTER.OPC.csproj
index b4a2e95..c9139d8 100644
--- a/MP.MONO.ADAPTER.OPC/MP.MONO.ADAPTER.OPC.csproj
+++ b/MP.MONO.ADAPTER.OPC/MP.MONO.ADAPTER.OPC.csproj
@@ -7,13 +7,23 @@
     <PackageId>MP.MONO.ADAPTER.OPC</PackageId>
     <Company>EgalWare</Company>
     <Description>OPC UA Console Client</Description>
-    <Copyright>Copyright © 2020+ EgalWare</Copyright>
+    <Copyright>Copyright � 2020+ EgalWare</Copyright>
     <RootNamespace>MP.MONO.ADAPTER.OPC</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Remove="UAClient.old.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
     <PackageReference Include="Mono.Options" Version="6.12.0.148" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="OPCFoundation.NetStandard.Opc.Ua.Client" Version="1.4.368.58" />
     <PackageReference Include="OPCFoundation.NetStandard.Opc.Ua.Configuration" Version="1.4.368.58" />
     <PackageReference Include="OPCFoundation.NetStandard.Opc.Ua.Core" Version="1.4.368.58" />
@@ -24,9 +34,20 @@
     <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
     <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />
     <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
+    <PackageReference Include="StackExchange.Redis" Version="2.5.61" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MP.MONO.Core\MP.MONO.Core.csproj" />
   </ItemGroup>
 <ItemGroup>
-  <None Update="Quickstarts.ReferenceClient.Config.xml">
+  <None Update="appsettings.json">
+    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+  </None>
+  <None Update="CONF\MpMonoAdapterClient.Config.xml">
+    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+  </None>
+  <None Update="CONF\Multiax.json">
     <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
   </None>
 </ItemGroup>
diff --git a/MP.MONO.ADAPTER.OPC/OpcUaDataItemExt.cs b/MP.MONO.ADAPTER.OPC/OpcUaDataItemExt.cs
new file mode 100644
index 0000000..0f04617
--- /dev/null
+++ b/MP.MONO.ADAPTER.OPC/OpcUaDataItemExt.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MP.MONO.ADAPTER.OPC
+{
+    /// <summary>
+    /// Classe di estensione x oggetti DataItems OPC-UA con struttura e valori
+    /// </summary>
+    public class OpcUaDataItemExt : Opc.Ua.Client.MonitoredItem
+    {
+        #region Public Constructors
+
+        public OpcUaDataItemExt(Opc.Ua.Client.MonitoredItem MonIt)
+        {
+            if (MonIt != null)
+            {
+                AttributeId = MonIt.AttributeId;
+                CacheQueueSize = MonIt.CacheQueueSize;
+                Handle = MonIt.Handle;
+                DiscardOldest = MonIt.DiscardOldest;
+                DisplayName = MonIt.DisplayName;
+                Encoding = MonIt.Encoding;
+                Filter = MonIt.Filter;
+                IndexRange = MonIt.IndexRange;
+                MonitoringMode = MonIt.MonitoringMode;
+                NodeClass = MonIt.NodeClass;
+                QueueSize = MonIt.QueueSize;
+                RelativePath = MonIt.RelativePath;
+                SamplingInterval = MonIt.SamplingInterval;
+                StartNodeId = MonIt.StartNodeId;
+            }
+        }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// NodeId univoco dell'oggetto x subscription (StartNodeId)
+        /// </summary>
+        public string nodeId { get; set; } = "";
+
+        /// <summary>
+        /// Valore (in sec) del periodo di downsampling (0 --> NON usato)
+        /// </summary>
+        public int samplePeriod { get; set; } = 60;
+
+        /// <summary>
+        /// Valore soglia DeadBand (0 --> non usata)
+        /// </summary>
+        public double thresholdDeadBand { get; set; } = 0;
+
+        /// <summary>
+        /// UUID univoco dell'oggetto --> flusso (DisplayName)
+        /// </summary>
+        public string uid { get; set; } = "";
+
+        /// <summary>
+        /// Valore Registrato in formato stringa
+        /// </summary>
+        public string value { get; set; } = "";
+
+        /// <summary>
+        /// Valore Registrato in formato byte array
+        /// </summary>
+        public byte[] rawByte { get; set; } = new byte[1];
+
+        /// <summary>
+        /// Timestamp data-ora evento registrato
+        /// </summary>
+        public DateTime valueTimestamp { get; set; } = DateTime.Now;
+
+        #endregion Public Properties
+    }
+}
diff --git a/MP.MONO.ADAPTER.OPC/Program.cs b/MP.MONO.ADAPTER.OPC/Program.cs
index a949e0d..239afa5 100644
--- a/MP.MONO.ADAPTER.OPC/Program.cs
+++ b/MP.MONO.ADAPTER.OPC/Program.cs
@@ -1,32 +1,3 @@
-/* ========================================================================
- * Copyright (c) 2005-2021 The OPC Foundation, Inc. All rights reserved.
- *
- * OPC Foundation MIT License 1.00
- * 
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * The complete license agreement can be found here:
- * http://opcfoundation.org/License/MIT/1.00/
- * ======================================================================*/
-
 using System;
 using System.Globalization;
 using System.IO;
@@ -35,6 +6,15 @@ using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Opc.Ua;
 using Opc.Ua.Configuration;
+using Microsoft.Extensions.Configuration;
+using MP.MONO.ADAPTER;
+using MP.MONO.Core;
+using MP.MONO.Core.CONF;
+using MP.MONO.Core.DTO;
+using Newtonsoft.Json;
+using NLog;
+using StackExchange.Redis;
+using System.Collections.Generic;
 
 namespace MP.MONO.ADAPTER.OPC
 {
@@ -43,22 +23,85 @@ namespace MP.MONO.ADAPTER.OPC
     /// </summary>
     public static class Program
     {
+        private static string redisConf = "";
+        private static string confPath = "";
+        private static string lineSep = "---------------------------------------------";
+        private static Logger Log = LogManager.GetCurrentClassLogger();
+        private static bool verboseLog = false;
+        private static bool logWriting = false;
+
+        /// <summary>
+        /// Redis channel manager
+        /// </summary>
+        private static ISubscriber sub { get; set; }
+
+        /// <summary>
+        /// Redis DB
+        /// </summary>
+        private static IDatabase? redisDb { get; set; }
+
+        private static Dictionary<string, int> LogSimulator = new Dictionary<string, int>();
+        private static Dictionary<string, DateTime> LastSend = new Dictionary<string, DateTime>();
+        private static DateTime lastLog = DateTime.Now.AddMinutes(-1);
+
         /// <summary>
         /// Main entry point.
         /// </summary>
         public static async Task Main(string[] args)
         {
             TextWriter output = Console.Out;
-            output.WriteLine("OPC UA Console Reference Client");
+            output.WriteLine("Egalware | MP.MONO.ADAPTER | OPC UA Console Client");
 
             output.WriteLine("OPC UA library: {0} @ {1} -- {2}",
                 Utils.GetAssemblyBuildNumber(),
                 Utils.GetAssemblyTimestamp().ToString("G", CultureInfo.InvariantCulture),
                 Utils.GetAssemblySoftwareVersion());
 
+
+            // init parte config, vedere https://blog.hildenco.com/2020/05/configuration-in-net-core-console.html
+            var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+            var builder = new ConfigurationBuilder()
+                .AddJsonFile($"appsettings.json", true, true)
+                .AddJsonFile($"appsettings.{env}.json", true, true)
+                .AddEnvironmentVariables();
+            var config = builder.Build();
+
+            // imposto variabili di base
+            redisConf = config.GetConnectionString("Redis");
+            confPath = Path.Combine(Directory.GetCurrentDirectory(), "conf");
+            Random rand = new Random();
+            List<MachineStatus>? statusList = new List<MachineStatus>();
+            List<MachineMode>? modeList = new List<MachineMode>();
+
+            // fix numero minimo dei thread pool x evitare collasso chiamate redis
+            ThreadPool.SetMinThreads(10, 10);
+
+
+
+            logInfo(lineSep, true, true);
+            logInfo($"Starting Machine ADAPTER", true, true);
+            logInfo($"Redis server param: {redisConf.Substring(0, 20)}...", false, true);
+            logInfo(lineSep, true, true);
+            logInfo("", true, true);
+
+            // Setup REDIS
+            ConnectionMultiplexer.SetFeatureFlag("preventthreadtheft", true);
+            ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(redisConf);
+            sub = redis.GetSubscriber();
+            redisDb = redis.GetDatabase();
+
+            // salvo configurazioni in redis
+            setupConf();
+
+            // avvio il vero e proprio programma di comunicaizone OPC-UA
+            var currIob = new IobOpcUa(confPath, config);
+
+            logInfo($"Started IOB at path {confPath}", true, true);
+
+#if false
             // The application name and config file names
-            var applicationName = "ConsoleReferenceClient";
-            var configSectionName = "Quickstarts.ReferenceClient";
+            var applicationName = "MP.MONO.ADAPTER.OPC";
+            var configSectionName = "MpMonoAdapterOpc";
             var usage = $"Usage: dotnet {applicationName}.dll [OPTIONS]";
 
             // command line options
@@ -102,7 +145,8 @@ namespace MP.MONO.ADAPTER.OPC
                 // Define the UA Client application
                 ApplicationInstance.MessageDlg = new ApplicationMessageDlg(output);
                 CertificatePasswordProvider PasswordProvider = new CertificatePasswordProvider(password);
-                ApplicationInstance application = new ApplicationInstance {
+                ApplicationInstance application = new ApplicationInstance
+                {
                     ApplicationName = applicationName,
                     ApplicationType = ApplicationType.Client,
                     ConfigSectionName = configSectionName,
@@ -113,7 +157,7 @@ namespace MP.MONO.ADAPTER.OPC
                 var config = await application.LoadApplicationConfiguration(silent: false);
 
                 // setup the logging
-                ConsoleUtils.ConfigureLogging(config, applicationName, logConsole, LogLevel.Information);
+                ConsoleUtils.ConfigureLogging(config, applicationName, logConsole, Microsoft.Extensions.Logging.LogLevel.Information);
 
                 // delete old certificate
                 if (renewCertificate)
@@ -147,7 +191,8 @@ namespace MP.MONO.ADAPTER.OPC
                     }
 
                     // create the UA Client object and connect to configured server.
-                    UAClient uaClient = new UAClient(application.ApplicationConfiguration, output, ClientBase.ValidateResponse) {
+                    UAClient uaClient = new UAClient(application.ApplicationConfiguration, output, ClientBase.ValidateResponse)
+                    {
                         AutoAccept = autoAccept
                     };
 
@@ -180,6 +225,208 @@ namespace MP.MONO.ADAPTER.OPC
             catch (Exception ex)
             {
                 output.WriteLine(ex.Message);
+            } 
+#endif
+
+            logInfo("Running - press CTRL-C to stop ADAPTER", false, true);
+            logInfo("", false, true);
+            // Ciclo infinito x attesa chiusura con CTRL-C
+            do
+            {
+                // se non fosse connesso... riprovo la connessione...
+                if (!currIob.connectionOk)
+                {
+                    currIob.tryConnect();
+                }
+                // attesa...
+                Thread.Sleep(100);
+            } while (true);
+
+        }
+
+        /// <summary>
+        /// verifica esistenza file oppure lo crea...
+        /// </summary>
+        private static void checkFilePresent(string filePath)
+        {
+            // verific presenza file log...
+            if (!File.Exists(filePath))
+            {
+                File.WriteAllText(filePath, $"{filePath} created!");
+            }
+        }
+
+        /// <summary>
+        /// Setup e salvataggio redis delle conf (es modi/stati)
+        /// </summary>
+        private static void setupConf()
+        {
+#if false
+    // leggo e salvo conf stati
+    string fullPath = Path.Combine(confPath, "StatusList.json");
+    if (File.Exists(fullPath))
+    {
+        var rawData = File.ReadAllText(fullPath);
+        if (!string.IsNullOrEmpty(rawData))
+        {
+            List<MachineStatus>? statusList = JsonConvert.DeserializeObject<List<MachineStatus>>(rawData);
+            // salvo in redis!
+            redisDb.StringSetAsync(Constants.STATUS_CONF_KEY, JsonConvert.SerializeObject(statusList));
+        }
+    }
+
+    // leggo e salvo conf modi
+    fullPath = Path.Combine(confPath, "ModeList.json");
+    if (File.Exists(fullPath))
+    {
+        var rawData = File.ReadAllText(fullPath);
+        if (!string.IsNullOrEmpty(rawData))
+        {
+            var localObj = JsonConvert.DeserializeObject<List<MachineMode>>(rawData);
+            // salvo in redis!
+            redisDb.StringSetAsync(Constants.MODE_CONF_KEY, JsonConvert.SerializeObject(localObj));
+        }
+    }
+
+    // leggo e salvo conf allarmi
+    fullPath = Path.Combine(confPath, "AlarmList.json");
+    if (File.Exists(fullPath))
+    {
+        var rawData = File.ReadAllText(fullPath);
+        if (!string.IsNullOrEmpty(rawData))
+        {
+            var localObj = JsonConvert.DeserializeObject<List<BaseAlarmConf>>(rawData);
+            if (localObj != null)
+            {
+                // sistemo allarmi
+                foreach (var item in localObj)
+                {
+                    item.setupData();
+                    // loggo
+                    logInfo($"Decodifica aree alarmMap: {item.description} | {item.memAddr} x {item.size} byte | {item.messages.Count} messaggi allarme", true, true);
+                }
+            }
+            // salvo in redis!
+            redisDb.StringSetAsync(Constants.ALARMS_CONF_KEY, JsonConvert.SerializeObject(localObj));
+        }
+    }
+
+    // leggo e salvo conf parametri
+    fullPath = Path.Combine(confPath, "ParamList.json");
+    if (File.Exists(fullPath))
+    {
+        var rawData = File.ReadAllText(fullPath);
+        if (!string.IsNullOrEmpty(rawData))
+        {
+            var localObj = JsonConvert.DeserializeObject<List<DisplayDataDTO>>(rawData);
+            // salvo in redis!
+            redisDb.StringSetAsync(Constants.PARAMS_CONF_KEY, JsonConvert.SerializeObject(localObj));
+        }
+    } 
+#endif
+
+            ConfigManager configManager = new ConfigManager(redisConf, confPath);
+            _ = configManager.getAlarmsConf();
+            _ = configManager.getMachineModeConf();
+            _ = configManager.getMachineStatusConf();
+            _ = configManager.getParamsConf();
+        }
+
+        /// <summary>
+        /// Effettua log INFO su file e se richiesto su console
+        /// </summary>
+        private static void logInfo(string msg, bool log2file = true, bool log2console = false)
+        {
+            if (log2console)
+            {
+                Console.WriteLine(msg);
+            }
+            if (log2file)
+            {
+                Log.Info(msg);
+            }
+        }
+        /// <summary>
+        /// Effettua log ERROR su file e se richiesto su console
+        /// </summary>
+        private static void logError(string msg, bool log2file = true, bool log2console = false)
+        {
+            if (log2console)
+            {
+                Console.WriteLine(msg);
+            }
+            if (log2file)
+            {
+                Log.Error(msg);
+            }
+        }
+
+        private static void saveAndSendMessage(string memKey, string value, string notifyChannel, string message)
+        {
+            // effettuo la scrittura nell'area di memoria indicata SE passato intervallo minimo
+            bool doSend = true;
+            if (LastSend.ContainsKey(memKey))
+            {
+                if (DateTime.Now.Subtract(LastSend[memKey]).TotalSeconds < 60)
+                {
+                    doSend = false;
+                }
+            }
+            else
+            {
+                LastSend.Add(memKey, DateTime.Now);
+            }
+            if (doSend)
+            {
+                redisDb.StringSetAsync(memKey, value);
+                LastSend[memKey] = DateTime.Now;
+                logInfo($"Redis Cache Key: {memKey}");
+            }
+            //redisDb.SetAdd(memKey, value);
+
+            // invio notifica tramite il canale richiesto
+            sub.Publish(notifyChannel, message);
+            if (verboseLog)
+            {
+                logInfo($"[{notifyChannel}] key: {memKey} | val: {value} | message: {message}");
+            }
+            else
+            {
+                try
+                {
+                    if (!logWriting)
+                    {
+                        if (LogSimulator.ContainsKey(notifyChannel))
+                        {
+                            LogSimulator[notifyChannel]++;
+                        }
+                        else
+                        {
+                            LogSimulator.Add(notifyChannel, 1);
+                        }
+                        logWriting = true;
+                        // vedo se loggare...
+                        DateTime adesso = DateTime.Now;
+                        if (adesso.Subtract(lastLog).TotalSeconds > 15)
+                        {
+                            lastLog = adesso;
+                            logInfo(lineSep);
+
+                            // lavoro su copia...
+                            var LogSimulatorCopy = new Dictionary<string, int>(LogSimulator);
+                            foreach (var item in LogSimulatorCopy)
+                            {
+                                logInfo($"Redis mQueue {item.Key,-20}{item.Value,12}");
+                            }
+                            logInfo(lineSep);
+                        }
+                        logWriting = false;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    logError($"ERROR{Environment.NewLine}{ex}");
+                }
             }
         }
     }
diff --git a/MP.MONO.ADAPTER.OPC/UAClient.cs b/MP.MONO.ADAPTER.OPC/UAClient.cs
index 3b815f5..d43ac4e 100644
--- a/MP.MONO.ADAPTER.OPC/UAClient.cs
+++ b/MP.MONO.ADAPTER.OPC/UAClient.cs
@@ -1,93 +1,315 @@
-/* ========================================================================
- * Copyright (c) 2005-2020 The OPC Foundation, Inc. All rights reserved.
- *
- * OPC Foundation MIT License 1.00
- * 
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * The complete license agreement can be found here:
- * http://opcfoundation.org/License/MIT/1.00/
- * ======================================================================*/
-
+using NLog;
+using Opc.Ua;
+using Opc.Ua.Client;
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.IO;
 using System.Threading.Tasks;
-using Opc.Ua;
-using Opc.Ua.Client;
 
 namespace MP.MONO.ADAPTER.OPC
 {
+    /// <summary>
+    /// Evento per incapsulare dati x refresh pagina
+    /// </summary>
+    public class opcUaMonitItemChange : EventArgs
+    {
+        #region Public Constructors
+
+        /// <summary>
+        /// salvataggio obj
+        /// </summary>
+        /// <param name="newObject"></param>
+        public opcUaMonitItemChange(MonitoredItem monitoredItem, MonitoredItemNotification notification)
+        {
+            _monitoredItem = monitoredItem;
+            _notification = notification;
+        }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// Proprietà lettura del MonitoredItem
+        /// </summary>
+        public MonitoredItem CurrMonitoredItem
+        {
+            get { return _monitoredItem; }
+        }
+
+        /// <summary>
+        /// Proprietà lettura della notifica
+        /// </summary>
+        public MonitoredItemNotification CurrNotify
+        {
+            get { return _notification; }
+        }
+
+        #endregion Public Properties
+
+        #region Private Fields
+
+        /// <summary>
+        /// Monitored Item da notificare
+        /// </summary>
+        private readonly MonitoredItem _monitoredItem;
+
+        /// <summary>
+        /// Valore notifica
+        /// </summary>
+        private readonly MonitoredItemNotification _notification;
+
+        #endregion Private Fields
+    }
+
     /// <summary>
     /// OPC UA Client with examples of basic functionality.
     /// </summary>
-    class UAClient
+    public class UAClient
     {
-        #region Constructors
+        #region Public Constructors
+
         /// <summary>
         /// Initializes a new instance of the UAClient class.
         /// </summary>
-        public UAClient(ApplicationConfiguration configuration, TextWriter writer, Action<IList, IList> validateResponse)
+        public UAClient(ApplicationConfiguration configuration, string user, string pwd, Action<IList, IList> validateResponse)
         {
             m_validateResponse = validateResponse;
-            m_output = writer;
+            lg = LogManager.GetCurrentClassLogger();
+            if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(pwd))
+            {
+                CurrUserIdentity = new UserIdentity(user, pwd);
+            }
+            else
+            {
+                CurrUserIdentity = new UserIdentity();
+            }
             m_configuration = configuration;
             m_configuration.CertificateValidator.CertificateValidation += CertificateValidation;
         }
-        #endregion
+
+        #endregion Public Constructors
+
+        #region Public Events
+
+        /// <summary>
+        /// Evento notifica variazione MonitoredItem
+        /// </summary>
+        public event EventHandler<opcUaMonitItemChange> eh_MonItChange;
+
+        #endregion Public Events
 
         #region Public Properties
+
+        /// <summary>
+        /// The user identity to use when creating the session.
+        /// </summary>
+        public IUserIdentity CurrUserIdentity { get; set; } = new UserIdentity();
+
+        /// <summary>
+        /// Gets or sets the server URL.
+        /// </summary>
+        public string ServerUrl { get; set; } = "opc.tcp://localhost:4840";
+
         /// <summary>
         /// Gets the client session.
         /// </summary>
         public Session Session => m_session;
 
-        /// <summary>
-        /// Auto accept untrusted certificates.
-        /// </summary>
-        public bool AutoAccept { get; set; } = false;
-        #endregion
+        #endregion Public Properties
 
         #region Public Methods
+
+        /// <summary>
+        /// Browse Server nodes
+        /// </summary>
+        public bool Browse(ushort startNodeNS, uint startNodeVal, List<string> vetoBrowse, ref Dictionary<string, string> nodeIdNameList)
+        {
+            bool fatto = false;
+            if (m_session == null || m_session.Connected == false)
+            {
+                lg.Error("Session not connected!");
+                return false;
+            }
+
+            try
+            {
+                // Create a Browser object
+                Browser browser = new Browser(m_session);
+
+                // Set browse parameters
+                browser.BrowseDirection = BrowseDirection.Forward;
+                browser.NodeClassMask = (int)NodeClass.Object | (int)NodeClass.Variable;
+                browser.ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences;
+
+                //NodeId nodeToBrowse = ObjectIds.Server;
+                //NodeId nodeToBrowse = new NodeId("ns=4,i=5001");
+                NodeId nodeToBrowse = new NodeId(startNodeVal, startNodeNS);
+
+                // Call Browse service
+                lg.Trace($"Browsing {nodeToBrowse} node...");
+                ReferenceDescriptionCollection browseResults = browser.Browse(nodeToBrowse);
+
+                // Display the results
+                lg.Trace($"Browse returned {browseResults.Count} results:");
+
+                foreach (ReferenceDescription result in browseResults)
+                {
+                    lg.Trace($"     NodeId = {result.NodeId}, TypeId = {result.TypeId}, DisplayName = {result.DisplayName.Text}, NodeClass = {result.NodeClass}, Others:  {result.BinaryEncodingId} | {result.BrowseName}");
+                    // se NON fa parte dell'elenco dei VETO di filterItems...
+                    if (!vetoBrowse.Contains($"{result.NodeId}"))
+                    {
+                        // se mancasse aggiungo...
+                        if (!nodeIdNameList.ContainsKey($"{result.NodeId}"))
+                        {
+                            nodeIdNameList.Add(result.NodeId.ToString(), result.DisplayName.Text);
+                        }
+                    }
+                }
+                fatto = true;
+            }
+            catch (Exception ex)
+            {
+                // Log Error
+                lg.Error($"Browse Error : {ex.Message}");
+            }
+
+            return fatto;
+        }
+
+        /// <summary>
+        /// Browse Server nodes
+        /// </summary>
+        public bool Browse(string browsePath, List<string> vetoBrowse, ref Dictionary<string, string> nodeIdNameList)
+        {
+            bool fatto = false;
+            if (m_session == null || m_session.Connected == false)
+            {
+                lg.Error("Session not connected!");
+                return false;
+            }
+
+            try
+            {
+                // Create a Browser object
+                Browser browser = new Browser(m_session);
+
+                // Set browse parameters
+                browser.BrowseDirection = BrowseDirection.Forward;
+                browser.NodeClassMask = (int)NodeClass.Object | (int)NodeClass.Variable;
+                browser.ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences;
+
+                //NodeId nodeToBrowse = ObjectIds.Server;
+                //NodeId nodeToBrowse = new NodeId("ns=4;i=5001");
+                NodeId nodeToBrowse = new NodeId(browsePath);
+                //nodeToBrowse = ObjectIds.Server;
+                //nodeToBrowse = new NodeId("Calibratrice_L1", 4);
+                //nodeToBrowse = new NodeId("Dati_Mes", 4);
+                //nodeToBrowse = new NodeId(5001, 2);
+                //nodeToBrowse = new NodeId("ns=4;s=NxController");
+                //nodeToBrowse = new NodeId("ns=4;s=Dati_Mes");
+                //nodeToBrowse = new NodeId("NxController.GlobalVars", 4);
+                //nodeToBrowse = new NodeId("Dati_Mes", 4);
+
+                // Call Browse service
+                lg.Trace($"Browsing {nodeToBrowse} node...");
+                ReferenceDescriptionCollection browseResults = browser.Browse(nodeToBrowse);
+
+                // Display the results
+                lg.Trace($"Browse returned {browseResults.Count} results:");
+
+                foreach (ReferenceDescription result in browseResults)
+                {
+                    // se veto --> loggo veto
+                    if (vetoBrowse.Contains($"{result.NodeId}"))
+                    {
+                        lg.Trace($"| FILTERED -->  NodeId = {result.NodeId}, DisplayName = {result.DisplayName.Text}, NodeClass = {result.NodeClass}, Others:  {result.BinaryEncodingId} | {result.BrowseName}");
+                    }
+                    // se NON fa parte dell'elenco dei VETO di filterItems...
+                    else
+                    {
+                        lg.Trace($"     NodeId = {result.NodeId}, DisplayName = {result.DisplayName.Text}, NodeClass = {result.NodeClass}, Others:  {result.BinaryEncodingId} | {result.BrowseName}");
+                        // se mancasse aggiungo...
+                        if (!nodeIdNameList.ContainsKey($"{result.NodeId}"))
+                        {
+                            nodeIdNameList.Add($"{result.NodeId}", result.DisplayName.Text);
+                            // se è un nodo object --> faccio sub browse!
+                            if (result.NodeClass != NodeClass.Variable)
+                            {
+                                this.Browse($"{result.NodeId}", vetoBrowse, ref nodeIdNameList);
+                            }
+                        }
+                    }
+                }
+                fatto = true;
+            }
+            catch (Exception ex)
+            {
+                // Log Error
+                lg.Error($"Browse Error : {ex.Message}");
+            }
+
+            return fatto;
+        }
+
+        /// <summary>
+        /// Call UA method
+        /// </summary>
+        public void CallMethod()
+        {
+            if (m_session == null || m_session.Connected == false)
+            {
+                lg.Error("Session not connected!");
+                return;
+            }
+
+            try
+            {
+                // Define the UA Method to call Parent node - Objects\CTT\Methods Method node - Objects\CTT\Methods\Add
+                NodeId objectId = new NodeId("ns=2;s=Methods");
+                NodeId methodId = new NodeId("ns=2;s=Methods_Add");
+
+                // Define the method parameters Input argument requires a Float and an UInt32 value
+                object[] inputArguments = new object[] { (float)10.5, (uint)10 };
+                IList<object> outputArguments = null;
+
+                // Invoke Call service
+                lg.Debug($"Calling UAMethod for node {methodId} ...");
+                outputArguments = m_session.Call(objectId, methodId, inputArguments);
+
+                // Display results
+                lg.Debug($"Method call returned {outputArguments.Count} output argument(s):");
+
+                foreach (var outputArgument in outputArguments)
+                {
+                    lg.Debug($"     OutputValue = {outputArgument}");
+                }
+            }
+            catch (Exception ex)
+            {
+                lg.Error($"Method call error: {ex.Message}");
+            }
+        }
+
         /// <summary>
         /// Creates a session with the UA server
         /// </summary>
-        public async Task<bool> ConnectAsync(string serverUrl)
+        public async Task<bool> ConnectAsync()
         {
-            if (serverUrl == null) throw new ArgumentNullException(nameof(serverUrl));
-
             try
             {
                 if (m_session != null && m_session.Connected == true)
                 {
-                    m_output.WriteLine("Session already connected!");
+                    lg.Info("Session already connected!");
                 }
                 else
                 {
-                    m_output.WriteLine("Connecting to... {0}", serverUrl);
+                    lg.Info("Connecting...");
+
+                    // Get the endpoint by connecting to server's discovery endpoint. Try to find
+                    // the first endopint without security.
+                    EndpointDescription endpointDescription = CoreClientUtils.SelectEndpoint(ServerUrl, false);
 
-                    // Get the endpoint by connecting to server's discovery endpoint.
-                    // Try to find the first endopint with security.
-                    EndpointDescription endpointDescription = CoreClientUtils.SelectEndpoint(m_configuration, serverUrl, true);
                     EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_configuration);
                     ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
 
@@ -99,7 +321,7 @@ namespace MP.MONO.ADAPTER.OPC
                         false,
                         m_configuration.ApplicationName,
                         30 * 60 * 1000,
-                        new UserIdentity(),
+                        CurrUserIdentity,
                         null
                     );
 
@@ -110,7 +332,7 @@ namespace MP.MONO.ADAPTER.OPC
                     }
 
                     // Session created successfully.
-                    m_output.WriteLine("New Session Created with SessionName = {0}", m_session.SessionName);
+                    lg.Info($"New Session Created with SessionName = {m_session.SessionName}");
                 }
 
                 return true;
@@ -118,7 +340,7 @@ namespace MP.MONO.ADAPTER.OPC
             catch (Exception ex)
             {
                 // Log Error
-                m_output.WriteLine("Create Session Error : {0}", ex.Message);
+                lg.Error($"Create Session Error : {ex.Message}");
                 return false;
             }
         }
@@ -132,27 +354,141 @@ namespace MP.MONO.ADAPTER.OPC
             {
                 if (m_session != null)
                 {
-                    m_output.WriteLine("Disconnecting...");
+                    lg.Info("Disconnecting...");
 
                     m_session.Close();
                     m_session.Dispose();
                     m_session = null;
 
                     // Log Session Disconnected event
-                    m_output.WriteLine("Session Disconnected.");
+                    lg.Info("Session Disconnected.");
                 }
                 else
                 {
-                    m_output.WriteLine("Session not created!");
+                    lg.Error("Session not created!");
                 }
             }
             catch (Exception ex)
             {
                 // Log Error
-                m_output.WriteLine($"Disconnect Error : {ex.Message}");
+                lg.Error($"Disconnect Error : {ex.Message}");
             }
         }
 
+        /// <summary>
+        /// Read a SINGLE of nodes value from Server
+        /// </summary>
+        /// <param name="reqNodeId"></param>
+        /// <returns></returns>
+        public string ReadNode(NodeId reqNodeId)
+        {
+            string answ = "";
+            if (m_session == null || m_session.Connected == false)
+            {
+                lg.Error("Session not connected!");
+                return answ;
+            }
+
+            try
+            {
+                //#region Read a node by calling the Read Service
+
+                //// build a list of nodes to be read
+                //ReadValueIdCollection nodesToRead = new ReadValueIdCollection()
+                //{
+                //    // Value of ServerStatus
+                //    new ReadValueId() { NodeId = Variables.Server_ServerStatus, AttributeId = Attributes.Value },
+                //    // BrowseName of ServerStatus_StartTime
+                //    new ReadValueId() { NodeId = Variables.Server_ServerStatus_StartTime, AttributeId = Attributes.BrowseName },
+                //    // Value of ServerStatus_StartTime
+                //    new ReadValueId() { NodeId = Variables.Server_ServerStatus_StartTime, AttributeId = Attributes.Value }
+                //};
+
+                //// Read the node attributes
+                //lg.Info("Reading nodes...");
+
+                //// Call Read Service
+                //m_session.Read(
+                //    null,
+                //    0,
+                //    TimestampsToReturn.Both,
+                //    nodesToRead,
+                //    out DataValueCollection resultsValues,
+                //    out DiagnosticInfoCollection diagnosticInfos);
+
+                //// Validate the results
+                //m_validateResponse(resultsValues, nodesToRead);
+
+                //// Display the results.
+                //foreach (DataValue result in resultsValues)
+                //{
+                //    lg.Info("Read Value = {0} , StatusCode = {1}", result.Value, result.StatusCode);
+                //}
+
+                //#endregion Read a node by calling the Read Service
+
+                #region Read the Value attribute of a node by calling the Session.ReadValue method
+
+                try
+                {
+                    DataValue resp = m_session.ReadValue(reqNodeId);
+                    answ = $"{resp.Value}";
+                }
+                catch (Exception exc)
+                {
+                    // Log Error
+                    lg.Error($"ReadValue Error : {Environment.NewLine}{exc}");
+                }
+
+                #endregion Read the Value attribute of a node by calling the Session.ReadValue method
+            }
+            catch (Exception ex)
+            {
+                // Log Error
+                lg.Error($"Read Nodes Error : {ex.Message}.");
+            }
+            return answ;
+        }
+
+        /// <summary>
+        /// Read a SINGLE of nodes value (RAW) from Server
+        /// </summary>
+        /// <param name="reqNodeId"></param>
+        /// <returns></returns>
+        public object ReadNodeRaw(NodeId reqNodeId)
+        {
+            object answ = null;
+            if (m_session == null || m_session.Connected == false)
+            {
+                lg.Error("Session not connected!");
+                return answ;
+            }
+
+            try
+            {
+                #region Read the Value attribute of a node by calling the Session.ReadValue method
+
+                try
+                {
+                    DataValue resp = m_session.ReadValue(reqNodeId);
+                    answ = resp;
+                }
+                catch (Exception exc)
+                {
+                    // Log Error
+                    lg.Error($"ReadNodeRaw Error 01: {Environment.NewLine}{exc}");
+                }
+
+                #endregion Read the Value attribute of a node by calling the Session.ReadValue method
+            }
+            catch (Exception ex)
+            {
+                // Log Error
+                lg.Error($"ReadNodeRaw Error 02: {ex.Message}.");
+            }
+            return answ;
+        }
+
         /// <summary>
         /// Read a list of nodes from Server
         /// </summary>
@@ -160,7 +496,7 @@ namespace MP.MONO.ADAPTER.OPC
         {
             if (m_session == null || m_session.Connected == false)
             {
-                m_output.WriteLine("Session not connected!");
+                lg.Error("Session not connected!");
                 return;
             }
 
@@ -180,7 +516,7 @@ namespace MP.MONO.ADAPTER.OPC
                 };
 
                 // Read the node attributes
-                m_output.WriteLine("Reading nodes...");
+                lg.Info("Reading nodes...");
 
                 // Call Read Service
                 m_session.Read(
@@ -197,33 +533,165 @@ namespace MP.MONO.ADAPTER.OPC
                 // Display the results.
                 foreach (DataValue result in resultsValues)
                 {
-                    m_output.WriteLine("Read Value = {0} , StatusCode = {1}", result.Value, result.StatusCode);
+                    lg.Trace($"Read Value = {result.Value} , StatusCode = {result.StatusCode}");
                 }
-                #endregion
+
+                #endregion Read a node by calling the Read Service
 
                 #region Read the Value attribute of a node by calling the Session.ReadValue method
+
                 // Read Server NamespaceArray
-                m_output.WriteLine("Reading Value of NamespaceArray node...");
+                lg.Trace("Reading Value of NamespaceArray node...");
                 DataValue namespaceArray = m_session.ReadValue(Variables.Server_NamespaceArray);
                 // Display the result
-                m_output.WriteLine($"NamespaceArray Value = {namespaceArray}");
-                #endregion
+                lg.Trace($"NamespaceArray Value = {namespaceArray}");
+
+                #endregion Read the Value attribute of a node by calling the Session.ReadValue method
             }
             catch (Exception ex)
             {
                 // Log Error
-                m_output.WriteLine($"Read Nodes Error : {ex.Message}.");
+                lg.Error($"Read Nodes Error : {ex.Message}.");
             }
         }
 
         /// <summary>
-        /// Write a list of nodes to the Server
+        /// Create Subscription and MonitoredItems for DataChanges
         /// </summary>
-        public void WriteNodes()
+        public List<MonitoredItem> SubscribeToDataChanges(Dictionary<string, string> DataList)
+        {
+            List<MonitoredItem> monItList = new List<MonitoredItem>();
+            if (m_session == null || m_session.Connected == false)
+            {
+                lg.Error("Session not connected!");
+                return monItList;
+            }
+
+            try
+            {
+                // Create a subscription for receiving data change notifications
+
+                // Define Subscription parameters
+                Subscription subscription = new Subscription(m_session.DefaultSubscription);
+
+                subscription.DisplayName = "Steamware IOB-WIN Subscription";
+                subscription.PublishingEnabled = true;
+                subscription.PublishingInterval = 1000;
+
+                m_session.AddSubscription(subscription);
+
+                // Create the subscription on Server side
+                subscription.Create();
+                lg.Info($"New Subscription created with SubscriptionId = {subscription.Id}");
+
+                // Create MonitoredItems for data changes
+                foreach (var item in DataList)
+                {
+                    MonitoredItem currMonIt = new MonitoredItem(subscription.DefaultItem);
+                    // Int32 Node - Objects\CTT\Scalar\Simulation\Int32
+                    currMonIt.StartNodeId = new NodeId(item.Key);
+                    currMonIt.AttributeId = Attributes.Value;
+                    currMonIt.DisplayName = item.Value;
+                    currMonIt.SamplingInterval = 1000;
+                    currMonIt.Notification += OnMonitoredItemNotification;
+                    subscription.AddItem(currMonIt);
+                    monItList.Add(currMonIt);
+                }
+
+#if false
+                MonitoredItem IO_120_00_MonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                // Int32 Node - Objects\CTT\Scalar\Simulation\Int32
+                IO_120_00_MonitoredItem.StartNodeId = new NodeId("ns=4;s=IO_120.00");
+                IO_120_00_MonitoredItem.AttributeId = Attributes.Value;
+                IO_120_00_MonitoredItem.DisplayName = "IO_120 Variable";
+                IO_120_00_MonitoredItem.SamplingInterval = 1000;
+                IO_120_00_MonitoredItem.Notification += OnMonitoredItemNotification;
+                subscription.AddItem(IO_120_00_MonitoredItem);
+
+                MonitoredItem IO_120_01_MonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                // Int32 Node - Objects\CTT\Scalar\Simulation\Int32
+                IO_120_01_MonitoredItem.StartNodeId = new NodeId("ns=4;s=IO_120.01");
+                IO_120_01_MonitoredItem.AttributeId = Attributes.Value;
+                IO_120_01_MonitoredItem.DisplayName = "IO_120_01 Variable";
+                IO_120_01_MonitoredItem.SamplingInterval = 1000;
+                IO_120_01_MonitoredItem.Notification += OnMonitoredItemNotification;
+                subscription.AddItem(IO_120_01_MonitoredItem);
+
+                MonitoredItem IO_130_MonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                // Int32 Node - Objects\CTT\Scalar\Simulation\Int32
+                IO_130_MonitoredItem.StartNodeId = new NodeId("ns=4;s=IO_130");
+                IO_130_MonitoredItem.AttributeId = Attributes.Value;
+                IO_130_MonitoredItem.DisplayName = "IO_130 Variable";
+                IO_130_MonitoredItem.SamplingInterval = 1000;
+                IO_130_MonitoredItem.Notification += OnMonitoredItemNotification;
+                subscription.AddItem(IO_130_MonitoredItem);
+
+                MonitoredItem IO_135_MonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                // Int32 Node - Objects\CTT\Scalar\Simulation\Int32
+                IO_135_MonitoredItem.StartNodeId = new NodeId("ns=4;s=IO_135");
+                IO_135_MonitoredItem.AttributeId = Attributes.Value;
+                IO_135_MonitoredItem.DisplayName = "IO_135 Variable";
+                IO_135_MonitoredItem.SamplingInterval = 1000;
+                IO_135_MonitoredItem.Notification += OnMonitoredItemNotification;
+                subscription.AddItem(IO_135_MonitoredItem);
+
+                MonitoredItem IO_140_MonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                // Int32 Node - Objects\CTT\Scalar\Simulation\Int32
+                IO_140_MonitoredItem.StartNodeId = new NodeId("ns=4;s=IO_140");
+                IO_140_MonitoredItem.AttributeId = Attributes.Value;
+                IO_140_MonitoredItem.DisplayName = "IO_140 Variable";
+                IO_140_MonitoredItem.SamplingInterval = 1000;
+                IO_140_MonitoredItem.Notification += OnMonitoredItemNotification;
+                subscription.AddItem(IO_140_MonitoredItem);
+
+                //MonitoredItem intMonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                //// Int32 Node - Objects\CTT\Scalar\Simulation\Int32
+                //intMonitoredItem.StartNodeId = new NodeId("ns=2;s=Scalar_Simulation_Int32");
+                //intMonitoredItem.AttributeId = Attributes.Value;
+                //intMonitoredItem.DisplayName = "Int32 Variable";
+                //intMonitoredItem.SamplingInterval = 1000;
+                //intMonitoredItem.Notification += OnMonitoredItemNotification;
+
+                //subscription.AddItem(intMonitoredItem);
+
+                //MonitoredItem floatMonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                //// Float Node - Objects\CTT\Scalar\Simulation\Float
+                //floatMonitoredItem.StartNodeId = new NodeId("ns=2;s=Scalar_Simulation_Float");
+                //floatMonitoredItem.AttributeId = Attributes.Value;
+                //floatMonitoredItem.DisplayName = "Float Variable";
+                //floatMonitoredItem.SamplingInterval = 1000;
+                //floatMonitoredItem.Notification += OnMonitoredItemNotification;
+
+                //subscription.AddItem(floatMonitoredItem);
+
+                //MonitoredItem stringMonitoredItem = new MonitoredItem(subscription.DefaultItem);
+                //// String Node - Objects\CTT\Scalar\Simulation\String
+                //stringMonitoredItem.StartNodeId = new NodeId("ns=2;s=Scalar_Simulation_String");
+                //stringMonitoredItem.AttributeId = Attributes.Value;
+                //stringMonitoredItem.DisplayName = "String Variable";
+                //stringMonitoredItem.SamplingInterval = 1000;
+                //stringMonitoredItem.Notification += OnMonitoredItemNotification;
+
+                //subscription.AddItem(stringMonitoredItem);
+#endif
+
+                // Create the monitored items on Server side
+                subscription.ApplyChanges();
+                lg.Info($"MonitoredItems created for SubscriptionId = {subscription.Id}");
+            }
+            catch (Exception ex)
+            {
+                lg.Error($"Subscribe error: {ex.Message}");
+            }
+            return monItList;
+        }
+
+        /// Write a list of nodes to the Server </summary>
+        public void WriteNodes(List<WriteValue> node2Write)
         {
             if (m_session == null || m_session.Connected == false)
             {
-                m_output.WriteLine("Session not connected!");
+                lg.Error("Session not connected!");
                 return;
             }
 
@@ -231,35 +699,12 @@ namespace MP.MONO.ADAPTER.OPC
             {
                 // Write the configured nodes
                 WriteValueCollection nodesToWrite = new WriteValueCollection();
-
-                // Int32 Node - Objects\CTT\Scalar\Scalar_Static\Int32
-                WriteValue intWriteVal = new WriteValue();
-                intWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Int32");
-                intWriteVal.AttributeId = Attributes.Value;
-                intWriteVal.Value = new DataValue();
-                intWriteVal.Value.Value = (int)100;
-                nodesToWrite.Add(intWriteVal);
-
-                // Float Node - Objects\CTT\Scalar\Scalar_Static\Float
-                WriteValue floatWriteVal = new WriteValue();
-                floatWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Float");
-                floatWriteVal.AttributeId = Attributes.Value;
-                floatWriteVal.Value = new DataValue();
-                floatWriteVal.Value.Value = (float)100.5;
-                nodesToWrite.Add(floatWriteVal);
-
-                // String Node - Objects\CTT\Scalar\Scalar_Static\String
-                WriteValue stringWriteVal = new WriteValue();
-                stringWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_String");
-                stringWriteVal.AttributeId = Attributes.Value;
-                stringWriteVal.Value = new DataValue();
-                stringWriteVal.Value.Value = "String Test";
-                nodesToWrite.Add(stringWriteVal);
+                nodesToWrite.AddRange(node2Write);
 
                 // Write the node attributes
                 StatusCodeCollection results = null;
                 DiagnosticInfoCollection diagnosticInfos;
-                m_output.WriteLine("Writing nodes...");
+                lg.Debug("Writing nodes...");
 
                 // Call Write Service
                 m_session.Write(null,
@@ -271,176 +716,212 @@ namespace MP.MONO.ADAPTER.OPC
                 m_validateResponse(results, nodesToWrite);
 
                 // Display the results.
-                m_output.WriteLine("Write Results :");
+                lg.Debug("Write Results :");
 
                 foreach (StatusCode writeResult in results)
                 {
-                    m_output.WriteLine("     {0}", writeResult);
+                    lg.Debug($"     {writeResult}");
                 }
             }
             catch (Exception ex)
             {
                 // Log Error
-                m_output.WriteLine($"Write Nodes Error : {ex.Message}.");
+                lg.Error($"Write Nodes Error : {ex.Message}");
             }
         }
 
         /// <summary>
-        /// Browse Server nodes
+        /// Write a list of nodes to the Server
         /// </summary>
-        public void Browse()
+        public void WriteSingleNode(WriteValue node2Write)
         {
             if (m_session == null || m_session.Connected == false)
             {
-                m_output.WriteLine("Session not connected!");
+                lg.Error("Session not connected!");
                 return;
             }
 
             try
             {
-                // Create a Browser object
-                Browser browser = new Browser(m_session);
+                // Write the configured nodes
+                WriteValueCollection nodesToWrite = new WriteValueCollection();
 
-                // Set browse parameters
-                browser.BrowseDirection = BrowseDirection.Forward;
-                browser.NodeClassMask = (int)NodeClass.Object | (int)NodeClass.Variable;
-                browser.ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences;
+                nodesToWrite.Add(node2Write);
 
-                NodeId nodeToBrowse = ObjectIds.Server;
+                // Write the node attributes
+                StatusCodeCollection results = null;
+                DiagnosticInfoCollection diagnosticInfos;
+                lg.Debug("Writing nodes...");
 
-                // Call Browse service
-                m_output.WriteLine("Browsing {0} node...", nodeToBrowse);
-                ReferenceDescriptionCollection browseResults = browser.Browse(nodeToBrowse);
+                // Call Write Service
+                m_session.Write(null,
+                                nodesToWrite,
+                                out results,
+                                out diagnosticInfos);
 
-                // Display the results
-                m_output.WriteLine("Browse returned {0} results:", browseResults.Count);
+                // Validate the response
+                m_validateResponse(results, nodesToWrite);
 
-                foreach (ReferenceDescription result in browseResults)
+                // Display the results.
+                lg.Debug("Write Results :");
+
+                foreach (StatusCode writeResult in results)
                 {
-                    m_output.WriteLine("     DisplayName = {0}, NodeClass = {1}", result.DisplayName.Text, result.NodeClass);
+                    lg.Debug("     {writeResult}");
                 }
             }
             catch (Exception ex)
             {
                 // Log Error
-                m_output.WriteLine($"Browse Error : {ex.Message}.");
+                lg.Error($"Write Nodes Error : {ex.Message}");
             }
         }
 
         /// <summary>
-        /// Call UA method
+        /// Write a list of nodes to the Server
         /// </summary>
-        public void CallMethod()
+        public void WriteTestNodes()
         {
             if (m_session == null || m_session.Connected == false)
             {
-                m_output.WriteLine("Session not connected!");
+                lg.Error("Session not connected!");
                 return;
             }
 
             try
             {
-                // Define the UA Method to call
-                // Parent node - Objects\CTT\Methods
-                // Method node - Objects\CTT\Methods\Add
-                NodeId objectId = new NodeId("ns=2;s=Methods");
-                NodeId methodId = new NodeId("ns=2;s=Methods_Add");
+                // scrivo vaslori a caso.. hhmm odierni
+                int hhmm = 9876;
+                int.TryParse(DateTime.Now.ToString("HHmm"), out hhmm);
+                // Write the configured nodes
+                WriteValueCollection nodesToWrite = new WriteValueCollection();
 
-                // Define the method parameters
-                // Input argument requires a Float and an UInt32 value
-                object[] inputArguments = new object[] { (float)10.5, (uint)10 };
-                IList<object> outputArguments = null;
+                // Int32 Node - Objects\CTT\Scalar\Scalar_Static\Int32
+                WriteValue commWriteVal = new WriteValue();
+                commWriteVal.NodeId = new NodeId("ns=4;s=IO_151");
+                commWriteVal.AttributeId = Attributes.Value;
+                commWriteVal.Value = new DataValue();
+                commWriteVal.Value.Value = (int)hhmm - 10;
+                nodesToWrite.Add(commWriteVal);
 
-                // Invoke Call service
-                m_output.WriteLine("Calling UAMethod for node {0} ...", methodId);
-                outputArguments = m_session.Call(objectId, methodId, inputArguments);
+                WriteValue artWriteVal = new WriteValue();
+                artWriteVal.NodeId = new NodeId("ns=4;s=IO_151");
+                artWriteVal.AttributeId = Attributes.Value;
+                artWriteVal.Value = new DataValue();
+                artWriteVal.Value.Value = (int)hhmm;
+                nodesToWrite.Add(artWriteVal);
 
-                // Display results
-                m_output.WriteLine("Method call returned {0} output argument(s):", outputArguments.Count);
+                WriteValue qtyWriteVal = new WriteValue();
+                qtyWriteVal.NodeId = new NodeId("ns=4;s=IO_153");
+                qtyWriteVal.AttributeId = Attributes.Value;
+                qtyWriteVal.Value = new DataValue();
+                qtyWriteVal.Value.Value = (int)hhmm + 10;
+                nodesToWrite.Add(qtyWriteVal);
 
-                foreach (var outputArgument in outputArguments)
+#if false
+                //// Int32 Node - Objects\CTT\Scalar\Scalar_Static\Int32
+                //WriteValue intWriteVal = new WriteValue();
+                //intWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Int32");
+                //intWriteVal.AttributeId = Attributes.Value;
+                //intWriteVal.Value = new DataValue();
+                //intWriteVal.Value.Value = (int)100;
+                //nodesToWrite.Add(intWriteVal);
+
+                //// Float Node - Objects\CTT\Scalar\Scalar_Static\Float
+                //WriteValue floatWriteVal = new WriteValue();
+                //floatWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Float");
+                //floatWriteVal.AttributeId = Attributes.Value;
+                //floatWriteVal.Value = new DataValue();
+                //floatWriteVal.Value.Value = (float)100.5;
+                //nodesToWrite.Add(floatWriteVal);
+
+                //// String Node - Objects\CTT\Scalar\Scalar_Static\String
+                //WriteValue stringWriteVal = new WriteValue();
+                //stringWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_String");
+                //stringWriteVal.AttributeId = Attributes.Value;
+                //stringWriteVal.Value = new DataValue();
+                //stringWriteVal.Value.Value = "String Test";
+                //nodesToWrite.Add(stringWriteVal);
+#endif
+
+                // Write the node attributes
+                StatusCodeCollection results = null;
+                DiagnosticInfoCollection diagnosticInfos;
+                lg.Debug("Writing nodes...");
+
+                // Call Write Service
+                m_session.Write(null,
+                                nodesToWrite,
+                                out results,
+                                out diagnosticInfos);
+
+                // Validate the response
+                m_validateResponse(results, nodesToWrite);
+
+                // Display the results.
+                lg.Debug("Write Results :");
+
+                foreach (StatusCode writeResult in results)
                 {
-                    m_output.WriteLine("     OutputValue = {0}", outputArgument.ToString());
+                    lg.Debug($"     {writeResult}");
                 }
             }
             catch (Exception ex)
             {
-                m_output.WriteLine("Method call error: {0}", ex.Message);
+                // Log Error
+                lg.Error($"Write Nodes Error : {ex.Message}.");
             }
         }
 
-        /// <summary>
-        /// Create Subscription and MonitoredItems for DataChanges
-        /// </summary>
-        public void SubscribeToDataChanges()
-        {
-            if (m_session == null || m_session.Connected == false)
-            {
-                m_output.WriteLine("Session not connected!");
-                return;
-            }
+        #endregion Public Methods
 
-            try
-            {
-                // Create a subscription for receiving data change notifications
+        #region Protected Fields
 
-                // Define Subscription parameters
-                Subscription subscription = new Subscription(m_session.DefaultSubscription);
+        protected static Logger lg;
 
-                subscription.DisplayName = "Console ReferenceClient Subscription";
-                subscription.PublishingEnabled = true;
-                subscription.PublishingInterval = 1000;
+        #endregion Protected Fields
 
-                m_session.AddSubscription(subscription);
+        #region Protected Methods
 
-                // Create the subscription on Server side
-                subscription.Create();
-                m_output.WriteLine("New Subscription created with SubscriptionId = {0}.", subscription.Id);
+        #endregion Protected Methods
 
-                // Create MonitoredItems for data changes (Reference Server)
+        #region Private Fields
 
-                MonitoredItem intMonitoredItem = new MonitoredItem(subscription.DefaultItem);
-                // Int32 Node - Objects\CTT\Scalar\Simulation\Int32
-                intMonitoredItem.StartNodeId = new NodeId("ns=2;s=Scalar_Simulation_Int32");
-                intMonitoredItem.AttributeId = Attributes.Value;
-                intMonitoredItem.DisplayName = "Int32 Variable";
-                intMonitoredItem.SamplingInterval = 1000;
-                intMonitoredItem.Notification += OnMonitoredItemNotification;
+        private readonly Action<IList, IList> m_validateResponse;
+        private ApplicationConfiguration m_configuration;
+        private Session m_session;
 
-                subscription.AddItem(intMonitoredItem);
-
-                MonitoredItem floatMonitoredItem = new MonitoredItem(subscription.DefaultItem);
-                // Float Node - Objects\CTT\Scalar\Simulation\Float
-                floatMonitoredItem.StartNodeId = new NodeId("ns=2;s=Scalar_Simulation_Float");
-                floatMonitoredItem.AttributeId = Attributes.Value;
-                floatMonitoredItem.DisplayName = "Float Variable";
-                floatMonitoredItem.SamplingInterval = 1000;
-                floatMonitoredItem.Notification += OnMonitoredItemNotification;
-
-                subscription.AddItem(floatMonitoredItem);
-
-                MonitoredItem stringMonitoredItem = new MonitoredItem(subscription.DefaultItem);
-                // String Node - Objects\CTT\Scalar\Simulation\String
-                stringMonitoredItem.StartNodeId = new NodeId("ns=2;s=Scalar_Simulation_String");
-                stringMonitoredItem.AttributeId = Attributes.Value;
-                stringMonitoredItem.DisplayName = "String Variable";
-                stringMonitoredItem.SamplingInterval = 1000;
-                stringMonitoredItem.Notification += OnMonitoredItemNotification;
-
-                subscription.AddItem(stringMonitoredItem);
-
-                // Create the monitored items on Server side
-                subscription.ApplyChanges();
-                m_output.WriteLine("MonitoredItems created for SubscriptionId = {0}.", subscription.Id);
-            }
-            catch (Exception ex)
-            {
-                m_output.WriteLine("Subscribe error: {0}", ex.Message);
-            }
-        }
-        #endregion
+        #endregion Private Fields
 
         #region Private Methods
+
+        /// <summary>
+        /// Handles the certificate validation event. This event is triggered every time an
+        /// untrusted certificate is received from the server.
+        /// </summary>
+        private void CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
+        {
+            bool certificateAccepted = true;
+
+            // **** Implement a custom logic to decide if the certificate should be accepted or not
+            // and set certificateAccepted flag accordingly. The certificate can be retrieved from
+            // the e.Certificate field ***
+
+            ServiceResult error = e.Error;
+            while (error != null)
+            {
+                lg.Error($"{error.StatusCode} | {error.Code} | {error.LocalizedText}");
+                error = error.InnerResult;
+            }
+
+            if (certificateAccepted)
+            {
+                lg.Info($"Untrusted Certificate accepted. SubjectName = {e.Certificate.SubjectName}");
+            }
+
+            e.AcceptAll = certificateAccepted;
+        }
+
         /// <summary>
         /// Handle DataChange notifications from Server
         /// </summary>
@@ -450,52 +931,20 @@ namespace MP.MONO.ADAPTER.OPC
             {
                 // Log MonitoredItem Notification event
                 MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
-                m_output.WriteLine("Notification Received for Variable \"{0}\" and Value = {1}.", monitoredItem.DisplayName, notification.Value);
+
+                // sollevo evento notifica vaziazione MonitoredItem
+                if (eh_MonItChange != null)
+                {
+                    eh_MonItChange(this, new opcUaMonitItemChange(monitoredItem, notification));
+                }
+                lg.Trace($"Notification Received | Variable: {monitoredItem.DisplayName} | Value: {notification.Value}");
             }
             catch (Exception ex)
             {
-                m_output.WriteLine("OnMonitoredItemNotification error: {0}", ex.Message);
+                lg.Error($"OnMonitoredItemNotification error: {ex.Message}");
             }
         }
 
-        /// <summary>
-        /// Handles the certificate validation event.
-        /// This event is triggered every time an untrusted certificate is received from the server.
-        /// </summary>
-        private void CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
-        {
-            bool certificateAccepted = false;
-
-            // ****
-            // Implement a custom logic to decide if the certificate should be
-            // accepted or not and set certificateAccepted flag accordingly.
-            // The certificate can be retrieved from the e.Certificate field
-            // ***
-
-            ServiceResult error = e.Error;
-            m_output.WriteLine(error);
-            if (error.StatusCode == StatusCodes.BadCertificateUntrusted && AutoAccept)
-            {
-                certificateAccepted = true;
-            }
-
-            if (certificateAccepted)
-            {
-                m_output.WriteLine("Untrusted Certificate accepted. Subject = {0}", e.Certificate.Subject);
-                e.Accept = true;
-            }
-            else
-            {
-                m_output.WriteLine("Untrusted Certificate rejected. Subject = {0}", e.Certificate.Subject);
-            }
-        }
-        #endregion
-
-        #region Private Fields
-        private ApplicationConfiguration m_configuration;
-        private Session m_session;
-        private readonly TextWriter m_output;
-        private readonly Action<IList, IList> m_validateResponse;
-        #endregion
+        #endregion Private Methods
     }
-}
+}
\ No newline at end of file
diff --git a/MP.MONO.ADAPTER.OPC2/UAClient.cs b/MP.MONO.ADAPTER.OPC/UAClient.old.cs
similarity index 93%
rename from MP.MONO.ADAPTER.OPC2/UAClient.cs
rename to MP.MONO.ADAPTER.OPC/UAClient.old.cs
index 3b815f5..46857b9 100644
--- a/MP.MONO.ADAPTER.OPC2/UAClient.cs
+++ b/MP.MONO.ADAPTER.OPC/UAClient.old.cs
@@ -2,7 +2,7 @@
  * Copyright (c) 2005-2020 The OPC Foundation, Inc. All rights reserved.
  *
  * OPC Foundation MIT License 1.00
- * 
+ *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
  * files (the "Software"), to deal in the Software without
@@ -11,7 +11,7 @@
  * copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following
  * conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
@@ -27,22 +27,22 @@
  * http://opcfoundation.org/License/MIT/1.00/
  * ======================================================================*/
 
+using Opc.Ua;
+using Opc.Ua.Client;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
-using Opc.Ua;
-using Opc.Ua.Client;
 
 namespace MP.MONO.ADAPTER.OPC
 {
     /// <summary>
     /// OPC UA Client with examples of basic functionality.
     /// </summary>
-    class UAClient
+    internal class UAClient
     {
-        #region Constructors
+
         /// <summary>
         /// Initializes a new instance of the UAClient class.
         /// </summary>
@@ -53,21 +53,98 @@ namespace MP.MONO.ADAPTER.OPC
             m_configuration = configuration;
             m_configuration.CertificateValidator.CertificateValidation += CertificateValidation;
         }
-        #endregion
 
-        #region Public Properties
+        /// <summary>
+        /// Auto accept untrusted certificates.
+        /// </summary>
+        public bool AutoAccept { get; set; } = false;
+
         /// <summary>
         /// Gets the client session.
         /// </summary>
         public Session Session => m_session;
 
         /// <summary>
-        /// Auto accept untrusted certificates.
+        /// Browse Server nodes
         /// </summary>
-        public bool AutoAccept { get; set; } = false;
-        #endregion
+        public void Browse()
+        {
+            if (m_session == null || m_session.Connected == false)
+            {
+                m_output.WriteLine("Session not connected!");
+                return;
+            }
+
+            try
+            {
+                // Create a Browser object
+                Browser browser = new Browser(m_session);
+
+                // Set browse parameters
+                browser.BrowseDirection = BrowseDirection.Forward;
+                browser.NodeClassMask = (int)NodeClass.Object | (int)NodeClass.Variable;
+                browser.ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences;
+
+                NodeId nodeToBrowse = ObjectIds.Server;
+
+                // Call Browse service
+                m_output.WriteLine("Browsing {0} node...", nodeToBrowse);
+                ReferenceDescriptionCollection browseResults = browser.Browse(nodeToBrowse);
+
+                // Display the results
+                m_output.WriteLine("Browse returned {0} results:", browseResults.Count);
+
+                foreach (ReferenceDescription result in browseResults)
+                {
+                    m_output.WriteLine("     DisplayName = {0}, NodeClass = {1}", result.DisplayName.Text, result.NodeClass);
+                }
+            }
+            catch (Exception ex)
+            {
+                // Log Error
+                m_output.WriteLine($"Browse Error : {ex.Message}.");
+            }
+        }
+
+        /// <summary>
+        /// Call UA method
+        /// </summary>
+        public void CallMethod()
+        {
+            if (m_session == null || m_session.Connected == false)
+            {
+                m_output.WriteLine("Session not connected!");
+                return;
+            }
+
+            try
+            {
+                // Define the UA Method to call Parent node - Objects\CTT\Methods Method node - Objects\CTT\Methods\Add
+                NodeId objectId = new NodeId("ns=2;s=Methods");
+                NodeId methodId = new NodeId("ns=2;s=Methods_Add");
+
+                // Define the method parameters Input argument requires a Float and an UInt32 value
+                object[] inputArguments = new object[] { (float)10.5, (uint)10 };
+                IList<object> outputArguments = null;
+
+                // Invoke Call service
+                m_output.WriteLine("Calling UAMethod for node {0} ...", methodId);
+                outputArguments = m_session.Call(objectId, methodId, inputArguments);
+
+                // Display results
+                m_output.WriteLine("Method call returned {0} output argument(s):", outputArguments.Count);
+
+                foreach (var outputArgument in outputArguments)
+                {
+                    m_output.WriteLine("     OutputValue = {0}", outputArgument.ToString());
+                }
+            }
+            catch (Exception ex)
+            {
+                m_output.WriteLine("Method call error: {0}", ex.Message);
+            }
+        }
 
-        #region Public Methods
         /// <summary>
         /// Creates a session with the UA server
         /// </summary>
@@ -85,8 +162,8 @@ namespace MP.MONO.ADAPTER.OPC
                 {
                     m_output.WriteLine("Connecting to... {0}", serverUrl);
 
-                    // Get the endpoint by connecting to server's discovery endpoint.
-                    // Try to find the first endopint with security.
+                    // Get the endpoint by connecting to server's discovery endpoint. Try to find
+                    // the first endopint with security.
                     EndpointDescription endpointDescription = CoreClientUtils.SelectEndpoint(m_configuration, serverUrl, true);
                     EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_configuration);
                     ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
@@ -166,7 +243,6 @@ namespace MP.MONO.ADAPTER.OPC
 
             try
             {
-                #region Read a node by calling the Read Service
 
                 // build a list of nodes to be read
                 ReadValueIdCollection nodesToRead = new ReadValueIdCollection()
@@ -199,15 +275,13 @@ namespace MP.MONO.ADAPTER.OPC
                 {
                     m_output.WriteLine("Read Value = {0} , StatusCode = {1}", result.Value, result.StatusCode);
                 }
-                #endregion
 
-                #region Read the Value attribute of a node by calling the Session.ReadValue method
                 // Read Server NamespaceArray
                 m_output.WriteLine("Reading Value of NamespaceArray node...");
                 DataValue namespaceArray = m_session.ReadValue(Variables.Server_NamespaceArray);
                 // Display the result
                 m_output.WriteLine($"NamespaceArray Value = {namespaceArray}");
-                #endregion
+
             }
             catch (Exception ex)
             {
@@ -216,159 +290,6 @@ namespace MP.MONO.ADAPTER.OPC
             }
         }
 
-        /// <summary>
-        /// Write a list of nodes to the Server
-        /// </summary>
-        public void WriteNodes()
-        {
-            if (m_session == null || m_session.Connected == false)
-            {
-                m_output.WriteLine("Session not connected!");
-                return;
-            }
-
-            try
-            {
-                // Write the configured nodes
-                WriteValueCollection nodesToWrite = new WriteValueCollection();
-
-                // Int32 Node - Objects\CTT\Scalar\Scalar_Static\Int32
-                WriteValue intWriteVal = new WriteValue();
-                intWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Int32");
-                intWriteVal.AttributeId = Attributes.Value;
-                intWriteVal.Value = new DataValue();
-                intWriteVal.Value.Value = (int)100;
-                nodesToWrite.Add(intWriteVal);
-
-                // Float Node - Objects\CTT\Scalar\Scalar_Static\Float
-                WriteValue floatWriteVal = new WriteValue();
-                floatWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Float");
-                floatWriteVal.AttributeId = Attributes.Value;
-                floatWriteVal.Value = new DataValue();
-                floatWriteVal.Value.Value = (float)100.5;
-                nodesToWrite.Add(floatWriteVal);
-
-                // String Node - Objects\CTT\Scalar\Scalar_Static\String
-                WriteValue stringWriteVal = new WriteValue();
-                stringWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_String");
-                stringWriteVal.AttributeId = Attributes.Value;
-                stringWriteVal.Value = new DataValue();
-                stringWriteVal.Value.Value = "String Test";
-                nodesToWrite.Add(stringWriteVal);
-
-                // Write the node attributes
-                StatusCodeCollection results = null;
-                DiagnosticInfoCollection diagnosticInfos;
-                m_output.WriteLine("Writing nodes...");
-
-                // Call Write Service
-                m_session.Write(null,
-                                nodesToWrite,
-                                out results,
-                                out diagnosticInfos);
-
-                // Validate the response
-                m_validateResponse(results, nodesToWrite);
-
-                // Display the results.
-                m_output.WriteLine("Write Results :");
-
-                foreach (StatusCode writeResult in results)
-                {
-                    m_output.WriteLine("     {0}", writeResult);
-                }
-            }
-            catch (Exception ex)
-            {
-                // Log Error
-                m_output.WriteLine($"Write Nodes Error : {ex.Message}.");
-            }
-        }
-
-        /// <summary>
-        /// Browse Server nodes
-        /// </summary>
-        public void Browse()
-        {
-            if (m_session == null || m_session.Connected == false)
-            {
-                m_output.WriteLine("Session not connected!");
-                return;
-            }
-
-            try
-            {
-                // Create a Browser object
-                Browser browser = new Browser(m_session);
-
-                // Set browse parameters
-                browser.BrowseDirection = BrowseDirection.Forward;
-                browser.NodeClassMask = (int)NodeClass.Object | (int)NodeClass.Variable;
-                browser.ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences;
-
-                NodeId nodeToBrowse = ObjectIds.Server;
-
-                // Call Browse service
-                m_output.WriteLine("Browsing {0} node...", nodeToBrowse);
-                ReferenceDescriptionCollection browseResults = browser.Browse(nodeToBrowse);
-
-                // Display the results
-                m_output.WriteLine("Browse returned {0} results:", browseResults.Count);
-
-                foreach (ReferenceDescription result in browseResults)
-                {
-                    m_output.WriteLine("     DisplayName = {0}, NodeClass = {1}", result.DisplayName.Text, result.NodeClass);
-                }
-            }
-            catch (Exception ex)
-            {
-                // Log Error
-                m_output.WriteLine($"Browse Error : {ex.Message}.");
-            }
-        }
-
-        /// <summary>
-        /// Call UA method
-        /// </summary>
-        public void CallMethod()
-        {
-            if (m_session == null || m_session.Connected == false)
-            {
-                m_output.WriteLine("Session not connected!");
-                return;
-            }
-
-            try
-            {
-                // Define the UA Method to call
-                // Parent node - Objects\CTT\Methods
-                // Method node - Objects\CTT\Methods\Add
-                NodeId objectId = new NodeId("ns=2;s=Methods");
-                NodeId methodId = new NodeId("ns=2;s=Methods_Add");
-
-                // Define the method parameters
-                // Input argument requires a Float and an UInt32 value
-                object[] inputArguments = new object[] { (float)10.5, (uint)10 };
-                IList<object> outputArguments = null;
-
-                // Invoke Call service
-                m_output.WriteLine("Calling UAMethod for node {0} ...", methodId);
-                outputArguments = m_session.Call(objectId, methodId, inputArguments);
-
-                // Display results
-                m_output.WriteLine("Method call returned {0} output argument(s):", outputArguments.Count);
-
-                foreach (var outputArgument in outputArguments)
-                {
-                    m_output.WriteLine("     OutputValue = {0}", outputArgument.ToString());
-                }
-            }
-            catch (Exception ex)
-            {
-                m_output.WriteLine("Method call error: {0}", ex.Message);
-            }
-        }
-
         /// <summary>
         /// Create Subscription and MonitoredItems for DataChanges
         /// </summary>
@@ -438,39 +359,95 @@ namespace MP.MONO.ADAPTER.OPC
                 m_output.WriteLine("Subscribe error: {0}", ex.Message);
             }
         }
-        #endregion
 
-        #region Private Methods
         /// <summary>
-        /// Handle DataChange notifications from Server
+        /// Write a list of nodes to the Server
         /// </summary>
-        private void OnMonitoredItemNotification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
+        public void WriteNodes()
         {
+            if (m_session == null || m_session.Connected == false)
+            {
+                m_output.WriteLine("Session not connected!");
+                return;
+            }
+
             try
             {
-                // Log MonitoredItem Notification event
-                MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
-                m_output.WriteLine("Notification Received for Variable \"{0}\" and Value = {1}.", monitoredItem.DisplayName, notification.Value);
+                // Write the configured nodes
+                WriteValueCollection nodesToWrite = new WriteValueCollection();
+
+                // Int32 Node - Objects\CTT\Scalar\Scalar_Static\Int32
+                WriteValue intWriteVal = new WriteValue();
+                intWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Int32");
+                intWriteVal.AttributeId = Attributes.Value;
+                intWriteVal.Value = new DataValue();
+                intWriteVal.Value.Value = (int)100;
+                nodesToWrite.Add(intWriteVal);
+
+                // Float Node - Objects\CTT\Scalar\Scalar_Static\Float
+                WriteValue floatWriteVal = new WriteValue();
+                floatWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_Float");
+                floatWriteVal.AttributeId = Attributes.Value;
+                floatWriteVal.Value = new DataValue();
+                floatWriteVal.Value.Value = (float)100.5;
+                nodesToWrite.Add(floatWriteVal);
+
+                // String Node - Objects\CTT\Scalar\Scalar_Static\String
+                WriteValue stringWriteVal = new WriteValue();
+                stringWriteVal.NodeId = new NodeId("ns=2;s=Scalar_Static_String");
+                stringWriteVal.AttributeId = Attributes.Value;
+                stringWriteVal.Value = new DataValue();
+                stringWriteVal.Value.Value = "String Test";
+                nodesToWrite.Add(stringWriteVal);
+
+                // Write the node attributes
+                StatusCodeCollection results = null;
+                DiagnosticInfoCollection diagnosticInfos;
+                m_output.WriteLine("Writing nodes...");
+
+                // Call Write Service
+                m_session.Write(null,
+                                nodesToWrite,
+                                out results,
+                                out diagnosticInfos);
+
+                // Validate the response
+                m_validateResponse(results, nodesToWrite);
+
+                // Display the results.
+                m_output.WriteLine("Write Results :");
+
+                foreach (StatusCode writeResult in results)
+                {
+                    m_output.WriteLine("     {0}", writeResult);
+                }
             }
             catch (Exception ex)
             {
-                m_output.WriteLine("OnMonitoredItemNotification error: {0}", ex.Message);
+                // Log Error
+                m_output.WriteLine($"Write Nodes Error : {ex.Message}.");
             }
         }
 
+        private readonly TextWriter m_output;
+
+        private readonly Action<IList, IList> m_validateResponse;
+
+        private ApplicationConfiguration m_configuration;
+
+        private Session m_session;
+
         /// <summary>
-        /// Handles the certificate validation event.
-        /// This event is triggered every time an untrusted certificate is received from the server.
+        /// Handles the certificate validation event. This event is triggered every time an
+        /// untrusted certificate is received from the server.
         /// </summary>
         private void CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
         {
             bool certificateAccepted = false;
 
-            // ****
-            // Implement a custom logic to decide if the certificate should be
-            // accepted or not and set certificateAccepted flag accordingly.
-            // The certificate can be retrieved from the e.Certificate field
-            // ***
+            // **** Implement a custom logic to decide if the certificate should be accepted or not
+            // and set certificateAccepted flag accordingly. The certificate can be retrieved from
+            // the e.Certificate field ***
 
             ServiceResult error = e.Error;
             m_output.WriteLine(error);
@@ -489,13 +466,23 @@ namespace MP.MONO.ADAPTER.OPC
                 m_output.WriteLine("Untrusted Certificate rejected. Subject = {0}", e.Certificate.Subject);
             }
         }
-        #endregion
 
-        #region Private Fields
-        private ApplicationConfiguration m_configuration;
-        private Session m_session;
-        private readonly TextWriter m_output;
-        private readonly Action<IList, IList> m_validateResponse;
-        #endregion
+        /// <summary>
+        /// Handle DataChange notifications from Server
+        /// </summary>
+        private void OnMonitoredItemNotification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
+        {
+            try
+            {
+                // Log MonitoredItem Notification event
+                MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
+                m_output.WriteLine("Notification Received for Variable \"{0}\" and Value = {1}.", monitoredItem.DisplayName, notification.Value);
+            }
+            catch (Exception ex)
+            {
+                m_output.WriteLine("OnMonitoredItemNotification error: {0}", ex.Message);
+            }
+        }
+
     }
-}
+}
\ No newline at end of file
diff --git a/MP.MONO.ADAPTER.OPC/appsettings.json b/MP.MONO.ADAPTER.OPC/appsettings.json
new file mode 100644
index 0000000..1a2f987
--- /dev/null
+++ b/MP.MONO.ADAPTER.OPC/appsettings.json
@@ -0,0 +1,49 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "Redis": "nkcredis.steamware.net:6379,DefaultDatabase=7,connectTimeout=5000,syncTimeout=5000,asyncTimeout=5000,abortConnect=false,ssl=false,password=nkc.password",
+    "AuthConnection": "Server=localhost;port=3306;database=GWMS;user=GWMS;pwd=GWMS_secret_pwd;sslmode=None;",
+    "DefaultConnection": "Server=localhost;port=3306;database=MAPO.MONO;user=GWMS;pwd=GWMS_secret_pwd;sslmode=None;",
+    "AdminConnection": "Server=localhost;port=3306;database=MAPO.MONO;user=root;pwd=Egalware_24068!;sslmode=None;",
+    "MP.MONO.Data": "Server=localhost;port=3306;database=MAPO.MONO;user=GWMS;pwd=GWMS_secret_pwd;sslmode=None;"
+  },
+  "DbConfig": {
+    "Server": "10.74.82.230",
+    "nKey": "MONO",
+    "sKey": "Calcium0xide-CaO"
+  },
+  "MachineId": 1,
+  "maxRecord": 15,
+  "ExternalProviders": {
+    "MailKit": {
+      "SMTP": {
+        "Address": "smtp.gmail.com",
+        "Port": "465",
+        "Account": "steamwarebot@gmail.com",
+        "Password": "drmfsls16",
+        "SenderEmail": "steamwarebot@gmail.com",
+        "SenderName": "Steamware Email BOT"
+      }
+    }
+  },
+  "Endpoint": {
+    "IpAddress": "192.168.0.2",
+    "Port": "4840",
+    "PingMsTimeout": 1500
+  },
+  "ENABLE_DATA_FILTER": true,
+  "ENABLE_CLI_RESTART": true,
+  "logEvery": 10,
+  "OPC_PARAM_CONF": "MULTIAX.json",
+  "pingTestSec": 5,
+  "verbose": false,
+  "disconMaxSec": 30,
+  "verboseLogTOut": 60,
+  "waitRecMSec": 60000
+}
diff --git a/MP.MONO.ADAPTER.OPC2/MP - Backup.MONO.ADAPTER.OPC.csproj b/MP.MONO.ADAPTER.OPC2/MP - Backup.MONO.ADAPTER.OPC.csproj
deleted file mode 100644
index a47c3ec..0000000
--- a/MP.MONO.ADAPTER.OPC2/MP - Backup.MONO.ADAPTER.OPC.csproj	
+++ /dev/null
@@ -1,45 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>$(AppTargetFrameWorks)</TargetFrameworks>
-    <AssemblyName>MP.MONO.ADAPTER.OPC</AssemblyName>
-    <OutputType>Exe</OutputType>
-    <PackageId>MP.MONO.ADAPTER.OPC</PackageId>
-    <Company>EgalWare</Company>
-    <Description>OPC UA Console Client</Description>
-    <Copyright>Copyright © 2020+ EgalWare</Copyright>
-    <RootNamespace>MP.MONO.ADAPTER.OPC</RootNamespace>
-  </PropertyGroup>
-
-  <ItemGroup Condition=" '$(NoHttps)' != 'true' ">
-    <ProjectReference Include="..\..\Stack\Opc.Ua.Bindings.Https\Opc.Ua.Bindings.Https.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Include="..\ConsoleReferenceServer\ConsoleUtils.cs" Exclude="bin\**;obj\**;**\*.xproj;packages\**" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
-    <PackageReference Include="Mono.Options" Version="6.12.0.148" />
-    <PackageReference Include="Serilog" Version="2.10.0" />
-    <PackageReference Include="Serilog.Expressions" Version="3.3.0" />
-    <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
-    <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
-    <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
-    <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\Stack\Opc.Ua.Core\Opc.Ua.Core.csproj" />
-    <ProjectReference Include="..\..\Libraries\Opc.Ua.Configuration\Opc.Ua.Configuration.csproj" />
-    <ProjectReference Include="..\..\Libraries\Opc.Ua.Client\Opc.Ua.Client.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="MP.MONO.ADAPTER.OPC.Config.xml">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>
diff --git a/MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.Config.xml b/MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.Config.xml
deleted file mode 100644
index bbf98d0..0000000
--- a/MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.Config.xml
+++ /dev/null
@@ -1,89 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ApplicationConfiguration
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xmlns:ua="http://opcfoundation.org/UA/2008/02/Types.xsd"
-  xmlns="http://opcfoundation.org/UA/SDK/Configuration.xsd"
->
-  <ApplicationName>Quickstart Console Reference Client</ApplicationName>
-  <ApplicationUri>urn:localhost:UA:Quickstarts:ReferenceClient</ApplicationUri>
-  <ProductUri>uri:opcfoundation.org:Quickstarts:ReferenceClient</ProductUri>
-  <ApplicationType>Client_1</ApplicationType>
-  
-  <SecurityConfiguration>
-
-    <!-- Where the application instance certificate is stored (MachineDefault) -->
-    <ApplicationCertificate>
-      <StoreType>Directory</StoreType>
-      <StorePath>%LocalApplicationData%/OPC Foundation/pki/own</StorePath>
-      <SubjectName>CN=Console Reference Client, C=US, S=Arizona, O=OPC Foundation, DC=localhost</SubjectName>
-    </ApplicationCertificate>
-
-   <!-- Where the issuer certificate are stored (certificate authorities) -->
-    <TrustedIssuerCertificates>
-      <StoreType>Directory</StoreType>
-      <StorePath>%LocalApplicationData%/OPC Foundation/pki/issuer</StorePath>
-    </TrustedIssuerCertificates>
-
-    <!-- Where the trust list is stored -->
-    <TrustedPeerCertificates>
-      <StoreType>Directory</StoreType>
-      <StorePath>%LocalApplicationData%/OPC Foundation/pki/trusted</StorePath>
-    </TrustedPeerCertificates>
-
-    <!-- The directory used to store invalid certficates for later review by the administrator. -->
-    <RejectedCertificateStore>
-      <StoreType>Directory</StoreType>
-      <StorePath>%LocalApplicationData%/OPC Foundation/pki/rejected</StorePath>
-    </RejectedCertificateStore>
-
-    <!-- WARNING: The following setting (to automatically accept untrusted certificates) should be used
-    for easy debugging purposes ONLY and turned off for production deployments! -->
-    <AutoAcceptUntrustedCertificates>false</AutoAcceptUntrustedCertificates>
-  
-  </SecurityConfiguration>
-  
-  <TransportConfigurations></TransportConfigurations>
-  
-  <TransportQuotas>
-    <OperationTimeout>600000</OperationTimeout>
-    <MaxStringLength>1048576</MaxStringLength>
-    <MaxByteStringLength>1048576</MaxByteStringLength>
-    <MaxArrayLength>65535</MaxArrayLength>
-    <MaxMessageSize>4194304</MaxMessageSize>
-    <MaxBufferSize>65535</MaxBufferSize>
-    <ChannelLifetime>300000</ChannelLifetime>
-    <SecurityTokenLifetime>3600000</SecurityTokenLifetime>
-  </TransportQuotas>
-
-  <ClientConfiguration>
-    <DefaultSessionTimeout>60000</DefaultSessionTimeout>
-    <WellKnownDiscoveryUrls>
-      <ua:String>opc.tcp://{0}:4840</ua:String>
-      <ua:String>http://{0}:52601/UADiscovery</ua:String>
-      <ua:String>http://{0}/UADiscovery/Default.svc</ua:String>
-    </WellKnownDiscoveryUrls>
-    <DiscoveryServers></DiscoveryServers>
-    <MinSubscriptionLifetime>10000</MinSubscriptionLifetime>
-  </ClientConfiguration>
-
-  <Extensions>
-  </Extensions>
-
-  <TraceConfiguration>
-    <OutputFilePath>%LocalApplicationData%/OPC Foundation/Logs/Quickstarts.ReferenceClient.log.txt</OutputFilePath>
-    <DeleteOnLoad>true</DeleteOnLoad>
-    <!-- Show Only Errors -->
-    <!-- <TraceMasks>1</TraceMasks> -->
-    <!-- Show Only Security and Errors -->
-    <!-- <TraceMasks>513</TraceMasks> -->
-    <!-- Show Only Security, Errors and Trace -->
-    <!-- <TraceMasks>515</TraceMasks> -->
-    <!-- Show Only Security, COM Calls, Errors and Trace -->
-    <!-- <TraceMasks>771</TraceMasks> -->
-    <!-- Show Only Security, Service Calls, Errors and Trace -->
-    <!-- <TraceMasks>523</TraceMasks> -->
-    <!-- Show Only Security, ServiceResultExceptions, Errors and Trace -->
-    <!-- <TraceMasks>519</TraceMasks> -->
-  </TraceConfiguration>
-  
-</ApplicationConfiguration>
\ No newline at end of file
diff --git a/MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.csproj b/MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.csproj
deleted file mode 100644
index a47c3ec..0000000
--- a/MP.MONO.ADAPTER.OPC2/MP.MONO.ADAPTER.OPC.csproj
+++ /dev/null
@@ -1,45 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>$(AppTargetFrameWorks)</TargetFrameworks>
-    <AssemblyName>MP.MONO.ADAPTER.OPC</AssemblyName>
-    <OutputType>Exe</OutputType>
-    <PackageId>MP.MONO.ADAPTER.OPC</PackageId>
-    <Company>EgalWare</Company>
-    <Description>OPC UA Console Client</Description>
-    <Copyright>Copyright © 2020+ EgalWare</Copyright>
-    <RootNamespace>MP.MONO.ADAPTER.OPC</RootNamespace>
-  </PropertyGroup>
-
-  <ItemGroup Condition=" '$(NoHttps)' != 'true' ">
-    <ProjectReference Include="..\..\Stack\Opc.Ua.Bindings.Https\Opc.Ua.Bindings.Https.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Include="..\ConsoleReferenceServer\ConsoleUtils.cs" Exclude="bin\**;obj\**;**\*.xproj;packages\**" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
-    <PackageReference Include="Mono.Options" Version="6.12.0.148" />
-    <PackageReference Include="Serilog" Version="2.10.0" />
-    <PackageReference Include="Serilog.Expressions" Version="3.3.0" />
-    <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
-    <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
-    <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
-    <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\Stack\Opc.Ua.Core\Opc.Ua.Core.csproj" />
-    <ProjectReference Include="..\..\Libraries\Opc.Ua.Configuration\Opc.Ua.Configuration.csproj" />
-    <ProjectReference Include="..\..\Libraries\Opc.Ua.Client\Opc.Ua.Client.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="MP.MONO.ADAPTER.OPC.Config.xml">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>
diff --git a/MP.MONO.ADAPTER.OPC2/Program.cs b/MP.MONO.ADAPTER.OPC2/Program.cs
deleted file mode 100644
index a949e0d..0000000
--- a/MP.MONO.ADAPTER.OPC2/Program.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-/* ========================================================================
- * Copyright (c) 2005-2021 The OPC Foundation, Inc. All rights reserved.
- *
- * OPC Foundation MIT License 1.00
- * 
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- *
- * The complete license agreement can be found here:
- * http://opcfoundation.org/License/MIT/1.00/
- * ======================================================================*/
-
-using System;
-using System.Globalization;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
-using Opc.Ua;
-using Opc.Ua.Configuration;
-
-namespace MP.MONO.ADAPTER.OPC
-{
-    /// <summary>
-    /// The program.
-    /// </summary>
-    public static class Program
-    {
-        /// <summary>
-        /// Main entry point.
-        /// </summary>
-        public static async Task Main(string[] args)
-        {
-            TextWriter output = Console.Out;
-            output.WriteLine("OPC UA Console Reference Client");
-
-            output.WriteLine("OPC UA library: {0} @ {1} -- {2}",
-                Utils.GetAssemblyBuildNumber(),
-                Utils.GetAssemblyTimestamp().ToString("G", CultureInfo.InvariantCulture),
-                Utils.GetAssemblySoftwareVersion());
-
-            // The application name and config file names
-            var applicationName = "ConsoleReferenceClient";
-            var configSectionName = "Quickstarts.ReferenceClient";
-            var usage = $"Usage: dotnet {applicationName}.dll [OPTIONS]";
-
-            // command line options
-            bool showHelp = false;
-            bool autoAccept = false;
-            bool logConsole = false;
-            bool appLog = false;
-            bool renewCertificate = false;
-            string password = null;
-            int timeout = Timeout.Infinite;
-
-            Mono.Options.OptionSet options = new Mono.Options.OptionSet {
-                usage,
-                { "h|help", "show this message and exit", h => showHelp = h != null },
-                { "a|autoaccept", "auto accept certificates (for testing only)", a => autoAccept = a != null },
-                { "c|console", "log to console", c => logConsole = c != null },
-                { "l|log", "log app output", c => appLog = c != null },
-                { "p|password=", "optional password for private key", (string p) => password = p },
-                { "r|renew", "renew application certificate", r => renewCertificate = r != null },
-                { "t|timeout=", "timeout in seconds to exit application", (int t) => timeout = t * 1000 },
-            };
-
-            try
-            {
-                // parse command line and set options
-                var extraArg = ConsoleUtils.ProcessCommandLine(output, args, options, ref showHelp, false);
-
-                // connect Url?
-                Uri serverUrl = new Uri("opc.tcp://localhost:62541/Quickstarts/ReferenceServer");
-                if (!string.IsNullOrEmpty(extraArg))
-                {
-                    serverUrl = new Uri(extraArg);
-                }
-
-                // log console output to logger
-                if (logConsole && appLog)
-                {
-                    output = new LogWriter();
-                }
-
-                // Define the UA Client application
-                ApplicationInstance.MessageDlg = new ApplicationMessageDlg(output);
-                CertificatePasswordProvider PasswordProvider = new CertificatePasswordProvider(password);
-                ApplicationInstance application = new ApplicationInstance {
-                    ApplicationName = applicationName,
-                    ApplicationType = ApplicationType.Client,
-                    ConfigSectionName = configSectionName,
-                    CertificatePasswordProvider = PasswordProvider
-                };
-
-                // load the application configuration.
-                var config = await application.LoadApplicationConfiguration(silent: false);
-
-                // setup the logging
-                ConsoleUtils.ConfigureLogging(config, applicationName, logConsole, LogLevel.Information);
-
-                // delete old certificate
-                if (renewCertificate)
-                {
-                    await application.DeleteApplicationInstanceCertificate().ConfigureAwait(false);
-                }
-
-                // check the application certificate.
-                bool haveAppCertificate = await application.CheckApplicationInstanceCertificate(false, minimumKeySize: 0).ConfigureAwait(false);
-                if (!haveAppCertificate)
-                {
-                    throw new ErrorExitException("Application instance certificate invalid!", ExitCode.ErrorCertificate);
-                }
-
-                // wait for timeout or Ctrl-C
-                var quitEvent = ConsoleUtils.CtrlCHandler();
-
-                // connect to a server until application stopped
-                bool quit = false;
-                DateTime start = DateTime.UtcNow;
-                int waitTime = int.MaxValue;
-                do
-                {
-                    if (timeout > 0)
-                    {
-                        waitTime = timeout - (int)DateTime.UtcNow.Subtract(start).TotalMilliseconds;
-                        if (waitTime <= 0)
-                        {
-                            break;
-                        }
-                    }
-
-                    // create the UA Client object and connect to configured server.
-                    UAClient uaClient = new UAClient(application.ApplicationConfiguration, output, ClientBase.ValidateResponse) {
-                        AutoAccept = autoAccept
-                    };
-
-                    bool connected = await uaClient.ConnectAsync(serverUrl.ToString());
-                    if (connected)
-                    {
-                        // Run tests for available methods.
-                        uaClient.ReadNodes();
-                        uaClient.WriteNodes();
-                        uaClient.Browse();
-                        uaClient.CallMethod();
-
-                        uaClient.SubscribeToDataChanges();
-
-                        // Wait for some DataChange notifications from MonitoredItems
-                        quit = quitEvent.WaitOne(Math.Min(30_000, waitTime));
-
-                        uaClient.Disconnect();
-                    }
-                    else
-                    {
-                        output.WriteLine("Could not connect to server! Retry in 10 seconds or Ctrl-C to quit.");
-                        quit = quitEvent.WaitOne(Math.Min(10_000, waitTime));
-                    }
-
-                } while (!quit);
-
-                output.WriteLine("\nClient stopped.");
-            }
-            catch (Exception ex)
-            {
-                output.WriteLine(ex.Message);
-            }
-        }
-    }
-}
diff --git a/MP.MONO.ADAPTER.OPC2/dotnettrace.cmd b/MP.MONO.ADAPTER.OPC2/dotnettrace.cmd
deleted file mode 100644
index 2d31776..0000000
--- a/MP.MONO.ADAPTER.OPC2/dotnettrace.cmd
+++ /dev/null
@@ -1,3 +0,0 @@
-REM collect a trace using the EventSource provider OPC-UA-Core
-dotnet tool install --global dotnet-trace
-dotnet-trace collect --name consolereferenceclient --providers OPC-UA-Core,OPC-UA-Client
diff --git a/MP.MONO.ADAPTER.OPC2/targets.props b/MP.MONO.ADAPTER.OPC2/targets.props
deleted file mode 100644
index 258a154..0000000
--- a/MP.MONO.ADAPTER.OPC2/targets.props
+++ /dev/null
@@ -1,44 +0,0 @@
-<Project>
-  <!-- Uncomment to suppress warning that .NET Core 2.1 is used with .NET 6 library. -->
-  <!--
-  <PropertyGroup>
-    <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
-  </PropertyGroup>
-  -->
-  <Choose>
-    <!-- Note: .NET Core 2.x is end of life, removed netcoreapp2.1 from any target. -->
-    <!-- Visual Studio 2022, supports .NET Framework 4.6.2, .NET Core 3.1 and .NET 6 -->
-    <When  Condition="'$(VisualStudioVersion)' == '17.0'">
-      <PropertyGroup>
-        <AppTargetFrameworks>net6.0;netcoreapp3.1;net462</AppTargetFrameworks>
-        <AppTargetFramework>net6.0</AppTargetFramework>
-        <TestsTargetFrameworks>net462;netcoreapp3.1;net6.0</TestsTargetFrameworks>
-        <LibTargetFrameworks>net462;netstandard2.0;netstandard2.1;net6.0</LibTargetFrameworks>
-        <LibxTargetFrameworks>net462;netstandard2.1;net6.0</LibxTargetFrameworks>
-        <HttpsTargetFrameworks>net462;netstandard2.0;netcoreapp3.1;net6.0</HttpsTargetFrameworks>
-      </PropertyGroup>
-    </When>
-    <!-- Visual Studio 2019, supports .NET Framework 4.6.2 and .NET Core 3.1 -->
-    <When  Condition="'$(VisualStudioVersion)' == '16.0'">
-      <PropertyGroup>
-        <AppTargetFrameworks>netcoreapp3.1;net462</AppTargetFrameworks>
-        <AppTargetFramework>netcoreapp3.1</AppTargetFramework>
-        <TestsTargetFrameworks>net462;netcoreapp3.1</TestsTargetFrameworks>
-        <LibTargetFrameworks>net462;netstandard2.0;netstandard2.1</LibTargetFrameworks>
-        <LibxTargetFrameworks>net462;netstandard2.1</LibxTargetFrameworks>
-        <HttpsTargetFrameworks>net462;netstandard2.0;netcoreapp3.1</HttpsTargetFrameworks>
-      </PropertyGroup>
-    </When>
-    <!-- Visual Studio 2017 and earlier, support only .NET Framework 4.6.2 because .NET Core 2.x is end of life. -->
-    <Otherwise>
-      <PropertyGroup>
-        <AppTargetFrameworks>net462</AppTargetFrameworks>
-        <AppTargetFramework>net462</AppTargetFramework>
-        <TestsTargetFrameworks>net462</TestsTargetFrameworks>
-        <LibTargetFrameworks>net462</LibTargetFrameworks>
-        <LibxTargetFrameworks>net462</LibxTargetFrameworks>
-        <HttpsTargetFrameworks>net462</HttpsTargetFrameworks>
-      </PropertyGroup>
-    </Otherwise>
-  </Choose>
-</Project>
diff --git a/MP.MONO.ALL.sln b/MP.MONO.ALL.sln
index f19dea8..ff7a877 100644
--- a/MP.MONO.ALL.sln
+++ b/MP.MONO.ALL.sln
@@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MP.MONO.DECODER", "MP.MONO.
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MP.MONO.ANALYZER", "MP.MONO.ANALYZER\MP.MONO.ANALYZER.csproj", "{4C9BEAED-1A33-41A7-B9D6-7C173A43FDB8}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MP.MONO.ADAPTER.OPC", "MP.MONO.ADAPTER.OPC\MP.MONO.ADAPTER.OPC.csproj", "{FA236252-9AF8-426A-8A0A-D3C234441563}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -97,6 +99,18 @@ Global
 		{4C9BEAED-1A33-41A7-B9D6-7C173A43FDB8}.Release|x64.Build.0 = Release|x64
 		{4C9BEAED-1A33-41A7-B9D6-7C173A43FDB8}.Release|x86.ActiveCfg = Release|x86
 		{4C9BEAED-1A33-41A7-B9D6-7C173A43FDB8}.Release|x86.Build.0 = Release|x86
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Debug|x64.Build.0 = Debug|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Debug|x86.Build.0 = Debug|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Release|x64.ActiveCfg = Release|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Release|x64.Build.0 = Release|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Release|x86.ActiveCfg = Release|Any CPU
+		{FA236252-9AF8-426A-8A0A-D3C234441563}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/MP.MONO.ANALYZER/MP.MONO.ANALYZER.csproj b/MP.MONO.ANALYZER/MP.MONO.ANALYZER.csproj
index 5b4b903..c82a21b 100644
--- a/MP.MONO.ANALYZER/MP.MONO.ANALYZER.csproj
+++ b/MP.MONO.ANALYZER/MP.MONO.ANALYZER.csproj
@@ -6,7 +6,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.12206.1319</Version>
+    <Version>1.12206.1419</Version>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/MP.MONO.ANALYZER/Resources/ChangeLog.html b/MP.MONO.ANALYZER/Resources/ChangeLog.html
index a7c264c..8615ea8 100644
--- a/MP.MONO.ANALYZER/Resources/ChangeLog.html
+++ b/MP.MONO.ANALYZER/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>MAPO-MONO</i>
-    <h4>Version: 1.12206.1319</h4>
+    <h4>Version: 1.12206.1419</h4>
     <br /> Release Note:
     <ul>
         <li>
diff --git a/MP.MONO.ANALYZER/Resources/VersNum.txt b/MP.MONO.ANALYZER/Resources/VersNum.txt
index 4ebdb53..9337bce 100644
--- a/MP.MONO.ANALYZER/Resources/VersNum.txt
+++ b/MP.MONO.ANALYZER/Resources/VersNum.txt
@@ -1 +1 @@
-1.12206.1319
+1.12206.1419
diff --git a/MP.MONO.ANALYZER/Resources/manifest.xml b/MP.MONO.ANALYZER/Resources/manifest.xml
index 722a5c8..cc3ec2c 100644
--- a/MP.MONO.ANALYZER/Resources/manifest.xml
+++ b/MP.MONO.ANALYZER/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.12206.1319</version>
+  <version>1.12206.1419</version>
   <url>http://nexus.steamware.net/repository/SWS/MP.MONO.ANALYZER/stable/LAST/MP.Mon.zip</url>
   <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.ANALYZER/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>
diff --git a/MP.MONO.Core/CONF/MachDataItem.cs b/MP.MONO.Core/CONF/MachDataItem.cs
new file mode 100644
index 0000000..ddae228
--- /dev/null
+++ b/MP.MONO.Core/CONF/MachDataItem.cs
@@ -0,0 +1,51 @@
+using static MP.MONO.Core.Enums;
+
+namespace MP.MONO.Core.CONF
+{
+    /// <summary>
+    /// Descrittore oggetto DataItem generico
+    /// </summary>
+    public class MachDataItem
+    {
+        #region Public Constructors
+
+        public MachDataItem()
+        { }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// Categoria oggetto
+        /// </summary>
+        public DataItemCategory Category { get; set; }
+
+        /// <summary>
+        /// Nome / descrizione
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Tipologia specifica
+        /// </summary>
+        public string SubType { get; set; }
+
+        /// <summary>
+        /// Tipologia principale
+        /// </summary>
+        public string Type { get; set; }
+
+        /// <summary>
+        /// Unità di misura
+        /// </summary>
+        public string Units { get; set; }
+
+        /// <summary>
+        /// ID generico
+        /// </summary>
+        public string uuid { get; set; }
+
+        #endregion Public Properties
+    }
+}
\ No newline at end of file
diff --git a/MP.MONO.Core/Enums.cs b/MP.MONO.Core/Enums.cs
index 47b0b80..5f3dbb3 100644
--- a/MP.MONO.Core/Enums.cs
+++ b/MP.MONO.Core/Enums.cs
@@ -20,6 +20,16 @@
             OR
         }
 
+        /// <summary>
+        /// Categoria dataItem
+        /// </summary>
+        public enum DataItemCategory
+        {
+            CONDITION = 0,
+            EVENT = 1,
+            SAMPLE = 2
+        }
+
         /// <summary>
         /// ENUM degli stati (es path OPC-UA)
         /// </summary>
diff --git a/MP.MONO.DECODER/MP.MONO.DECODER.csproj b/MP.MONO.DECODER/MP.MONO.DECODER.csproj
index fe8cc55..95332fc 100644
--- a/MP.MONO.DECODER/MP.MONO.DECODER.csproj
+++ b/MP.MONO.DECODER/MP.MONO.DECODER.csproj
@@ -6,7 +6,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.12206.1319</Version>
+    <Version>1.12206.1419</Version>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/MP.MONO.DECODER/Resources/ChangeLog.html b/MP.MONO.DECODER/Resources/ChangeLog.html
index a7c264c..8615ea8 100644
--- a/MP.MONO.DECODER/Resources/ChangeLog.html
+++ b/MP.MONO.DECODER/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>MAPO-MONO</i>
-    <h4>Version: 1.12206.1319</h4>
+    <h4>Version: 1.12206.1419</h4>
     <br /> Release Note:
     <ul>
         <li>
diff --git a/MP.MONO.DECODER/Resources/VersNum.txt b/MP.MONO.DECODER/Resources/VersNum.txt
index 4ebdb53..9337bce 100644
--- a/MP.MONO.DECODER/Resources/VersNum.txt
+++ b/MP.MONO.DECODER/Resources/VersNum.txt
@@ -1 +1 @@
-1.12206.1319
+1.12206.1419
diff --git a/MP.MONO.DECODER/Resources/manifest.xml b/MP.MONO.DECODER/Resources/manifest.xml
index 4c9beef..bd3dc7e 100644
--- a/MP.MONO.DECODER/Resources/manifest.xml
+++ b/MP.MONO.DECODER/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.12206.1319</version>
+  <version>1.12206.1419</version>
   <url>http://nexus.steamware.net/repository/SWS/MP.MONO.DECODER/stable/LAST/MP.Mon.zip</url>
   <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.DECODER/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>
diff --git a/MP.MONO.SIM/MP.MONO.SIM.csproj b/MP.MONO.SIM/MP.MONO.SIM.csproj
index 50128bf..9448581 100644
--- a/MP.MONO.SIM/MP.MONO.SIM.csproj
+++ b/MP.MONO.SIM/MP.MONO.SIM.csproj
@@ -6,7 +6,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.12206.1319</Version>
+    <Version>1.12206.1419</Version>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/MP.MONO.SIM/Resources/ChangeLog.html b/MP.MONO.SIM/Resources/ChangeLog.html
index a7c264c..8615ea8 100644
--- a/MP.MONO.SIM/Resources/ChangeLog.html
+++ b/MP.MONO.SIM/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>MAPO-MONO</i>
-    <h4>Version: 1.12206.1319</h4>
+    <h4>Version: 1.12206.1419</h4>
     <br /> Release Note:
     <ul>
         <li>
diff --git a/MP.MONO.SIM/Resources/VersNum.txt b/MP.MONO.SIM/Resources/VersNum.txt
index 4ebdb53..9337bce 100644
--- a/MP.MONO.SIM/Resources/VersNum.txt
+++ b/MP.MONO.SIM/Resources/VersNum.txt
@@ -1 +1 @@
-1.12206.1319
+1.12206.1419
diff --git a/MP.MONO.SIM/Resources/manifest.xml b/MP.MONO.SIM/Resources/manifest.xml
index c2c609f..10be56b 100644
--- a/MP.MONO.SIM/Resources/manifest.xml
+++ b/MP.MONO.SIM/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.12206.1319</version>
+  <version>1.12206.1419</version>
   <url>http://nexus.steamware.net/repository/SWS/MP.MONO.SIM/stable/LAST/MP.Mon.zip</url>
   <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.SIM/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>
diff --git a/MP.MONO.UI/MP.MONO.UI.csproj b/MP.MONO.UI/MP.MONO.UI.csproj
index ad0b53e..655039d 100644
--- a/MP.MONO.UI/MP.MONO.UI.csproj
+++ b/MP.MONO.UI/MP.MONO.UI.csproj
@@ -5,7 +5,7 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <Platforms>AnyCPU;x86;x64</Platforms>
-    <Version>1.12206.1411</Version>
+    <Version>1.12206.1419</Version>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/MP.MONO.UI/Resources/ChangeLog.html b/MP.MONO.UI/Resources/ChangeLog.html
index e755785..8615ea8 100644
--- a/MP.MONO.UI/Resources/ChangeLog.html
+++ b/MP.MONO.UI/Resources/ChangeLog.html
@@ -1,6 +1,6 @@
 <body>
     <i>MAPO-MONO</i>
-    <h4>Version: 1.12206.1411</h4>
+    <h4>Version: 1.12206.1419</h4>
     <br /> Release Note:
     <ul>
         <li>
diff --git a/MP.MONO.UI/Resources/VersNum.txt b/MP.MONO.UI/Resources/VersNum.txt
index b7e1283..9337bce 100644
--- a/MP.MONO.UI/Resources/VersNum.txt
+++ b/MP.MONO.UI/Resources/VersNum.txt
@@ -1 +1 @@
-1.12206.1411
+1.12206.1419
diff --git a/MP.MONO.UI/Resources/manifest.xml b/MP.MONO.UI/Resources/manifest.xml
index d55cab2..69323c6 100644
--- a/MP.MONO.UI/Resources/manifest.xml
+++ b/MP.MONO.UI/Resources/manifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <item>
-  <version>1.12206.1411</version>
+  <version>1.12206.1419</version>
   <url>http://nexus.steamware.net/repository/SWS/MP.MONO.UI/stable/LAST/MP.Mon.zip</url>
   <changelog>http://nexus.steamware.net/repository/SWS/MP.MONO.UI/stable/LAST/ChangeLog.html</changelog>
   <mandatory>false</mandatory>