Samuele Locatelli
1863 lines
80 KiB
C#
1863 lines
80 KiB
C#
using NLog;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Client;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace IOB_WIN_NEXT
|
|
{
|
|
/// <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>
|
|
public class UAClient
|
|
{
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the UAClient class.
|
|
/// </summary>
|
|
/// <param name="configuration"></param>
|
|
/// <param name="codIOB"></param>
|
|
/// <param name="user"></param>
|
|
/// <param name="pwd"></param>
|
|
/// <param name="verboseLog"></param>
|
|
/// <param name="validateResponse"></param>
|
|
/// <param name="maxNullRead">Numero massimo di risposte nulle in browsing prima di disconnettersi</param>
|
|
public UAClient(ApplicationConfiguration configuration, string codIOB, string user, string pwd, bool verboseLog, Action<IList, IList> validateResponse, int maxNullRead)
|
|
{
|
|
currNullReceiv = 0;
|
|
maxNullAllowed = maxNullRead;
|
|
m_validateResponse = validateResponse;
|
|
currIob = codIOB;
|
|
lg = LogManager.GetCurrentClassLogger();
|
|
if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(pwd))
|
|
{
|
|
CurrUserIdentity = new UserIdentity(user, pwd);
|
|
}
|
|
else
|
|
{
|
|
CurrUserIdentity = new UserIdentity();
|
|
}
|
|
isLogVerbose = verboseLog;
|
|
m_configuration = configuration;
|
|
m_configuration.CertificateValidator.CertificateValidation += CertificateValidation;
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Events
|
|
|
|
/// <summary>
|
|
/// Evento notifica variazione MonitoredItem
|
|
/// </summary>
|
|
public event EventHandler<opcUaMonitItemChange> eh_MonItChange;
|
|
|
|
/// <summary>
|
|
/// Evento notifica superamento numero letture null
|
|
/// </summary>
|
|
public event EventHandler<int> eh_nullExceed;
|
|
|
|
#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;
|
|
|
|
#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)
|
|
{
|
|
lgError("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
|
|
lgTrace($"Browsing {nodeToBrowse} node...");
|
|
ReferenceDescriptionCollection browseResults = browser.Browse(nodeToBrowse);
|
|
|
|
// Display the results
|
|
lgTrace($"Browse returned {browseResults.Count} results:");
|
|
|
|
foreach (ReferenceDescription result in browseResults)
|
|
{
|
|
lgTrace($" 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
|
|
lgError($"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)
|
|
{
|
|
lgError("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
|
|
lgTrace($"Browsing {nodeToBrowse} node...");
|
|
ReferenceDescriptionCollection browseResults = browser.Browse(nodeToBrowse);
|
|
|
|
// Display the results
|
|
lgTrace($"Browse returned {browseResults.Count} results:");
|
|
|
|
foreach (ReferenceDescription result in browseResults)
|
|
{
|
|
// se veto --> loggo veto
|
|
if (vetoBrowse.Contains($"{result.NodeId}"))
|
|
{
|
|
lgDebug($"FILTER --> 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
|
|
{
|
|
lgDebug($" 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
|
|
lgError($"Browse Error : {ex.Message}");
|
|
}
|
|
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Call UA method
|
|
/// </summary>
|
|
public void CallMethod()
|
|
{
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("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
|
|
lgDebug($"Calling UAMethod for node {methodId} ...");
|
|
outputArguments = m_session.Call(objectId, methodId, inputArguments);
|
|
|
|
// Display results
|
|
lgDebug($"Method call returned {outputArguments.Count} output argument(s):");
|
|
|
|
foreach (var outputArgument in outputArguments)
|
|
{
|
|
lgDebug($" OutputValue = {outputArgument}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
lgError($"Method call error: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a session with the UA server
|
|
/// </summary>
|
|
public async Task<bool> ConnectAsync()
|
|
{
|
|
try
|
|
{
|
|
if (m_session != null && m_session.Connected == true)
|
|
{
|
|
lgInfo("Session already connected!");
|
|
}
|
|
else
|
|
{
|
|
lgInfo("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);
|
|
|
|
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_configuration);
|
|
ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
|
|
|
|
// Create the session
|
|
Session session = await Session.Create(
|
|
m_configuration,
|
|
endpoint,
|
|
true,
|
|
false,
|
|
m_configuration.ApplicationName,
|
|
60 * 60 * 1000,
|
|
CurrUserIdentity,
|
|
null
|
|
);
|
|
|
|
#if false
|
|
Session session = await Session.Create(
|
|
m_configuration,
|
|
endpoint,
|
|
false,
|
|
false,
|
|
m_configuration.ApplicationName,
|
|
60 * 60 * 1000,
|
|
CurrUserIdentity,
|
|
null
|
|
);
|
|
#endif
|
|
|
|
// Assign the created session
|
|
if (session != null && session.Connected)
|
|
{
|
|
m_session = session;
|
|
}
|
|
|
|
// Session created successfully.
|
|
lgInfo($"New Session Created with SessionName = {m_session.SessionName}");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Create Session Error : {ex.Message}");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Disconnects the session.
|
|
/// </summary>
|
|
public void Disconnect()
|
|
{
|
|
try
|
|
{
|
|
if (m_session != null)
|
|
{
|
|
lgInfo("Disconnecting...");
|
|
|
|
m_session.Close();
|
|
m_session.Dispose();
|
|
m_session = null;
|
|
|
|
// Log Session Disconnected event
|
|
lgInfo("Session Disconnected.");
|
|
}
|
|
else
|
|
{
|
|
lgError("Session not created!");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Disconnect Error : {ex.Message}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads a node by node Id
|
|
/// </summary>
|
|
/// <param name="nodeIdString">The node Id as string</param>
|
|
/// <returns>The read node</returns>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
public Node ReadNode(String nodeIdString)
|
|
{
|
|
//Create a nodeId using the identifier string
|
|
NodeId nodeId = new NodeId(nodeIdString);
|
|
//Create a node
|
|
Node node = new Node();
|
|
//Read the dataValue
|
|
node = m_session.ReadNode(nodeId);
|
|
return node;
|
|
}
|
|
|
|
/// <summary>Reads a node by node Id</summary>
|
|
/// <param name="nodeIdString">The node Id as string</param>
|
|
/// <returns>A dictionary containing the attribute values of the node using the attribute uint identifier as key;
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
public Dictionary<uint, DataValue> ReadNodeAttributes(String nodeIdString)
|
|
{
|
|
//Create a nodeId using the identifier string
|
|
NodeId nodeId = new NodeId(nodeIdString);
|
|
return ReadNodeAttributes(nodeId);
|
|
}
|
|
|
|
/// <summary>Reads a node by node Id</summary>
|
|
/// <param name="nodeId">The node Id</param>
|
|
/// <returns>A dictionary containing the attribute values of the node using the attribute uint identifier as key;
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
public Dictionary<uint, DataValue> ReadNodeAttributes(NodeId nodeId)
|
|
{
|
|
Dictionary<int, uint> attributeDictionary = new Dictionary<int, uint>()
|
|
{
|
|
{1, Attributes.NodeId },
|
|
{2, Attributes.NodeClass },
|
|
{3, Attributes.BrowseName },
|
|
{4, Attributes.DisplayName },
|
|
{5, Attributes.Value },
|
|
{6, Attributes.DataType},
|
|
{7, Attributes.ValueRank},
|
|
{8, Attributes.ArrayDimensions},
|
|
{9, Attributes.AccessLevel }
|
|
};
|
|
|
|
//Create a read value id collection to store the nodes to read
|
|
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
|
|
|
|
//Create a StatusCodeCollection
|
|
DataValueCollection dataValueCollection = new DataValueCollection();
|
|
|
|
//Create a DiagnosticInfoCollection
|
|
DiagnosticInfoCollection diag = new DiagnosticInfoCollection();
|
|
|
|
//Go through the attribute dictionary and create the nodes accordingly
|
|
for (int i = 0; i < attributeDictionary.Count; i++)
|
|
{
|
|
///Create a read value id with the nessessary attribute
|
|
ReadValueId nodeToRead = new ReadValueId();
|
|
nodeToRead.NodeId = nodeId;
|
|
nodeToRead.AttributeId = attributeDictionary[i + 1];
|
|
nodesToRead.Add(nodeToRead);
|
|
}
|
|
//Read the read value id collection
|
|
m_session.Read(null, 0, TimestampsToReturn.Neither, nodesToRead, out dataValueCollection, out diag);
|
|
//Create a dictionary to store the attribute values
|
|
Dictionary<uint, DataValue> attributeValues = new Dictionary<uint, DataValue>();
|
|
//Go through the data value collection to store every data value according to its attribute identifier
|
|
int counter = 1;
|
|
foreach (DataValue dataValue in dataValueCollection)
|
|
{
|
|
attributeValues.Add(attributeDictionary[counter], dataValue);
|
|
counter += 1;
|
|
}
|
|
return attributeValues;
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
lgError("Session not connected!");
|
|
numErrors++;
|
|
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
|
|
lgError($"ReadNodeRaw Error 01: {Environment.NewLine}{exc}");
|
|
numErrors++;
|
|
|
|
// provare disconnect?!?
|
|
if (numErrors >= maxErrors)
|
|
{
|
|
numErrors = 0;
|
|
Disconnect();
|
|
}
|
|
}
|
|
|
|
#endregion Read the Value attribute of a node by calling the Session.ReadValue method
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"ReadNodeRaw Error 02: {ex.Message}.");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a list of nodes from Server
|
|
/// </summary>
|
|
public void ReadNodes()
|
|
{
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("Session not connected!");
|
|
return;
|
|
}
|
|
|
|
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
|
|
lgInfo("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)
|
|
{
|
|
lgTrace($"Read Value = {result.Value} , StatusCode = {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
|
|
|
|
// Read Server NamespaceArray
|
|
lgTrace("Reading Value of NamespaceArray node...");
|
|
DataValue namespaceArray = m_session.ReadValue(Variables.Server_NamespaceArray);
|
|
// Display the result
|
|
lgTrace($"NamespaceArray Value = {namespaceArray}");
|
|
|
|
#endregion Read the Value attribute of a node by calling the Session.ReadValue method
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Read Nodes Error : {ex.Message}.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a SINGLE of nodes value from Server
|
|
/// </summary>
|
|
/// <param name="reqNodeId"></param>
|
|
/// <returns>Value as String</returns>
|
|
public string ReadNodeString(NodeId reqNodeId)
|
|
{
|
|
string answ = "";
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("Session not connected!");
|
|
return answ;
|
|
}
|
|
|
|
try
|
|
{
|
|
try
|
|
{
|
|
DataValue resp = m_session.ReadValue(reqNodeId);
|
|
answ = $"{resp.Value}";
|
|
// decremento errore...
|
|
if (numErrors > 0)
|
|
{
|
|
numErrors--;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
// Log Error
|
|
numErrors++;
|
|
lgTrace($"ReadValue Error | reqNodeId: {reqNodeId} | numErrors: {numErrors}{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Read Nodes Error : {ex.Message}.");
|
|
numErrors++;
|
|
}
|
|
// se supero maxErrors --> invio eccezione e resetto...
|
|
if (numErrors >= maxErrors)
|
|
{
|
|
// reset + exception
|
|
numErrors = 0;
|
|
throw new Exception($"Errore lettura OPC-UA: {maxErrors} errori");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>Reads a struct or UDT by node Id</summary>
|
|
/// <param name="nodeIdString">The node Id as strings</param>
|
|
/// <returns>The read struct/UDT elements as a list of string[3]; string[0] = tag name, string[1] = value, string[2] = opc data type</returns>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
public List<string[]> ReadStructUdt(String nodeIdString)
|
|
{
|
|
//Define result list to return var name and var value
|
|
List<string[]> resultStringList = new List<string[]>();
|
|
|
|
//Read the node attributes
|
|
Dictionary<uint, DataValue> nodeAttributes = ReadNodeAttributes(nodeIdString);
|
|
//Create a data value storing the value
|
|
DataValue data = nodeAttributes[Attributes.Value];
|
|
|
|
//Check if the entered node id is of type array and accordingly get the byte array of the data values
|
|
ExtensionObject dataValue = new ExtensionObject();
|
|
List<byte[]> byteArrays = new List<byte[]>();
|
|
if (data.Value is ExtensionObject[])
|
|
{
|
|
foreach (ExtensionObject temp in (ExtensionObject[])data.Value)
|
|
{
|
|
byteArrays.Add((byte[])temp.Body);
|
|
}
|
|
}
|
|
else if (data.Value is ExtensionObject)
|
|
{
|
|
dataValue = (ExtensionObject)data.Value;
|
|
byteArrays.Add((byte[])dataValue.Body);
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("The entered node id is not of tpye struct/udt.");
|
|
}
|
|
|
|
//Get the type dictionary of the struct as a list of string[3]; string[0] = tag name, string[1] = data type, string [2] = array dimensions
|
|
List<string[]> structureDictionary = new List<string[]>();
|
|
DataTypeNode dataTypeNode = (DataTypeNode)ReadNode(nodeAttributes[Attributes.DataType].ToString());
|
|
GetTypeDictionary(dataTypeNode, m_session, structureDictionary);
|
|
|
|
//Get the deserialized byte string as a list of string[4]; string[0]=array index; string[1]=tag name; string[2]=tag value; string[3]=tag data type
|
|
resultStringList = ParseDataToTagsFromDictionary(structureDictionary, byteArrays);
|
|
|
|
//return result as List<string[]> string[0]=array index; string[1]=tag name; string[2]=tag value; string[3]=tag data type
|
|
return resultStringList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create Subscription and MonitoredItems for DataChanges
|
|
/// </summary>
|
|
public List<MonitoredItem> SubscribeToDataChanges(Dictionary<string, string> DataList)
|
|
{
|
|
List<MonitoredItem> monItList = new List<MonitoredItem>();
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("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();
|
|
lgInfo($"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);
|
|
}
|
|
|
|
// Create the monitored items on Server side
|
|
subscription.ApplyChanges();
|
|
lgInfo($"MonitoredItems created for SubscriptionId = {subscription.Id}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
lgError($"Subscribe error: {ex.Message}");
|
|
}
|
|
return monItList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a list of nodes to the Server
|
|
/// </summary>
|
|
/// <param name="node2Write"></param>
|
|
public void WriteNodes(List<WriteValue> node2Write)
|
|
{
|
|
if (node2Write != null)
|
|
{
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("Session not connected!");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Write the configured nodes
|
|
WriteValueCollection nodesToWrite = new WriteValueCollection();
|
|
nodesToWrite.AddRange(node2Write);
|
|
|
|
// Write the node attributes
|
|
StatusCodeCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos;
|
|
lgDebug("Writing nodes...");
|
|
|
|
// Call Write Service
|
|
m_session.Write(null,
|
|
nodesToWrite,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
// Validate the response
|
|
m_validateResponse(results, nodesToWrite);
|
|
|
|
// Display the results.
|
|
lgDebug("Write Results :");
|
|
|
|
foreach (StatusCode writeResult in results)
|
|
{
|
|
lgDebug($" {writeResult}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Write Nodes Error : {ex.Message}");
|
|
numErrors++;
|
|
|
|
// provare disconnect?!?
|
|
if (numErrors >= maxErrors)
|
|
{
|
|
numErrors = 0;
|
|
Disconnect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo scrittura alternativa in formato UDT dei dati...
|
|
/// </summary>
|
|
/// <param name="node2Write"></param>
|
|
public void WriteNodesUdt(string nodeIdString, Dictionary<string, string> data2write)
|
|
{
|
|
if (!string.IsNullOrEmpty(nodeIdString) && data2write != null && data2write.Count > 0)
|
|
{
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("Session not connected!");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
var listUdtRows = new List<string[]>();
|
|
|
|
listUdtRows = new List<string[]>();
|
|
// leggo elenco dati in primis
|
|
listUdtRows = ReadStructUdt(nodeIdString);
|
|
// va scartata ultima riga!!!!
|
|
listUdtRows.RemoveAt(listUdtRows.Count - 1);
|
|
|
|
// sostituzione dei dati: per ogni valore corrente cerco nei valori data2write
|
|
foreach (var item in listUdtRows)
|
|
{
|
|
// se trovo valore da sostituire
|
|
if (data2write.ContainsKey(item[1]))
|
|
{
|
|
item[2] = data2write[item[1]];
|
|
}
|
|
}
|
|
|
|
// scrivo
|
|
WriteStructUdt(nodeIdString, listUdtRows);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Error WriteNodesUdt for {nodeIdString}: {Environment.NewLine}{ex.Message}");
|
|
numErrors++;
|
|
|
|
// provare disconnect?!?
|
|
if (numErrors >= maxErrors)
|
|
{
|
|
numErrors = 0;
|
|
Disconnect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes values to node Ids
|
|
/// </summary>
|
|
/// <param name="valuesByNodeId">Mulitple NodeIds with there values (multiple possible if not a scalar).</param>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
public void WriteValues(Dictionary<NodeId, IEnumerable<string>> valuesByNodeId)
|
|
{
|
|
//Create a collection of values to write
|
|
WriteValueCollection valuesToWrite = new WriteValueCollection();
|
|
|
|
foreach (var keyValuePair in valuesByNodeId)
|
|
{
|
|
NodeId nodeId = keyValuePair.Key;
|
|
IEnumerable<string> values = keyValuePair.Value;
|
|
|
|
//Get the OPC UA data type and the Rank
|
|
Node node = m_session.ReadNode(nodeId);
|
|
VariableNode variableNode = (VariableNode)node.DataLock;
|
|
NodeId datatypeId = variableNode.DataType;
|
|
BuiltInType targetype = TypeInfo.GetBuiltInType(datatypeId);
|
|
|
|
//Ensure that target type is not null by reading the node of the data type id
|
|
if (targetype == BuiltInType.Null)
|
|
{
|
|
try
|
|
{
|
|
//Get the node id of the parent base data type
|
|
NodeId tempNodeId = GetParentDataType(datatypeId, m_session);
|
|
targetype = TypeInfo.GetBuiltInType(tempNodeId);
|
|
if (targetype == BuiltInType.Null)//Ensure that the entered node id is not of type struct
|
|
{
|
|
throw new Exception("The entered node id may be of type struct. Please use the methods for read/write structs.");
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw new Exception("The node id data type is not castable. Please check the data type.");
|
|
}
|
|
|
|
}
|
|
int valueRank = variableNode.ValueRank;
|
|
DataValue dataValue = null;
|
|
|
|
//Check if there is a value entered
|
|
if (!values.Any() || nodeId == null) //no value in the textbox
|
|
{
|
|
throw new Exception("There is no NodeId or value entered.");
|
|
}
|
|
|
|
//Ensure that boolean entries have lower case initial and float, double and long double have the rigth format
|
|
List<string> tempValues = new List<string>();
|
|
if (targetype == BuiltInType.Boolean)
|
|
{
|
|
foreach (string tempValue in values)
|
|
{
|
|
tempValues.Add(tempValue.ToLower());
|
|
}
|
|
values = tempValues;
|
|
}
|
|
if (targetype == BuiltInType.Float || targetype == BuiltInType.Double)
|
|
{
|
|
foreach (string tempValue in values)
|
|
{
|
|
tempValues.Add(tempValue.Replace(',', '.'));
|
|
}
|
|
values = tempValues;
|
|
}
|
|
|
|
//Check if the inputed value has the type matrix or array
|
|
if (valueRank >= ValueRanks.OneDimension)
|
|
{
|
|
//Cast values in the target type
|
|
Array castValues = TypeInfo.CastArray(values.ToArray(), BuiltInType.Null, targetype, (object source, BuiltInType srcType, BuiltInType dstType) => TypeInfo.Cast(source, dstType));
|
|
|
|
if (valueRank == ValueRanks.OneDimension) //Check if inputed value is array
|
|
{
|
|
dataValue = new DataValue(new Variant(castValues, new TypeInfo(targetype, valueRank)));
|
|
}
|
|
else //Inputed value has more then one dimension
|
|
{
|
|
//Get matrix dimensions
|
|
int[] dimensions = new int[valueRank];
|
|
for (int i = 0; i < valueRank; i++)
|
|
{
|
|
dimensions[i] = (int)variableNode.ArrayDimensions[i];
|
|
}
|
|
Matrix matrix = new Matrix(castValues, targetype, dimensions);
|
|
dataValue = new DataValue(new Variant(matrix));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
try //OPC UA data type with type scalar
|
|
{
|
|
dataValue = new DataValue(new Variant(TypeInfo.Cast(values.First(), targetype)));
|
|
}
|
|
catch //no OPC UA data type
|
|
{
|
|
throw new FormatException($"The value inputed [{values.First()}] is not convertable to type {targetype}.");
|
|
}
|
|
}
|
|
//Create a WriteValue using the NodeId, dataValue and attributeType
|
|
WriteValue valueToWrite = new WriteValue()
|
|
{
|
|
Value = dataValue,
|
|
NodeId = nodeId,
|
|
AttributeId = Attributes.Value
|
|
};
|
|
|
|
//Add the dataValues to the collection
|
|
valuesToWrite.Add(valueToWrite);
|
|
}
|
|
|
|
StatusCodeCollection result;
|
|
//Write the collection to the server
|
|
m_session.Write(null, valuesToWrite, out result, out _);
|
|
foreach (StatusCode code in result)
|
|
{
|
|
|
|
lgDebug($" {code}");
|
|
#if false
|
|
if (code != 0)
|
|
{
|
|
throw new Exception(code.ToString());
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a list of nodes to the Server
|
|
/// </summary>
|
|
public void WriteSingleNode(WriteValue node2Write)
|
|
{
|
|
if (node2Write != null)
|
|
{
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("Session not connected!");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Write the configured nodes
|
|
WriteValueCollection nodesToWrite = new WriteValueCollection();
|
|
nodesToWrite.Add(node2Write);
|
|
|
|
// Write the node attributes
|
|
StatusCodeCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos;
|
|
lgDebug("Writing nodes...");
|
|
|
|
// Call Write Service
|
|
m_session.Write(null,
|
|
nodesToWrite,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
// Validate the response
|
|
m_validateResponse(results, nodesToWrite);
|
|
|
|
// Display the results.
|
|
lgDebug("Write Results :");
|
|
|
|
foreach (StatusCode writeResult in results)
|
|
{
|
|
lgDebug($" {writeResult}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Write Nodes Error : {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Writes data to a struct or UDT by node Id</summary>
|
|
/// <param name="nodeIdString">The node Id as strings</param>
|
|
/// <param name="dataToWrite">The data to write as string[3]; string[0] = tag name, string[1] = value, string[2] = opc data type</param>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
public void WriteStructUdt(String nodeIdString, List<string[]> dataToWrite)
|
|
{
|
|
//Create a NodeId from the NodeIdString
|
|
NodeId nodeId = new NodeId(nodeIdString);
|
|
|
|
//Creat a WriteValueColelction
|
|
WriteValueCollection valuesToWrite = new WriteValueCollection();
|
|
|
|
//Create a WriteValue
|
|
WriteValue writevalue = new WriteValue();
|
|
|
|
//Read the node attributes
|
|
Dictionary<uint, DataValue> nodeAttributes = ReadNodeAttributes(nodeIdString);
|
|
//Create a data value storing the value
|
|
DataValue data = nodeAttributes[Attributes.Value];
|
|
|
|
//Check if the entered node id is of type array and accordingly get the byte array(s) of the data values
|
|
ExtensionObject extensionObject = new ExtensionObject();
|
|
List<byte[]> byteArrays = new List<byte[]>();
|
|
if (data.Value is ExtensionObject[])
|
|
{
|
|
foreach (ExtensionObject temp in (ExtensionObject[])data.Value)
|
|
{
|
|
byteArrays.Add((byte[])temp.Body);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
extensionObject = (ExtensionObject)data.Value;
|
|
byteArrays.Add((byte[])extensionObject.Body);
|
|
}
|
|
|
|
//Get the type dictionary of the struct as a list of string[3]; string[0] = tag name, string[1] = data type, string [2] = array dimensions
|
|
List<string[]> structureDictionary = new List<string[]>();
|
|
DataTypeNode dataTypeNode = (DataTypeNode)ReadNode(nodeAttributes[Attributes.DataType].ToString());
|
|
GetTypeDictionary(dataTypeNode, m_session, structureDictionary);
|
|
|
|
//Delete empty list elements in the structure dictionary and in the list of the gui
|
|
for (int j = 0; j < structureDictionary.Count; j++)
|
|
{
|
|
if (structureDictionary[j][1] == "")//Check if the data type entry is empty as this is an indicator for a struct/udt in a struct/udt
|
|
{
|
|
structureDictionary.RemoveAt(j);
|
|
//dataToWrite.RemoveAt(j);
|
|
}
|
|
}
|
|
|
|
//Create a byte array
|
|
List<byte[]> bytesToWrite;
|
|
|
|
//Parse dataToWrite to the byte array
|
|
bytesToWrite = ParseDataToByteArray(dataToWrite, structureDictionary);
|
|
|
|
//Create a StatusCodeCollection
|
|
StatusCodeCollection results = new StatusCodeCollection();
|
|
|
|
//Create a DiagnosticInfoCollection
|
|
DiagnosticInfoCollection diag = new DiagnosticInfoCollection();
|
|
|
|
//Get the structure definition
|
|
StructureDefinition structureDefinition = (StructureDefinition)dataTypeNode.DataTypeDefinition.Body;
|
|
|
|
//Create an ExtensionObject from the Structure given to this function
|
|
ExtensionObject writeExtObj = new ExtensionObject();
|
|
|
|
//Copy the encoding node id to the extension object type id
|
|
writeExtObj.TypeId = structureDefinition.DefaultEncodingId;
|
|
|
|
//Copy data to extension object body
|
|
DataValue dataValue = null;
|
|
|
|
if (bytesToWrite.Count == 1)
|
|
{
|
|
//Copy data to extension object body
|
|
writeExtObj.Body = bytesToWrite[0];
|
|
//Turn the created ExtensionObject into a DataValue
|
|
dataValue = new DataValue(writeExtObj);
|
|
}
|
|
else
|
|
{
|
|
ExtensionObject[] writeExteObjArr = new ExtensionObject[bytesToWrite.Count];
|
|
for (int i = 0; i < bytesToWrite.Count; i++)
|
|
{
|
|
//Create an ExtensionObject from the Structure given to this function
|
|
writeExtObj = new ExtensionObject();
|
|
//Copy data to extension object body
|
|
writeExtObj.TypeId = structureDefinition.DefaultEncodingId;
|
|
writeExtObj.Body = bytesToWrite[i];
|
|
//Copy extension object to extension object array
|
|
writeExteObjArr[i] = writeExtObj;
|
|
}
|
|
//Turn the created ExtensionObject[] into a DataValue
|
|
dataValue = new DataValue(writeExteObjArr);
|
|
}
|
|
//Setup for the WriteValue
|
|
writevalue.NodeId = nodeId;
|
|
writevalue.Value = dataValue;
|
|
writevalue.AttributeId = Attributes.Value;
|
|
//Add the created value to the collection
|
|
valuesToWrite.Add(writevalue);
|
|
|
|
try
|
|
{
|
|
m_session.Write(null, valuesToWrite, out results, out diag);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
//Handle Exception here
|
|
throw e;
|
|
}
|
|
|
|
//Check result codes
|
|
foreach (StatusCode result in results)
|
|
{
|
|
if (result.ToString() != "Good")
|
|
{
|
|
Exception e = new Exception(result.ToString());
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a list of nodes to the Server
|
|
/// </summary>
|
|
public void WriteTestNodes()
|
|
{
|
|
if (m_session == null || m_session.Connected == false)
|
|
{
|
|
lgError("Session not connected!");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
// 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();
|
|
|
|
// 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);
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
// Write the node attributes
|
|
StatusCodeCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos;
|
|
lgDebug("Writing nodes...");
|
|
|
|
// Call Write Service
|
|
m_session.Write(null,
|
|
nodesToWrite,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
// Validate the response
|
|
m_validateResponse(results, nodesToWrite);
|
|
|
|
// Display the results.
|
|
lgDebug("Write Results :");
|
|
|
|
foreach (StatusCode writeResult in results)
|
|
{
|
|
lgDebug($" {writeResult}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Log Error
|
|
lgError($"Write Nodes Error : {ex.Message}.");
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected static bool isLogVerbose = false;
|
|
|
|
protected static Logger lg;
|
|
|
|
protected int currNullReceiv = 0;
|
|
|
|
protected int maxErrors = 20;
|
|
|
|
protected int maxNullAllowed = 100;
|
|
|
|
protected int numErrors = 0;
|
|
|
|
#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.Debug(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>
|
|
/// Browses for the node id of the parent data type of type base data type
|
|
/// </summary>
|
|
/// <param name="nodeId">The data to write as string[4]; string[0] = index, string[1] = tag name, string[2] = value, string[3] = opc data type</param>
|
|
/// <returns>The node id of the parent data type</returns>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
private static NodeId GetParentDataType(NodeId nodeId, Session theSessionToBrowseIn)
|
|
{
|
|
ReferenceDescriptionCollection referenceDescriptionCollection;
|
|
byte[] continuationPoint;
|
|
theSessionToBrowseIn.Browse(null, null, nodeId, 1, BrowseDirection.Inverse, ReferenceTypeIds.HasSubtype, true, 0, out continuationPoint, out referenceDescriptionCollection);
|
|
NodeId nodeIdParentDataType = (NodeId)referenceDescriptionCollection[0].NodeId;
|
|
|
|
if (nodeIdParentDataType.NamespaceIndex != 0)
|
|
{
|
|
nodeIdParentDataType = GetParentDataType(nodeIdParentDataType, theSessionToBrowseIn);
|
|
}
|
|
|
|
return nodeIdParentDataType;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Browses for the desired type dictonary to parse for containing data types
|
|
/// </summary>
|
|
/// <param name="dataTypeNode">The data type node</param>
|
|
/// <param name="theSessionToBrowseIn">The current session to browse in</param>
|
|
/// <param name="structureDictionary">The list of string arrays containing the structure information tag name, data type id and array dimension</param>
|
|
/// <returns>The dictionary as List of string arrays</returns>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
private static List<string[]> GetTypeDictionary(DataTypeNode dataTypeNode, Session theSessionToBrowseIn, List<string[]> structureDictionary)
|
|
{
|
|
//Create a temp list of string containing the structure dictionary
|
|
List<string[]> tempStructureDictionary = new List<string[]>();
|
|
tempStructureDictionary = structureDictionary;
|
|
Session tempSession = theSessionToBrowseIn;
|
|
//Get Structure Definition
|
|
StructureFieldCollection structureFieldCollection = null;
|
|
try
|
|
{
|
|
StructureDefinition structureDefinition = (StructureDefinition)dataTypeNode.DataTypeDefinition.Body;
|
|
structureFieldCollection = (StructureFieldCollection)structureDefinition.Fields;
|
|
}
|
|
catch
|
|
{
|
|
structureDictionary[structureDictionary.Count - 1][1] = UAClient.GetParentDataType(dataTypeNode.NodeId, tempSession).ToString();
|
|
return structureDictionary;
|
|
}
|
|
|
|
//Check every structure field in the collection
|
|
foreach (StructureField structureField in structureFieldCollection)
|
|
{
|
|
if (structureField.DataType.NamespaceIndex != 0) //Check for structures in the structure
|
|
{
|
|
//Create a reference description collection
|
|
ReferenceDescriptionCollection referenceDescriptionCollection;
|
|
//Create a continuationPoint
|
|
byte[] continuationPoint;
|
|
//Browse for the references of the data type of the structure field
|
|
theSessionToBrowseIn.Browse(
|
|
null,
|
|
null,
|
|
structureField.DataType,
|
|
0u,
|
|
BrowseDirection.Both,
|
|
ReferenceTypeIds.References,
|
|
true,
|
|
0,
|
|
out continuationPoint,
|
|
out referenceDescriptionCollection);
|
|
if (((NodeId)referenceDescriptionCollection[0].NodeId).NamespaceIndex == 0)//Data type is sub type of a base data type, i.e. BYTE is a sub tpye of Byte
|
|
{
|
|
//Check if the structure field is an array and parse the dimension to string
|
|
string arrayDimensions = "";
|
|
if (structureField.ValueRank == ValueRanks.OneDimension)
|
|
{
|
|
arrayDimensions = structureField.ArrayDimensions[0].ToString();
|
|
}
|
|
//Add the structure field name, its data type node id and array dimension to the dictionary list
|
|
tempStructureDictionary.Add(new string[] { structureField.Name, ((NodeId)referenceDescriptionCollection[0].NodeId).ToString(), arrayDimensions });
|
|
}
|
|
else//The structure/udt has at least one additional structure/udt inside
|
|
{
|
|
//Read the data type node id of the structure/udt in the parent structure/udt
|
|
DataTypeNode tempDataTypeNode = (DataTypeNode)theSessionToBrowseIn.ReadNode(structureField.DataType.ToString());
|
|
//Enter an empty Line to seperate the inside structure from the parent
|
|
tempStructureDictionary.Add(new string[] { structureField.Name + " - " + "struct/udt of type: " + tempDataTypeNode.DisplayName.ToString(), "", "" });
|
|
//Copy the temp dictionary to the real dictionary
|
|
structureDictionary = tempStructureDictionary;
|
|
//Recursively get the structure of the structure/udt in the parent structure/udt
|
|
GetTypeDictionary(tempDataTypeNode, tempSession, structureDictionary);
|
|
}
|
|
}
|
|
else //The structure field is a base data type
|
|
{
|
|
//Check if the structure field is an array and parse the dimension to string
|
|
string arrayDimensions = "";
|
|
if (structureField.ValueRank == ValueRanks.OneDimension)
|
|
{
|
|
arrayDimensions = structureField.ArrayDimensions[0].ToString();
|
|
}
|
|
//Add the structure field name, its data type node id and array dimension to the dictionary list
|
|
tempStructureDictionary.Add(new string[] { structureField.Name, structureField.DataType.ToString(), arrayDimensions });
|
|
}
|
|
//Copy the temp dictionary to the real dictionary
|
|
structureDictionary = tempStructureDictionary;
|
|
}
|
|
//Add a row for marking the end of the struct/udt
|
|
|
|
structureDictionary.Add(new string[] { "/" + dataTypeNode.DisplayName.ToString(), "", "" });
|
|
return structureDictionary;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses data to write to a list of byte arrays
|
|
/// </summary>
|
|
/// <param name="dataToWrite">The data to write as string[4]; string[0] = index, string[1] = tag name, string[2] = value, string[3] = opc data type</param>
|
|
/// <param name="structureDictionary">The structure of the udt/struct</param>
|
|
/// <returns>The list of the parsed byte arrays</returns>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
private static List<byte[]> ParseDataToByteArray(List<string[]> dataToWrite, List<string[]> structureDictionary)
|
|
{
|
|
//Define result byte list to return a byte array
|
|
List<byte[]> resultByteList = new List<byte[]>();
|
|
|
|
//Dictionary to get the right byte length depending on the data type
|
|
Dictionary<BuiltInType, int> byteLength = new Dictionary<BuiltInType, int>()
|
|
{
|
|
{BuiltInType.Boolean, 1},
|
|
{BuiltInType.Int16, 2},
|
|
{BuiltInType.Int32, 4},
|
|
{BuiltInType.Int64, 8},
|
|
{BuiltInType.UInt16, 2},
|
|
{BuiltInType.UInt32, 4},
|
|
{BuiltInType.UInt64, 8},
|
|
{BuiltInType.Float, 4},
|
|
{BuiltInType.Double, 8},
|
|
{BuiltInType.Byte, 1},
|
|
{BuiltInType.String, 4}
|
|
};
|
|
|
|
//Counter for the structure dictionary browsing
|
|
int tempCounter = 0;
|
|
|
|
//Create byte array to store the data of one array
|
|
byte[] byteArray = new byte[0];
|
|
|
|
//Start decoding for opc data types
|
|
foreach (string[] element in dataToWrite)
|
|
{
|
|
//Reset the counter and the byteArray each time the counter reaches the size of the target Structure/UDT and the data to write include the target Structure/UDT several times
|
|
if (tempCounter == structureDictionary.Count)
|
|
{
|
|
//Add the byte array to the result byte array list
|
|
resultByteList.Add(byteArray);
|
|
|
|
//Reset the counter and the array
|
|
byteArray = new byte[0];
|
|
tempCounter = 0;
|
|
}
|
|
|
|
//Create byte array to store the bytes of one value depending on its data type, hence it is reseted to 0 for each element
|
|
byte[] dataByteArray = new byte[0];
|
|
|
|
//Get the data type id and the target type by using the structure dictionary
|
|
NodeId datatypeId = new NodeId(structureDictionary[tempCounter][1]);
|
|
BuiltInType targetType = TypeInfo.GetBuiltInType(datatypeId);
|
|
|
|
//Get the system type for getting the rigth parse method
|
|
Type systemType = TypeInfo.GetSystemType(datatypeId, null);
|
|
|
|
//Parse array dimension string of the structure dictionary in int32
|
|
Int32 arraySize = 0;
|
|
if (structureDictionary[tempCounter][2] != "")
|
|
{
|
|
arraySize = Int32.Parse(structureDictionary[tempCounter][2]);
|
|
}
|
|
|
|
//Serialize the byte string depending on the target data type and the array size - special if queries are needed for byte and string
|
|
if (targetType == BuiltInType.String && !(arraySize > 0))
|
|
{
|
|
//Resize the data byte array to its correct size depending on the byte length of target type by using the dictionary
|
|
dataByteArray = new byte[byteLength[targetType]];
|
|
//Get the bytes of the string length and copy them to the beginning of the data byte array
|
|
Array.Copy(BitConverter.GetBytes(element[2].Length), 0, dataByteArray, 0, byteLength[targetType]);
|
|
//Convert the string to byte and concat them to the data byte array by converting every char of the string
|
|
foreach (Char c in element[2])
|
|
{
|
|
byte[] tempArray = new byte[1];
|
|
tempArray[0] = Convert.ToByte(c);
|
|
dataByteArray = dataByteArray.Concat(tempArray).ToArray();
|
|
}
|
|
}
|
|
else if (targetType == BuiltInType.String && arraySize > 0)
|
|
{
|
|
//Create a temp string array with the array size
|
|
string[] tempStringArr = new string[(arraySize - 1)];
|
|
//Resize the data byte array to its correct size depending on the byte length of target type by using the dictionary
|
|
dataByteArray = new byte[byteLength[BuiltInType.UInt32]];
|
|
//Get the bytes of the string length and copy them to the beginning of the data byte array
|
|
Array.Copy(BitConverter.GetBytes(arraySize), 0, dataByteArray, 0, byteLength[targetType]);
|
|
|
|
//Get the single array elements by splitting the string
|
|
tempStringArr = element[2].Split(';');
|
|
//Go through every string element in the temp string array
|
|
for (int ii = 0; ii < arraySize; ii++)
|
|
{
|
|
//Copy the string length as byte to the data byte array
|
|
byte[] tempArray = new byte[byteLength[targetType]];
|
|
Array.Copy(BitConverter.GetBytes(tempStringArr[ii].Length), 0, tempArray, 0, byteLength[targetType]);
|
|
dataByteArray = dataByteArray.Concat(tempArray).ToArray();
|
|
//Convert the string to byte and concat them to the data byte array by converting every char of the string
|
|
foreach (Char c in tempStringArr[ii])
|
|
{
|
|
byte[] tempArraySingle = new byte[1];
|
|
tempArraySingle[0] = Convert.ToByte(c);
|
|
dataByteArray = dataByteArray.Concat(tempArraySingle).ToArray();
|
|
}
|
|
}
|
|
}
|
|
else if (targetType == BuiltInType.Byte && !(arraySize > 0))
|
|
{
|
|
//Convert the string of byte to byte
|
|
dataByteArray = new byte[byteLength[targetType]];
|
|
dataByteArray[0] = Convert.ToByte(element[2]);
|
|
}
|
|
else if (targetType == BuiltInType.Byte && arraySize > 0)
|
|
{
|
|
//Create a temp string variable to store the array elements which are divided by ;
|
|
String tempString = "";
|
|
//Resize the data byte array to its correct size depending on the byte length of target type by using the dictionary
|
|
dataByteArray = new byte[byteLength[BuiltInType.UInt32]];
|
|
//Get the bytes of the string length and copy them to the beginning of the data byte array
|
|
Array.Copy(BitConverter.GetBytes(arraySize), 0, dataByteArray, 0, byteLength[targetType]);
|
|
|
|
//Check every char in the string value of the element
|
|
foreach (Char c in element[2])
|
|
{
|
|
if (c != ';') //Concat every char to a string value in elements except the ;
|
|
{
|
|
tempString = String.Concat(tempString, c);
|
|
}
|
|
else
|
|
{
|
|
//Create a temp byte array with its correct size depending on the byte length of the target data type
|
|
byte[] tempArray = new byte[byteLength[targetType]];
|
|
tempArray[0] = Convert.ToByte(tempString);
|
|
//Copy the temp array to the data byte array
|
|
dataByteArray = dataByteArray.Concat(tempArray).ToArray();
|
|
//Reset the temp string
|
|
tempString = "";
|
|
}
|
|
}
|
|
}
|
|
else if (!(arraySize > 0))
|
|
{
|
|
//Create the byte array with its correct size depending on the byte length of the target data type
|
|
dataByteArray = new byte[byteLength[targetType]];
|
|
//Get the converter method depending on the system type
|
|
System.Reflection.MethodInfo methodInfo = typeof(Convert).GetMethod("To" + systemType.Name, new Type[] { typeof(string) });
|
|
//Call the converter method
|
|
dynamic convertDataType = methodInfo.Invoke(null, new Object[] { element[2] });
|
|
Array.Copy(BitConverter.GetBytes(convertDataType), 0, dataByteArray, 0, byteLength[targetType]);
|
|
}
|
|
else if (arraySize > 0)
|
|
{
|
|
//Create a temp string variable to store the array elements which are divided by ;
|
|
String tempString = "";
|
|
//Create the byte array with the size of a UInt32, which is the data type for the array dimension
|
|
dataByteArray = new byte[byteLength[BuiltInType.UInt32]];
|
|
//Get the bytes of the array dimension and copy them to the data byte array as they always are at the beginning of a byte array of an array
|
|
Array.Copy(BitConverter.GetBytes(arraySize), 0, dataByteArray, 0, byteLength[targetType]);
|
|
|
|
//Check every char in the string value of the element
|
|
foreach (Char c in element[2])
|
|
{
|
|
if (c != ';') //Concat every char to a string value in elements except the ;
|
|
{
|
|
tempString = String.Concat(tempString, c);
|
|
}
|
|
else
|
|
{
|
|
//Create a temp byte array with its correct size depending on the byte length of the target data type
|
|
byte[] tempArray = new byte[byteLength[targetType]];
|
|
//Get the converter method depending on the system type
|
|
System.Reflection.MethodInfo methodInfo = typeof(Convert).GetMethod("To" + systemType.Name, new Type[] { typeof(string) });
|
|
//Call the converter method
|
|
dynamic convertDataType = methodInfo.Invoke(null, new Object[] { element[2] });
|
|
Array.Copy(BitConverter.GetBytes(convertDataType), 0, tempArray, 0, byteLength[targetType]);
|
|
//Concat the temp array with the data array
|
|
dataByteArray = dataByteArray.Concat(tempArray).ToArray();
|
|
//Reset the temp string
|
|
tempString = "";
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Exception e = new Exception("Data type is too complex to be parsed." + System.Environment.NewLine);
|
|
throw e;
|
|
}
|
|
|
|
//Add the data byte array to the byte array containing all data and count the counter
|
|
byteArray = byteArray.Concat(dataByteArray).ToArray();
|
|
tempCounter++;
|
|
}
|
|
resultByteList.Add(byteArray);
|
|
return resultByteList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a byte array to objects containing tag names and tag data types
|
|
/// </summary>
|
|
/// <param name="varList">List of object containing tag names and tag data types</param>
|
|
/// <param name="byteResult">A byte array to parse</param>
|
|
/// <returns>A list of string[4]; string[0] = tag name, string[1] = tag name, string[2] = value, string[3] = opc data type</returns>
|
|
/// <exception cref="Exception">Throws and forwards any exception with short error description.</exception>
|
|
private static List<string[]> ParseDataToTagsFromDictionary(List<string[]> varList, List<byte[]> byteArrays)
|
|
{
|
|
//Define result list to return var name, var value and var data type
|
|
List<string[]> resultStringList = new List<string[]>();
|
|
|
|
//Dictionary for index counting
|
|
Dictionary<BuiltInType, int> byteLength = new Dictionary<BuiltInType, int>()
|
|
{
|
|
{BuiltInType.Boolean, 1},
|
|
{BuiltInType.Int16, 2},
|
|
{BuiltInType.Int32, 4},
|
|
{BuiltInType.Int64, 8},
|
|
{BuiltInType.UInt16, 2},
|
|
{BuiltInType.UInt32, 4},
|
|
{BuiltInType.UInt64, 8},
|
|
{BuiltInType.Float, 4},
|
|
{BuiltInType.Double, 8},
|
|
{BuiltInType.Byte, 1},
|
|
{BuiltInType.String, 4}
|
|
};
|
|
|
|
//Array index
|
|
int arrayIndex = 0;
|
|
foreach (byte[] byteResult in byteArrays)
|
|
{
|
|
//Byte decoding index
|
|
int index = 0;
|
|
|
|
//Start decoding for opc data types
|
|
foreach (string[] val in varList)
|
|
{
|
|
string[] dataReferenceStringArray = new string[4];
|
|
|
|
//Check if the type dictionary includes a struct/udt in a struct/udt and enter an empty row
|
|
if (val[1] == "")
|
|
{
|
|
dataReferenceStringArray[0] = "[" + arrayIndex.ToString() + "]";
|
|
dataReferenceStringArray[1] = val[0];
|
|
dataReferenceStringArray[2] = "";
|
|
dataReferenceStringArray[3] = "";
|
|
//Add the data Reference string array to the result string list
|
|
resultStringList.Add(dataReferenceStringArray);
|
|
continue;
|
|
}
|
|
//Add array index
|
|
dataReferenceStringArray[0] = "[" + arrayIndex.ToString() + "]";
|
|
//Copy tag name
|
|
dataReferenceStringArray[1] = val[0];
|
|
//Get the target data type via the data type id
|
|
NodeId datatypeId = new NodeId(val[1]);
|
|
BuiltInType targetType = TypeInfo.GetBuiltInType(datatypeId);
|
|
//Get the system type
|
|
Type systemType = TypeInfo.GetSystemType(datatypeId, null);
|
|
//Parse array dimensions string in int32
|
|
Int32 arrayDimensions = 0;
|
|
if (val[2] != "")
|
|
{
|
|
arrayDimensions = Int32.Parse(val[2]);
|
|
}
|
|
|
|
//Deserialize the byte array depending on the target data type and the array dimension
|
|
if (targetType == BuiltInType.String && !(arrayDimensions > 0))
|
|
{
|
|
//Get the string length
|
|
Int32 stringlength = BitConverter.ToInt32(byteResult, index);
|
|
index += byteLength[targetType];
|
|
if (stringlength > 0) //Decode the bytes to its string value
|
|
{
|
|
dataReferenceStringArray[2] = Encoding.UTF8.GetString(byteResult, index, stringlength);
|
|
index += stringlength;
|
|
}
|
|
else
|
|
{
|
|
dataReferenceStringArray[2] = "";
|
|
}
|
|
}
|
|
else if (targetType == BuiltInType.String && arrayDimensions > 0)
|
|
{
|
|
//Skip array information (UInt32) regarding its size
|
|
index += byteLength[BuiltInType.UInt32];
|
|
//Check every element of the array
|
|
for (int i = 0; i < arrayDimensions; i++)
|
|
{
|
|
//Get the string length
|
|
Int32 stringlength = BitConverter.ToInt32(byteResult, index);
|
|
index += byteLength[targetType];
|
|
if (stringlength > 0) //Decode the bytes to its string value
|
|
{
|
|
dataReferenceStringArray[2] = String.Concat(dataReferenceStringArray[2], Encoding.UTF8.GetString(byteResult, index, stringlength));
|
|
//Add a ; to the string value to seperate the value from the other array values
|
|
dataReferenceStringArray[2] = String.Concat(dataReferenceStringArray[2], ";");
|
|
index += stringlength;
|
|
}
|
|
else
|
|
{
|
|
dataReferenceStringArray[2] = dataReferenceStringArray[2] + ";";
|
|
}
|
|
}
|
|
}
|
|
else if (targetType == BuiltInType.Byte && !(arrayDimensions > 0))
|
|
{
|
|
//Copy the byte value as string to the data reference array
|
|
dataReferenceStringArray[2] = byteResult[index].ToString();
|
|
index += byteLength[targetType];
|
|
}
|
|
else if (targetType == BuiltInType.Byte && arrayDimensions > 0)
|
|
{
|
|
//Skip array information (UInt32) regarding its size
|
|
index += byteLength[BuiltInType.UInt32];
|
|
Int32[] tempArray = new Int32[arrayDimensions];
|
|
//Check every element of the array
|
|
for (int i = 0; i < arrayDimensions; i++)
|
|
{
|
|
tempArray[i] = byteResult[index];
|
|
index += byteLength[targetType];
|
|
}
|
|
//Add the values as one value seperated by ; to the data reference array
|
|
dataReferenceStringArray[2] = String.Join(";", tempArray);
|
|
dataReferenceStringArray[2] = String.Concat(dataReferenceStringArray[2], ";");
|
|
}
|
|
else if (!(arrayDimensions > 0))
|
|
{
|
|
//Get the converter method depending on the system type
|
|
System.Reflection.MethodInfo methodInfo = typeof(BitConverter).GetMethod("To" + systemType.Name);
|
|
//Call the method
|
|
dataReferenceStringArray[2] = methodInfo.Invoke(null, new Object[] { byteResult, index }).ToString();
|
|
index += byteLength[targetType];
|
|
}
|
|
else if (arrayDimensions > 0)
|
|
{
|
|
//Skip array information (UInt32) regarding its size
|
|
index += byteLength[BuiltInType.UInt32];
|
|
//Get the converter method depending on the system type
|
|
System.Reflection.MethodInfo methodInfo = typeof(BitConverter).GetMethod("To" + systemType.Name);
|
|
dynamic[] tempArray = new dynamic[arrayDimensions];
|
|
//Check every element of the array
|
|
for (int i = 0; i < arrayDimensions; i++)
|
|
{
|
|
tempArray[i] = methodInfo.Invoke(null, new Object[] { byteResult, index }).ToString();
|
|
index += byteLength[targetType];
|
|
}
|
|
//Add the values as one value seperated by ; to the data reference array
|
|
dataReferenceStringArray[2] = String.Join(";", tempArray);
|
|
dataReferenceStringArray[2] = String.Concat(dataReferenceStringArray[1], ";");
|
|
}
|
|
else
|
|
{
|
|
Exception e = new Exception("Data type is too complex to be parsed." + System.Environment.NewLine);
|
|
throw e;
|
|
}
|
|
//Copy the target type as string to the data reference array
|
|
dataReferenceStringArray[3] = targetType.ToString();
|
|
//Add the data Reference string array to the result string list
|
|
resultStringList.Add(dataReferenceStringArray);
|
|
}
|
|
//Count the array index
|
|
arrayIndex += 1;
|
|
}
|
|
return resultStringList;
|
|
}
|
|
|
|
/// <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;
|
|
|
|
// verifico se ricevo null, superata soglia genero eccezione
|
|
if ($"{notification.Value}".Contains("null"))
|
|
{
|
|
currNullReceiv++;
|
|
lgTrace($"NUll data read | Variable: {monitoredItem.StartNodeId.Identifier} | Value: {notification.Value}");
|
|
}
|
|
else
|
|
{
|
|
currNullReceiv--;
|
|
currNullReceiv = currNullReceiv > 0 ? currNullReceiv : 0;
|
|
// sollevo evento notifica vaziazione MonitoredItem
|
|
if (eh_MonItChange != null)
|
|
{
|
|
eh_MonItChange(this, new opcUaMonitItemChange(monitoredItem, notification));
|
|
}
|
|
}
|
|
lgTrace($"Notification Received | Variable: {monitoredItem.StartNodeId.Identifier} | Value: {notification.Value}");
|
|
// se ho ricevuto troppi nul --> disconnetto
|
|
if (currNullReceiv > maxNullAllowed)
|
|
{
|
|
if (eh_nullExceed != null)
|
|
{
|
|
eh_nullExceed(this, currNullReceiv);
|
|
}
|
|
// reset
|
|
currNullReceiv = 0;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
lgError($"OnMonitoredItemNotification error: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |