/// <summary>
/// Changes the area monitored by the control.
/// </summary>
public void ChangeArea(NodeId areaId, bool fetchRecent)
{
m_areaId = areaId;
EventsLV.Items.Clear();
if (fetchRecent)
{
ReadRecentHistory();
}
if (m_subscription != null)
{
MonitoredItem monitoredItem = new MonitoredItem(m_monitoredItem);
monitoredItem.StartNodeId = areaId;
m_subscription.AddItem(monitoredItem);
m_subscription.RemoveItem(m_monitoredItem);
m_monitoredItem = monitoredItem;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.ApplyChanges();
}
}
/// <summary>
/// Updates the filter.
/// </summary>
private void UpdateFilter()
{
if (m_subscription != null)
{
// changing the filter changes the fields requested. this makes it
// impossible to process notifications sent before the change.
// to avoid this problem we create a new item and remove the old one.
MonitoredItem monitoredItem = m_filter.CreateMonitoredItem(m_session);
// set up callback for notifications.
monitoredItem.Notification += m_MonitoredItem_Notification;
m_subscription.AddItem(monitoredItem);
m_subscription.RemoveItem(m_monitoredItem);
m_subscription.ApplyChanges();
// replace monitored item.
m_monitoredItem.Notification -= m_MonitoredItem_Notification;
m_monitoredItem = monitoredItem;
// send a refresh since previously filtered conditions may be now available.
Conditions_RefreshMI_Click(this, null);
}
}
public void addConnection(BaseVariableState collectorNode, ReferenceDescription clientNode)
{
// test if clientNode is Variable
if (clientNode.NodeClass == NodeClass.Variable)//&& collectorNode.GetType()==typeof(VariableNode))
{
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = ExpandedNodeId.ToNodeId(clientNode.NodeId, session.NamespaceUris);
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(connectVariable);
Debug.Print("Client.cs: not fully implemented new session, just easily created");
Subscription sub = new Subscription();
sub.PublishingEnabled = true;
sub.PublishingInterval = 1000;
sub.Priority = 1;
sub.KeepAliveCount = 10;
sub.LifetimeCount = 20;
sub.MaxNotificationsPerPublish = 1000;
sub.AddItem(monitoredItem);
session.AddSubscription(sub);
sub.Create();
connectedVariables.Add(monitoredItem, collectorNode);
}
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
// browse the instances in the server.
//BrowseCTRL.Initialize(m_session, ObjectIds.ObjectsFolder, ReferenceTypeIds.Organizes, ReferenceTypeIds.Aggregates);
//verify if Session is established
if (m_session != null)
{
//verify if the Subscription was not already created
if (m_subscription == null)
{
//create the subscritpion
m_subscription = new Subscription(m_session.DefaultSubscription);
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000; //1000msec interval
m_session.AddSubscription(m_subscription);
m_subscription.Create();
}
//Add Start_Piece to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Start_Piece";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Start_Piece_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add Change_Mould to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Change_Mould";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Change_Mould_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add Actual_State to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Actual_State";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Actual_State_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
DataValueCollection results = Read_Value("ns=3;s=Mould_1");
DataValueCollection results1 = Read_Value("ns=3;s=Mould_2");
string Mould_1Value = (string)results[0].Value;
string Mould_2Value = (string)results1[0].Value;
comboBox1.Items.Add(Mould_1Value);
comboBox1.Items.Add(Mould_2Value);
//comboBox1.Text = Mould_1Value;
//Open connection to DB
string connectionString = "SERVER=" + DB_server + ";" +
"DATABASE=" + DB_database + ";" + "UID=" + DB_uid + ";" +
"PASSWORD="******";";
DB_connection = new MySqlConnection(connectionString);
try
{
DB_connection.Open();
}
catch (MySqlException ex)
{
MessageBox.Show(ex.Message);
};
}
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Tests the session reconnect.
/// </summary>
private bool DoReconnectTest()
{
double increment = MaxProgress / 6;
double position = 0;
bool success = true;
lock (m_messages)
{
m_messages.Clear();
}
int currentKeepAlive = Session.KeepAliveInterval;
List <Subscription> subscriptions = new List <Subscription>();
KeepAliveEventHandler keepAliveHandler = new KeepAliveEventHandler(Session_Reconnect);
NotificationEventHandler notificationHandler = new NotificationEventHandler(Session_Notification);
try
{
Session.KeepAlive += keepAliveHandler;
Session.Notification += notificationHandler;
for (int publishingInterval = 1000; publishingInterval <= 10000; publishingInterval += 1000)
{
Subscription subscription = new Subscription();
subscription.MaxMessageCount = 100;
subscription.LifetimeCount = 100;
subscription.KeepAliveCount = 10;
subscription.PublishingEnabled = true;
subscription.PublishingInterval = publishingInterval;
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = VariableIds.Server_ServerStatus_CurrentTime;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = -1;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
subscription.AddItem(monitoredItem);
Session.AddSubscription(subscription);
subscription.Create();
subscriptions.Add(subscription);
}
m_keepAliveCount = 0;
Session.KeepAliveInterval = 1000;
Log("Setting keep alive interval to {0}ms.", Session.KeepAliveInterval);
int testDuration = 3000;
for (int ii = 0; ii < 6; ii++)
{
Session.Reconnect();
Log("Session reconnected. KeepAlives={0}", m_keepAliveCount);
if (m_errorEvent.WaitOne(testDuration, false))
{
Log("Unexpected error waiting for session keep alives. {0}", m_error.ToLongString());
return(false);
}
position += increment;
ReportProgress(position);
}
}
finally
{
Session.RemoveSubscriptions(subscriptions);
Session.KeepAliveInterval = currentKeepAlive;
Session.KeepAlive -= keepAliveHandler;
Session.Notification -= notificationHandler;
}
ReportProgress(MaxProgress);
lock (m_messages)
{
foreach (KeyValuePair <uint, List <uint> > entry in m_messages)
{
entry.Value.Sort();
for (int ii = 0; ii < entry.Value.Count - 1; ii++)
{
if (entry.Value[ii + 1] - entry.Value[ii] > 1)
{
Log("Missing message. Subscription={0}, SequenceNumber={1}-{2}", entry.Key, entry.Value[ii] + 1, entry.Value[ii + 1] - 1);
}
if (entry.Value[ii + 1] == entry.Value[ii])
{
// Log("Duplicate message. Subscription={0}, SequenceNumber={1}", entry.Key, entry.Value[ii]);
}
}
}
}
return(success);
}
/// <summary>
/// Connects to a server.
/// </summary>
private void Server_ConnectMI_Click(object sender, EventArgs e)
{
try
{
// disconnect any existing session.
Server_DisconnectMI_Click(sender, e);
InitialStateTB.Text = "1";
FinalStateTB.Text = "100";
// create the session.
EndpointDescription endpointDescription = SelectEndpoint();
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_configuration);
ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
m_session = Session.Create(
m_configuration,
endpoint,
true,
m_configuration.ApplicationName,
60000,
null,
null);
// set up keep alive callback.
m_session.KeepAliveInterval = 2000;
m_session.KeepAlive += new KeepAliveEventHandler(Session_KeepAlive);
// this client has built-in knowledge of the information model used by the server.
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.Methods);
string[] browsePaths = new string[]
{
"1:My Process/1:State",
"1:My Process",
"1:My Process/1:Start"
};
List<NodeId> nodes = FormUtils.TranslateBrowsePaths(
m_session,
ObjectIds.ObjectsFolder,
wellKnownNamespaceUris,
browsePaths);
// subscribe to the state if available.
if (nodes.Count > 0 && !NodeId.IsNull(nodes[0]))
{
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 1000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = nodes[0];
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
}
// save the object/method
if (nodes.Count > 2)
{
m_objectNode = nodes[1];
m_methodNode = nodes[2];
}
ConnectedLB.Text = "Connected";
ServerUrlLB.Text = endpointDescription.EndpointUrl;
LastKeepAliveTimeLB.Text = "---";
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Reads an verifies all of the nodes.
/// </summary>
private bool DoSamplingIntervalTest(bool modifySamplingInterval)
{
// follow tree from each starting node.
bool success = true;
// collection writeable variables that don't change during the test.
lock (m_variables)
{
m_lastWriteTime = DateTime.MinValue;
m_writeDelayed = false;
m_writeTimerCounter++;
m_variables.Clear();
// collection writeable variables that don't change during the test.
for (int ii = 0; ii < WriteableVariables.Count; ii++)
{
AddVariableToTest(WriteableVariables[ii], m_variables, false);
}
// reduce list based on coverage.
List<TestVariable> variables = new List<TestVariable>();
int counter = 0;
foreach (TestVariable variable in m_variables)
{
if (!CheckCoverage(ref counter))
{
continue;
}
variables.Add(variable);
}
// check if there is anything to work with.
if (variables.Count == 0)
{
Log("WARNING: No writeable variables found.");
Log(WriteTest.g_WriteableVariableHelpText);
return true;
}
m_variables.Clear();
m_variables.AddRange(variables);
ReadEURanges(m_variables);
InitialWrite();
// check if there is anything to work with.
if (m_variables.Count == 0)
{
Log("WARNING: No writeable variables found.");
Log(WriteTest.g_WriteableVariableHelpText);
return true;
}
Log("Starting SamplingIntervalTest for {0} Variables ({1}% Coverage, Start={2})", m_variables.Count, Configuration.Coverage, m_variables[0].Variable);
m_stopped = 0;
m_writeInterval = 1000;
m_useDeadbandValues = false;
m_errorEvent.Reset();
}
Subscription subscription = new Subscription();
subscription.PublishingInterval = 500;
subscription.PublishingEnabled = true;
subscription.Priority = 0;
subscription.KeepAliveCount = 1000;
subscription.LifetimeCount = 1000;
subscription.MaxNotificationsPerPublish = 100;
Session.AddSubscription(subscription);
subscription.Create();
m_publishingTime = subscription.CurrentPublishingInterval;
m_writerTimer = new Timer(DoWrite, m_writeTimerCounter, 0, m_writeInterval);
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
// create monitored items.
if (success)
{
lock (m_variables)
{
m_monitoredItems = new Dictionary<uint,TestVariable>();
for (int ii = 0; ii < m_variables.Count; ii++)
{
// servers that sample data values may not pick up boolean value changes.
if (m_variables[ii].DataType == BuiltInType.Boolean)
{
continue;
}
VariableNode variable = m_variables[ii].Variable;
for (int jj = 2000; jj <= 10000; jj += 1000)
{
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = variable.NodeId;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.RelativePath = null;
monitoredItem.IndexRange = null;
monitoredItem.SamplingInterval = jj;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
monitoredItem.Filter = null;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.Handle = m_variables[ii];
m_variables[ii].Notifications[monitoredItem.ClientHandle] = new List<Notification>();
m_monitoredItems[monitoredItem.ClientHandle] = m_variables[ii];
subscription.AddItem(monitoredItem);
}
}
}
subscription.ApplyChanges();
// check results.
foreach (MonitoredItem monitoredItem in subscription.MonitoredItems)
{
if (ServiceResult.IsBad(monitoredItem.Status.Error))
{
TestVariable variable = monitoredItem.Handle as TestVariable;
Log(
"Could not create MonitoredItem {0}. NodeId={1}, SamplingInterval={2}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.SamplingInterval);
success = false;
}
}
}
// modify sampling interval.
if (success)
{
if (modifySamplingInterval)
{
if (!ModifySamplingInterval(subscription))
{
success = false;
}
}
}
// wait for first data change.
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
// wait while values are written.
lock (m_variables)
{
m_writeCount = 0;
m_startTime = DateTime.UtcNow;
}
if (success)
{
double increment = MaxProgress/10;
double position = 0;
for (int ii = 0; ii < 20; ii++)
{
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
break;
}
position += increment;
ReportProgress(position);
}
}
int writeCount = 0;
lock (m_variables)
{
m_stopped = 1;
m_endTime = DateTime.UtcNow;
writeCount = m_writeCount;
m_writerTimer.Dispose();
m_writerTimer = null;
}
Session.RemoveSubscription(subscription);
// wait for last data change.
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
// verify results.
if (success)
{
double duration = CalculateInterval(m_startTime, m_endTime);
double expectedWrites = Math.Truncate(duration/m_writeInterval);
if (Math.Abs(expectedWrites - writeCount) > 1)
{
Log(
"WARNING: unexpected number of writes for monitored items: Expected={0}, Actual={1}",
expectedWrites,
writeCount,
duration);
}
lock (m_variables)
{
int errorCount = 0;
foreach (MonitoredItem monitoredItem in subscription.MonitoredItems)
{
if (errorCount > 10)
{
break;
}
TestVariable variable = (TestVariable)monitoredItem.Handle;
if (variable.WriteError)
{
continue;
}
IList<Notification> notifications = variable.Notifications[monitoredItem.ClientHandle];
// count the number of notifications.
int first = -1;
for (int ii = 0; ii < notifications.Count; ii++)
{
if (notifications[ii].Timestamp < m_startTime)
{
continue;
}
first = ii;
}
if (first == -1)
{
Log(
"No notifications for monitored item: {0}, NodeId={1}, SamplingInterval={2}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.SamplingInterval);
success = false;
errorCount++;
continue;
}
int actualNotifications = notifications.Count - first;
double range = (notifications[notifications.Count-1].Timestamp - notifications[first].Timestamp).TotalMilliseconds;
// check that at least one notification was recieved.
double expectedNotifications = Math.Truncate(range/monitoredItem.SamplingInterval);
if (Math.Abs(expectedNotifications - actualNotifications) > 1)
{
Log(
"Unexpected number of notifications for monitored item: {0}, NodeId={1}, SamplingInterval={2}, Expected={3}, Actual={4}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.SamplingInterval,
expectedNotifications,
actualNotifications);
StringBuilder buffer = new StringBuilder();
buffer.Append("Notifications:\r\n");
for (int ii = 0; ii < notifications.Count; ii++)
{
buffer.AppendFormat(
"[{0}]\t{1:HH:mm:ss.fff}\t{2}\t{3:HH:mm:ss.fff}\r\n",
notifications[ii].SequenceNumber,
notifications[ii].Timestamp,
notifications[ii].Value.WrappedValue,
notifications[ii].Value.SourceTimestamp);
}
buffer.Append("Values:\r\n");
for (int ii = 0; ii < variable.Values.Count; ii++)
{
buffer.AppendFormat(
"[{0}]\t{1}\t{2:HH:mm:ss.fff}\r\n",
ii,
variable.Values[ii].WrappedValue,
variable.Timestamps[ii]);
}
Log(buffer.ToString());
success = false;
errorCount++;
continue;
}
// check timing.
if (!CheckNotificationTiming(monitoredItem, variable, notifications))
{
success = false;
errorCount++;
continue;
}
}
}
}
lock (m_variables)
{
Log("Completed SamplingIntervalTest for {0} Nodes", m_variables.Count);
}
return success;
}
/// <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;
}
try
{
// Create a subscription for receiving data change notifications
// Define Subscription parameters
Subscription subscription = new Subscription(m_session.DefaultSubscription);
subscription.DisplayName = "Console ReferenceClient Subscription";
subscription.PublishingEnabled = true;
subscription.PublishingInterval = 1000;
m_session.AddSubscription(subscription);
// Create the subscription on Server side
subscription.Create();
m_output.WriteLine("New Subscription created with SubscriptionId = {0}.", subscription.Id);
// Create MonitoredItems for data changes (Reference Server)
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);
// 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);
}
}
public void CreateMonitoredItem(
Session session, Subscription subscription, NodeId nodeId, MonitoringMode mode)
{
if (subscription == null)
{
subscription = session.DefaultSubscription;
if (session.AddSubscription(subscription))
subscription.Create();
}
else
{
session.AddSubscription(subscription);
}
// add the new monitored item.
MonitoredItem monitoredItem = new MonitoredItem(subscription.DefaultItem);
monitoredItem.StartNodeId = nodeId;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.DisplayName = nodeId.Identifier.ToString();
monitoredItem.MonitoringMode = mode;
monitoredItem.SamplingInterval = mode == MonitoringMode.Sampling ? 1000 : 0;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
monitoredItem.Notification += MonitoredItem_Notification;
subscription.AddItem(monitoredItem);
subscription.ApplyChanges();
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
if (m_session == null)
{
StartBTN.Enabled = false;
return;
}
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
// this client has built-in knowledge of the information model used by the server.
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.Methods);
string[] browsePaths = new string[]
{
"1:My Process/1:State",
"1:My Process",
"1:My Process/1:Start"
};
List<NodeId> nodes = ClientUtils.TranslateBrowsePaths(
m_session,
ObjectIds.ObjectsFolder,
wellKnownNamespaceUris,
browsePaths);
// subscribe to the state if available.
if (nodes.Count > 0 && !NodeId.IsNull(nodes[0]))
{
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 1000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = nodes[0];
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
}
// save the object/method
if (nodes.Count > 2)
{
m_objectNode = nodes[1];
m_methodNode = nodes[2];
}
InitialStateTB.Text = "1";
FinalStateTB.Text = "100";
StartBTN.Enabled = true;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <param name="subscription"></param>
/// <param name="lv"></param>
/// <returns></returns>
public virtual MonitoredItem CreateMonitoredItem(Session session, Subscription subscription, ListView lv)
{
MonitoredItem mi = new MonitoredItem(subscription.DefaultItem);
INode node = session.NodeCache.Find(this);
mi.DisplayName = session.NodeCache.GetDisplayText(node);
mi.StartNodeId = this;
mi.RelativePath = this.RelativePath;
mi.NodeClass = NodeClass.Variable;
mi.AttributeId = Attributes.Value;
subscription.AddItem(mi);
AddToListView(mi, lv);
return mi;
}
public void SubscribeToDataChanges()
{
if (_session == null || _session.Connected == false)
{
Console.WriteLine("Session not connected!");
return;
}
try
{
// Create a subscription for receiving data change notifications
// Define Subscription parameters
Subscription subscription = new Subscription(_session.DefaultSubscription);
subscription.DisplayName = "Console ReferenceClient Subscription";
subscription.PublishingEnabled = true;
subscription.PublishingInterval = 1000;
_session.AddSubscription(subscription);
// Create the subscription on Server side
subscription.Create();
// Console.WriteLine("New Subscription created with SubscriptionId = {0}.", subscription.Id);
// Create MonitoredItems for data changes
MonitoredItem boolMonitoredItem = new MonitoredItem(subscription.DefaultItem);
// Int32 Node - Objects\CTT\Scalar\Simulation\Int32
boolMonitoredItem.StartNodeId = new NodeId("ns=3;s=\"上位通讯\".\"写入\".\"9#\".\"请求绑定\"");
boolMonitoredItem.AttributeId = Attributes.Value;
boolMonitoredItem.DisplayName = "request";
boolMonitoredItem.SamplingInterval = 1000;
boolMonitoredItem.Notification += OnMonitoredRequest;
subscription.AddItem(boolMonitoredItem);
MonitoredItem floatMonitoredItem = new MonitoredItem(subscription.DefaultItem);
// Float Node - Objects\CTT\Scalar\Simulation\Float
floatMonitoredItem.StartNodeId = new NodeId("ns=3;s=\"上位通讯\".\"写入\".\"15#\".\"请求匹配\"");
floatMonitoredItem.AttributeId = Attributes.Value;
floatMonitoredItem.DisplayName = "equals";
floatMonitoredItem.SamplingInterval = 1000;
floatMonitoredItem.Notification += OnMonitoredEquals;
subscription.AddItem(floatMonitoredItem);
MonitoredItem stringMonitoredItem = new MonitoredItem(subscription.DefaultItem);
// String Node - Objects\CTT\Scalar\Simulation\String
stringMonitoredItem.StartNodeId = new NodeId("ns=3;s=\"上位通讯\".\"写入\".\"15#\".\"应急开关\"");
stringMonitoredItem.AttributeId = Attributes.Value;
stringMonitoredItem.DisplayName = "stop";
stringMonitoredItem.SamplingInterval = 1000;
stringMonitoredItem.Notification += OnMonitoredStop;
subscription.AddItem(stringMonitoredItem);
// Create the monitored items on Server side
subscription.ApplyChanges();
// Console.WriteLine("MonitoredItems created for SubscriptionId = {0}.", subscription.Id);
}
catch (Exception ex)
{
Console.WriteLine("Subscribe error: {0}", ex.Message);
}
}
/// <summary>
/// Creates subscriptions according to the configuration.
/// </summary>
private bool CreateSubscriptions()
{
try
{
if (opcSession == null)
{
throw new InvalidOperationException("OPC session must not be null.");
}
subscrByID = new Dictionary <uint, SubscriptionTag>();
foreach (SubscriptionConfig subscriptionConfig in deviceConfig.Subscriptions)
{
if (!subscriptionConfig.Active)
{
continue;
}
Subscription subscription = new Subscription(opcSession.DefaultSubscription)
{
DisplayName = subscriptionConfig.DisplayName,
PublishingInterval = subscriptionConfig.PublishingInterval
};
SubscriptionTag subscriptionTag = new SubscriptionTag(subscription);
foreach (ItemConfig itemConfig in subscriptionConfig.Items)
{
if (!itemConfig.Active)
{
continue;
}
subscription.AddItem(new MonitoredItem(subscription.DefaultItem)
{
StartNodeId = itemConfig.NodeID,
DisplayName = itemConfig.DisplayName
});
if (itemConfig.Tag is KPTag kpTag)
{
subscriptionTag.ItemsByNodeID[itemConfig.NodeID] = new ItemTag
{
ItemConfig = itemConfig,
KPTag = kpTag
};
}
}
opcSession.AddSubscription(subscription);
subscription.Create();
subscrByID[subscription.Id] = subscriptionTag;
}
return(true);
}
catch (Exception ex)
{
WriteToLog((Localization.UseRussian ?
"Ошибка при создании подписок: " :
"Error creating subscriptions: ") + ex);
return(false);
}
}
/// <summary>
///
/// </summary>
private void AddSessions()
{
Browser browser = new Browser(m_Session);
browser.MaxReferencesReturned = 0;
browser.BrowseDirection = BrowseDirection.Forward;
browser.IncludeSubtypes = true;
browser.NodeClassMask = (int)NodeClass.Object;
browser.ContinueUntilDone = true;
NodeId browseid = new NodeId(Objects.Server_ServerDiagnostics_SessionsDiagnosticsSummary);
browser.ReferenceTypeId = null;
ReferenceDescriptionCollection refs = browser.Browse(browseid);
foreach (ReferenceDescription rf in refs)
{
if (m_Session.TypeTree.IsTypeOf(new ExpandedNodeId(rf.TypeDefinition), new ExpandedNodeId(ObjectTypes.SessionDiagnosticsObjectType)))
{
if (listView1.Items.IndexOfKey(rf.NodeId.ToString()) == -1)
{
ListViewItem lvi = listView1.Items.Add(rf.NodeId.ToString(), rf.DisplayName.Text.ToString(), -1);
lvi.Tag = rf.NodeId;
lvi.IndentCount = 0;
string SessionID = "SessionDiagnostics.SessionId";
string ClientName = "SessionDiagnostics.ClientName";
string ClientConnectionTime = "SessionDiagnostics.ClientConnectionTime";
ListViewItem.ListViewSubItem SessionIDSubItem = lvi.SubItems.Add("");
SessionIDSubItem.Name = rf.NodeId.Identifier.ToString() + "." + SessionID;
ListViewItem.ListViewSubItem ClientNameSubItem = lvi.SubItems.Add("");
ClientNameSubItem.Name = rf.NodeId.Identifier.ToString() + "." + ClientName;
ListViewItem.ListViewSubItem ClientConnectionTimeSubItem = lvi.SubItems.Add("");
ClientConnectionTimeSubItem.Name = rf.NodeId.Identifier.ToString() + "." + ClientConnectionTime;
MonitoredItem sessionItem = new MonitoredItem(m_Subscription.DefaultItem);
sessionItem.StartNodeId = (NodeId)rf.NodeId;
sessionItem.RelativePath = SessionID;
sessionItem.NodeClass = NodeClass.Object;
sessionItem.AttributeId = Attributes.Value;
m_Subscription.AddItem(sessionItem);
sessionItem.Notification += m_ItemNotification;
INode node = m_Session.NodeCache.Find(rf.NodeId);
TypedMonitoredItem SessionIDItem = new TypedMonitoredItem(m_Subscription.DefaultItem);
SessionIDItem.StartNodeId = (NodeId)rf.NodeId;
SessionIDItem.RelativePath = SessionID;
SessionIDItem.NodeClass = NodeClass.Variable;
SessionIDItem.AttributeId = Attributes.Value;
m_Subscription.AddItem(SessionIDItem);
SessionIDItem.Notification += m_ItemNotification;
SessionIDSubItem.Tag = SessionIDItem;
Utils.Trace("Adding: {0}, {1} as subitem in AddSessions()", SessionIDItem.StartNodeId.ToString(), SessionIDItem.RelativePath.ToString());
TypedMonitoredItem ClientNameItem = new TypedMonitoredItem(m_Subscription.DefaultItem);
ClientNameItem.StartNodeId = (NodeId)rf.NodeId;
ClientNameItem.RelativePath = ClientName;
ClientNameItem.NodeClass = NodeClass.Variable;
ClientNameItem.AttributeId = Attributes.Value;
m_Subscription.AddItem(ClientNameItem);
ClientNameItem.Notification += m_ItemNotification;
ClientNameSubItem.Tag = ClientNameItem;
Utils.Trace("Adding: {0}, {1} as subitem in AddSessions()", ClientNameItem.StartNodeId.ToString(), ClientNameItem.RelativePath.ToString());
DateTimeMonitoredItem ClientConnectionTimeItem = new DateTimeMonitoredItem(m_Subscription.DefaultItem);
ClientConnectionTimeItem.StartNodeId = (NodeId)rf.NodeId;
ClientConnectionTimeItem.RelativePath = ClientConnectionTime;
ClientConnectionTimeItem.NodeClass = NodeClass.Variable;
ClientConnectionTimeItem.AttributeId = Attributes.Value;
m_Subscription.AddItem(ClientConnectionTimeItem);
ClientConnectionTimeItem.Notification += m_ItemNotification;
ClientConnectionTimeSubItem.Tag = ClientConnectionTimeItem;
Utils.Trace("Adding: {0}, {1} as subitem in AddSessions()", ClientConnectionTimeItem.StartNodeId.ToString(), ClientConnectionTimeItem.RelativePath.ToString());
}
else
{
Utils.Trace("Key already exists in listview. rf.BrowseName: {0},rf.NodeId: {1}, rf.TypeDefinition: {2}", rf.BrowseName.ToString(), rf.NodeId.ToString(), rf.TypeDefinition.ToString());
}
}
else
{
Utils.Trace("Unknown Object rf.BrowseName: {0},rf.NodeId: {1}, rf.TypeDefinition: {2}", rf.BrowseName.ToString(), rf.NodeId.ToString(), rf.TypeDefinition.ToString());
}
}
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
//verify if Session is established
if (m_session != null)
{
//verify if the Subscription was not already created
if (m_subscription == null)
{
//create the subscritpion
m_subscription = new Subscription(m_session.DefaultSubscription);
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 4000; //msec interval
m_session.AddSubscription(m_subscription);
m_subscription.Create();
MonitoredItem monitoredItem;
//Add Pressure_array to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Sensors_Data";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Pressure_Array_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add Actual_Mould to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Actual_Mould";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Actual_Mould_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
}
}
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Connects the specified endpoint URL.
/// </summary>
/// <param name="endpointUrl">The endpoint URL.</param>
/// <exception cref="System.ArgumentNullException">endpointUrl</exception>
/// <exception cref="System.ArgumentException">endpointUrl</exception>
public async void Connect(string endpointUrl)
{
if (endpointUrl == null)
{
endpointUrl = m_endpointUrl;
}
if (String.IsNullOrEmpty(endpointUrl))
{
throw new ArgumentNullException(nameof(endpointUrl));
}
if (!Uri.IsWellFormedUriString(endpointUrl, UriKind.Absolute))
{
throw new ArgumentException(endpointUrl + " is not a valid URL.", nameof(endpointUrl));
}
if (m_session != null)
{
m_session.Dispose();
m_session = null;
}
EndpointDescription endpointDescription = CoreClientUtils.SelectEndpoint(endpointUrl, true);
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_application.ApplicationConfiguration);
ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
m_session = await Session.Create(
m_application.ApplicationConfiguration,
endpoint,
false,
false,
m_application.ApplicationName,
60000,
AdminCredentials,
m_preferredLocales);
m_session.SessionClosing += Session_SessionClosing;
m_session.KeepAlive += Session_KeepAlive;
m_session.KeepAlive += KeepAlive;
if (m_session.Factory.GetSystemType(Opc.Ua.Gds.DataTypeIds.ApplicationRecordDataType) == null)
{
m_session.Factory.AddEncodeableTypes(typeof(Opc.Ua.Gds.ObjectIds).Assembly);
}
m_session.ReturnDiagnostics = DiagnosticsMasks.SymbolicIdAndText;
m_endpointUrl = m_session.ConfiguredEndpoint.EndpointUrl.ToString();
#if TODO_GDS_STATUS_SUBSCRIPTION
Subscription subscription = new Subscription();
subscription.Handle = this;
subscription.DisplayName = null;
subscription.PublishingInterval = 1000;
subscription.KeepAliveCount = 10;
subscription.LifetimeCount = 100;
subscription.MaxNotificationsPerPublish = 10;
subscription.PublishingEnabled = true;
subscription.TimestampsToReturn = TimestampsToReturn.Neither;
m_session.AddSubscription(subscription);
subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = Opc.Ua.VariableIds.Server_ServerStatus;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
monitoredItem.Handle = typeof(ServerStatusDataType);
monitoredItem.Notification += ServerStatusChanged;
subscription.AddItem(monitoredItem);
subscription.ApplyChanges();
#endif
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
// check for disconnect.
if (m_session == null)
{
if (m_auditEventForm != null)
{
m_auditEventForm.Close();
m_auditEventForm = null;
}
return;
}
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
// create the default subscription.
m_subscription = new Subscription();
m_subscription.DisplayName = null;
m_subscription.PublishingInterval = 1000;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 100;
m_subscription.MaxNotificationsPerPublish = 1000;
m_subscription.PublishingEnabled = true;
m_subscription.TimestampsToReturn = TimestampsToReturn.Both;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
// must specify the fields that the form is interested in.
m_filter.SelectClauses = m_filter.ConstructSelectClauses(
m_session,
NodeId.Parse("ns=2;s=4:2"),
NodeId.Parse("ns=2;s=4:1"),
ObjectTypeIds.DialogConditionType,
ObjectTypeIds.ExclusiveLimitAlarmType,
ObjectTypeIds.NonExclusiveLimitAlarmType);
// create a monitored item based on the current filter settings.
m_monitoredItem = m_filter.CreateMonitoredItem(m_session);
// set up callback for notifications.
m_monitoredItem.Notification += m_MonitoredItem_Notification;
m_subscription.AddItem(m_monitoredItem);
m_subscription.ApplyChanges();
// send an initial refresh.
Conditions_RefreshMI_Click(sender, e);
ConditionsMI.Enabled = true;
ViewMI.Enabled = true;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Tests the session keep alive when there are no errors.
/// </summary>
private bool DoKeepAliveTest()
{
bool success = true;
double increment = MaxProgress/3;
double position = 0;
m_keepAliveCount = 0;
int currentKeepAlive = Session.KeepAliveInterval;
List<Subscription> subscriptions = new List<Subscription>();
KeepAliveEventHandler handler = new KeepAliveEventHandler(Session_KeepAlive);
try
{
Session.KeepAlive += handler;
// add several subscriptions with long publish intervals.
for (int publishingInterval = 10000; publishingInterval <= 20000; publishingInterval += 1000)
{
Subscription subscription = new Subscription();
subscription.MaxMessageCount = 100;
subscription.LifetimeCount = 100;
subscription.KeepAliveCount = 10;
subscription.PublishingEnabled = true;
subscription.PublishingInterval = publishingInterval;
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = VariableIds.Server_ServerStatus_CurrentTime;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = -1;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
subscription.AddItem(monitoredItem);
Session.AddSubscription(subscription);
subscription.Create();
subscriptions.Add(subscription);
}
// get a value to read.
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = VariableIds.Server_ServerStatus;
nodeToRead.AttributeId = Attributes.Value;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
nodesToRead.Add(nodeToRead);
int testDuration = 5000;
// make sure the keep alives come at the expected rate.
for (int keepAliveInterval = 500; keepAliveInterval < 2000; keepAliveInterval += 500)
{
m_keepAliveCount = 0;
DateTime start = DateTime.UtcNow;
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticsInfos = null;
Session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticsInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticsInfos, nodesToRead);
ServerStatusDataType status = ExtensionObject.ToEncodeable(results[0].Value as ExtensionObject) as ServerStatusDataType;
if (status == null)
{
Log("Server did not return a valid ServerStatusDataType structure. Value={0}, Status={1}", results[0].WrappedValue, results[0].StatusCode);
return false;
}
if ((DateTime.UtcNow - start).TotalSeconds > 1)
{
Log("Unexpected delay reading the ServerStatus structure. Delay={0}s", (DateTime.UtcNow - start).TotalSeconds);
return false;
}
Log("Setting keep alive interval to {0}ms.", keepAliveInterval);
Session.KeepAliveInterval = keepAliveInterval;
if (m_errorEvent.WaitOne(testDuration, false))
{
Log("Unexpected error waiting for session keep alives. {0}", m_error.ToLongString());
return false;
}
if (m_keepAliveCount < testDuration / keepAliveInterval)
{
Log("Missing session keep alives. Expected={0}, Actual={1}", testDuration / keepAliveInterval, m_keepAliveCount);
return false;
}
Log("{0} keep alives received in {1}ms.", m_keepAliveCount, testDuration);
position += increment;
ReportProgress(position);
}
ReportProgress(MaxProgress);
}
finally
{
Session.RemoveSubscriptions(subscriptions);
Session.KeepAliveInterval = currentKeepAlive;
Session.KeepAlive -= handler;
}
return success;
}
public async Task ConnectAndMonitor()
{
_opcSessionSemaphore.Wait();
Trace($"Connect and monitor session and nodes on endpoint '{EndpointUri.AbsoluteUri}'.");
try
{
// if the session is disconnected, create it.
if (State == SessionState.Disconnected)
{
EndpointDescription selectedEndpoint = CoreClientUtils.SelectEndpoint(EndpointUri.AbsoluteUri, true);
ConfiguredEndpoint configuredEndpoint = new ConfiguredEndpoint(selectedEndpoint.Server, EndpointConfiguration.Create(OpcConfiguration));
configuredEndpoint.Update(selectedEndpoint);
try
{
uint timeout = SessionTimeout * ((UnsuccessfulConnectionCount >= OpcSessionCreationBackoffMax) ? OpcSessionCreationBackoffMax : UnsuccessfulConnectionCount + 1);
Trace($"Create session for endpoint URI '{EndpointUri.AbsoluteUri}' with timeout of {timeout} ms.");
Session = await Session.Create(
OpcConfiguration,
configuredEndpoint,
true,
false,
OpcConfiguration.ApplicationName,
timeout,
new UserIdentity(new AnonymousIdentityToken()),
null);
if (Session != null)
{
Trace($"Session successfully created with Id {Session.SessionId}.");
if (!selectedEndpoint.EndpointUrl.Equals(configuredEndpoint.EndpointUrl))
{
Trace($"the Server has updated the EndpointUrl to '{selectedEndpoint.EndpointUrl}'");
}
// init object state and install keep alive
UnsuccessfulConnectionCount = 0;
State = SessionState.Connected;
Session.KeepAliveInterval = OpcKeepAliveIntervalInSec * 1000;
Session.KeepAlive += new KeepAliveEventHandler((sender, e) => StandardClient_KeepAlive(sender, e, Session));
// fetch the namespace array and cache it. it will not change as long the session exists.
NodeId namespaceArrayNodeId = new NodeId(Variables.Server_NamespaceArray, 0);
DataValue namespaceArrayNodeValue = Session.ReadValue(namespaceArrayNodeId);
_namespaceTable.Update(namespaceArrayNodeValue.GetValue <string[]>(null));
// show the available namespaces
Trace($"The session to endpoint '{selectedEndpoint.EndpointUrl}' has {_namespaceTable.Count} entries in its namespace array:");
int i = 0;
foreach (var ns in _namespaceTable.ToArray())
{
Trace($"Namespace index {i++}: {ns}");
}
}
}
catch (Exception e)
{
Trace(e, $"Session creation to endpoint '{EndpointUri.AbsoluteUri}' failed {++UnsuccessfulConnectionCount} time(s). Please verify if server is up and Publisher configuration is correct.");
State = SessionState.Disconnected;
Session = null;
return;
}
}
// stop monitoring of nodes if requested and remove them from the monitored items list.
var itemsToRemove = MonitoredItemsInfo.Where(i => i.State == MonitoredItemInfo.MonitoredItemState.StopMonitoring);
if (itemsToRemove.GetEnumerator().MoveNext())
{
itemsToRemove.GetEnumerator().Reset();
Trace($"Remove nodes on endpoint '{EndpointUri.AbsoluteUri}'");
Session.DefaultSubscription.RemoveItems(itemsToRemove.Select(i => i.MonitoredItem));
}
// ensure all nodes on this session are monitored.
Trace($"Start monitoring nodes on endpoint '{EndpointUri.AbsoluteUri}'");
var unmonitoredItems = MonitoredItemsInfo.Where(i => i.State == MonitoredItemInfo.MonitoredItemState.Unmonitored);
foreach (var item in unmonitoredItems)
{
// if the session is disconnected, we stop trying and wait for the next cycle
if (State == SessionState.Disconnected)
{
break;
}
NodeId currentNodeId;
try
{
Subscription subscription = Session.DefaultSubscription;
if (Session.AddSubscription(subscription))
{
Trace("Create default subscription.");
subscription.Create();
}
// lookup namespace index if ExpandedNodeId format has been used and build NodeId identifier.
if (!string.IsNullOrEmpty(item.StartNodeId.NamespaceUri))
{
currentNodeId = NodeId.Create(item.StartNodeId.Identifier, item.StartNodeId.NamespaceUri, _namespaceTable);
}
else
{
currentNodeId = new NodeId((NodeId)item.StartNodeId);
}
// get the DisplayName for the node, otherwise use the nodeId
Node node = Session.ReadNode(currentNodeId);
item.DisplayName = node.DisplayName.Text ?? currentNodeId.ToString();
// add the new monitored item.
MonitoredItem monitoredItem = new MonitoredItem(subscription.DefaultItem)
{
StartNodeId = currentNodeId,
AttributeId = item.AttributeId,
DisplayName = node.DisplayName.Text,
MonitoringMode = item.MonitoringMode,
SamplingInterval = item.SamplingInterval,
QueueSize = item.QueueSize,
DiscardOldest = item.DiscardOldest
};
monitoredItem.Notification += item.Notification;
subscription.AddItem(monitoredItem);
subscription.ApplyChanges();
item.MonitoredItem = monitoredItem;
item.State = MonitoredItemInfo.MonitoredItemState.Monitoreded;
item.EndpointUri = EndpointUri;
Trace($"Created monitored item for node '{currentNodeId}' on endpoint '{EndpointUri.AbsoluteUri}'");
}
catch (Exception e) when(e.GetType() == typeof(ServiceResultException))
{
ServiceResultException sre = (ServiceResultException)e;
switch ((uint)sre.Result.StatusCode)
{
case StatusCodes.BadSessionIdInvalid:
{
Trace($"Session with Id {Session.SessionId} is no longer available on endpoint '{EndpointUri}'. Cleaning up.");
// clean up the session
_opcSessionSemaphore.Release();
Disconnect();
break;
}
case StatusCodes.BadNodeIdInvalid:
case StatusCodes.BadNodeIdUnknown:
{
Trace($"Failed to monitor node '{item.StartNodeId.Identifier}' on endpoint '{EndpointUri}'.");
Trace($"OPC UA ServiceResultException is '{sre.Result}'. Please check your publisher configuration for this node.");
break;
}
default:
{
Trace($"Unhandled OPC UA ServiceResultException '{sre.Result}' when monitoring node '{item.StartNodeId.Identifier}' on endpoint '{EndpointUri}'. Continue.");
break;
}
}
}
catch (Exception e)
{
Trace(e, $"Failed to monitor node '{item.StartNodeId.Identifier}' on endpoint '{EndpointUri}'");
}
}
// shutdown unused sessions.
var unusedSessions = OpcSessions.Where(s => s.MonitoredItemsInfo.Count == 0);
foreach (var unusedSession in unusedSessions)
{
await unusedSession.Shutdown();
OpcSessions.Remove(unusedSession);
}
}
finally
{
_opcSessionSemaphore.Release();
}
}
/// <summary>
/// Creates an item from a reference.
/// </summary>
public void AddItem(ReferenceDescription reference)
{
if (reference == null)
{
return;
}
Node node = m_subscription.Session.NodeCache.Find(reference.NodeId) as Node;
if (node == null)
{
return;
}
Node parent = null;
// if the NodeId is of type string and contains '.' do not use relative paths
if (node.NodeId.IdType != IdType.String || (node.NodeId.Identifier.ToString().IndexOf('.') == -1 &&
node.NodeId.Identifier.ToString().IndexOf('/') == -1))
{
parent = FindParent(node);
}
MonitoredItem monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
if (parent != null)
{
monitoredItem.DisplayName = String.Format("{0}.{1}", parent, node);
}
else
{
monitoredItem.DisplayName = String.Format("{0}", node);
}
monitoredItem.StartNodeId = node.NodeId;
monitoredItem.NodeClass = node.NodeClass;
if (parent != null)
{
List <Node> parents = new List <Node>();
parents.Add(parent);
while (parent.NodeClass != NodeClass.ObjectType && parent.NodeClass != NodeClass.VariableType)
{
parent = FindParent(parent);
if (parent == null)
{
break;
}
parents.Add(parent);
}
monitoredItem.StartNodeId = parents[parents.Count - 1].NodeId;
StringBuilder relativePath = new StringBuilder();
for (int ii = parents.Count - 2; ii >= 0; ii--)
{
relativePath.AppendFormat(".{0}", parents[ii].BrowseName);
}
relativePath.AppendFormat(".{0}", node.BrowseName);
monitoredItem.RelativePath = relativePath.ToString();
}
Session session = m_subscription.Session;
if (node.NodeClass == NodeClass.Object || node.NodeClass == NodeClass.Variable)
{
node.Find(ReferenceTypeIds.HasChild, true);
}
m_subscription.AddItem(monitoredItem);
}
public async Task <ConnectionStatus> OpcClient(string endpointURL)
{
try
{
Uri endpointURI = new Uri(endpointURL);
var selectedEndpoint = CoreClientUtils.SelectEndpoint(endpointURL, false, 15000);
info.LabelText = "Selected endpoint uses: " + selectedEndpoint.SecurityPolicyUri.Substring(selectedEndpoint.SecurityPolicyUri.LastIndexOf('#') + 1);
var endpointConfiguration = EndpointConfiguration.Create(config);
var endpoint = new ConfiguredEndpoint(selectedEndpoint.Server, endpointConfiguration);
endpoint.Update(selectedEndpoint);
var platform = Device.RuntimePlatform;
var sessionName = "";
switch (Device.RuntimePlatform)
{
case "Android":
sessionName = "AIS Demonstrator Android Applikation";
break;
// other cases are irrelevant for the Industrie 4.0 Demonstrator as of now
case "UWP":
sessionName = "OPC UA Xamarin Client UWP";
break;
case "iOS":
sessionName = "OPC UA Xamarin Client IOS";
break;
}
#region OPC UA User Authentication handling
/*
* Partially copied from https://github.com/OPCFoundation/UA-.NETStandard/issues/446
*/
UserTokenPolicy utp = new UserTokenPolicy();
utp.TokenType = UserTokenType.UserName;
UserTokenPolicyCollection utpCollection = new UserTokenPolicyCollection();
utpCollection.Add(utp);
selectedEndpoint.UserIdentityTokens = utpCollection;
selectedEndpoint.SecurityMode = MessageSecurityMode.SignAndEncrypt;
UserIdentity SessionUserIdentity = new UserIdentity(MainActivity.UserName, MainActivity.UserPassword);
#endregion
session = await Session.Create(config, endpoint, false, sessionName, 30000, SessionUserIdentity, null);
if (session != null)
{
connectionStatus = ConnectionStatus.Connected;
#region Subscription + monitoredItems
// Code for Monitored Items based on http://opcfoundation.github.io/UA-.NETStandard/help/index.htm#client_development.htm
// Create Subscription
Subscription subscription = new Subscription() // new Subscription(OpcClient.session.DefaultSubscription)
{
PublishingInterval = 1000,
PublishingEnabled = true
};
// CoffeeLevel
MonitoredItem CoffeeLevel = new MonitoredItem(subscription.DefaultItem)
{
StartNodeId = "ns=1;s=CoffeeLevel",
DisplayName = "MonitoredCoffeeLevel",
AttributeId = Attributes.Value,
MonitoringMode = MonitoringMode.Reporting,
SamplingInterval = 1000, // check the CoffeeLevel every second
QueueSize = 1, // only the most recent value for the CoffeeLevel is needed, thus we only need a queuesize of one
DiscardOldest = true // we only need the most recent value for CoffeeLevel
};
CoffeeLevel.Notification += (sender, e) => OnNotification(sender, e, ref valueCoffeeLevel);
// WaterLevel
MonitoredItem WaterLevel = new MonitoredItem(subscription.DefaultItem)
{
StartNodeId = "ns=1;s=WaterLevel",
DisplayName = "MonitoredWaterLevel",
AttributeId = Attributes.Value,
MonitoringMode = MonitoringMode.Reporting,
SamplingInterval = 1000, // check the CoffeeLevel every second
QueueSize = 1, // only the most recent value for the CoffeeLevel is needed, thus we only need a queuesize of one
DiscardOldest = true // we only need the most recent value for CoffeeLevel
};
WaterLevel.Notification += (sender, e) => OnNotification(sender, e, ref valueWaterLevel);
// CleanlinessLevel
MonitoredItem CleanlinessLevel = new MonitoredItem(subscription.DefaultItem)
{
StartNodeId = "ns=1;s=Cleanliness",
DisplayName = "MonitoredCleanlinessLevel",
AttributeId = Attributes.Value,
MonitoringMode = MonitoringMode.Reporting,
SamplingInterval = 1000, // check the CoffeeLevel every second
QueueSize = 1, // only the most recent value for the CoffeeLevel is needed, thus we only need a queuesize of one
DiscardOldest = true // we only need the most recent value for CoffeeLevel
};
CleanlinessLevel.Notification += (sender, e) => OnNotification(sender, e, ref valueCleanlinessLevel);
// add MonitoredItems to Subscription
subscription.AddItem(CoffeeLevel);
subscription.AddItem(WaterLevel);
subscription.AddItem(CleanlinessLevel);
// add Subscription to Session
session.AddSubscription(subscription);
subscription.Create();
#endregion
}
else
{
connectionStatus = ConnectionStatus.NotConnected;
}
// register keep alive handler
session.KeepAlive += Client_KeepAlive;
}
catch
{
connectionStatus = ConnectionStatus.Error;
}
return(connectionStatus);
}
private void BoilerCB_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
if (m_session == null)
{
return;
}
if (m_subscription != null)
{
m_session.RemoveSubscription(m_subscription);
m_subscription = null;
}
ReferenceDescription boiler = (ReferenceDescription)BoilerCB.SelectedItem;
if (boiler == null)
{
return;
}
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 1000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.Boiler);
string[] browsePaths = new string[]
{
"1:PipeX001/1:FTX001/1:Output",
"1:DrumX001/1:LIX001/1:Output",
"1:PipeX002/1:FTX002/1:Output",
"1:LCX001/1:SetPoint",
};
List <NodeId> nodes = ClientUtils.TranslateBrowsePaths(
m_session,
(NodeId)boiler.NodeId,
wellKnownNamespaceUris,
browsePaths);
Control[] controls = new Control[]
{
InputPipeFlowTB,
DrumLevelTB,
OutputPipeFlowTB,
DrumLevelSetPointTB
};
for (int ii = 0; ii < nodes.Count; ii++)
{
controls[ii].Text = "---";
if (nodes[ii] != null)
{
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = nodes[ii];
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Handle = controls[ii];
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
}
}
m_subscription.ApplyChanges();
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Creates the subscription.
/// </summary>
private void CreateSubscription()
{
m_subscription = new Subscription();
m_subscription.Handle = this;
m_subscription.DisplayName = null;
m_subscription.PublishingInterval = 1000;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 100;
m_subscription.MaxNotificationsPerPublish = 1000;
m_subscription.PublishingEnabled = true;
m_subscription.TimestampsToReturn = TimestampsToReturn.Both;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
m_monitoredItem = new MonitoredItem();
m_monitoredItem.StartNodeId = m_areaId;
m_monitoredItem.AttributeId = Attributes.EventNotifier;
m_monitoredItem.SamplingInterval = 0;
m_monitoredItem.QueueSize = 1000;
m_monitoredItem.DiscardOldest = true;
ChangeFilter(m_filter, false);
m_monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(m_monitoredItem);
m_subscription.ApplyChanges();
}
public void AddSubscription()
{
var subscription = new Subscription();
// check keepAlive
int keepAlive = 0;
Session.KeepAlive += (Session sender, KeepAliveEventArgs e) => { keepAlive++; };
// add current time
var list = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusCurrentTime", StartNodeId = VariableIds.Server_ServerStatus_CurrentTime
}
};
list.ForEach(i => i.Notification += (MonitoredItem item, MonitoredItemNotificationEventArgs e) => {
foreach (var value in item.DequeueValues())
{
TestContext.Out.WriteLine("{0}: {1}, {2}, {3}", item.DisplayName, value.Value, value.SourceTimestamp, value.StatusCode);
}
});
subscription = new Subscription(Session.DefaultSubscription);
TestContext.Out.WriteLine("MaxMessageCount: {0}", subscription.MaxMessageCount);
TestContext.Out.WriteLine("MaxNotificationsPerPublish: {0}", subscription.MaxNotificationsPerPublish);
TestContext.Out.WriteLine("MinLifetimeInterval: {0}", subscription.MinLifetimeInterval);
subscription.AddItem(list.First());
Assert.AreEqual(1, subscription.MonitoredItemCount);
Assert.True(subscription.ChangesPending);
bool result = Session.AddSubscription(subscription);
Assert.True(result);
subscription.Create();
// add state
var list2 = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusState", StartNodeId = VariableIds.Server_ServerStatus_State
}
};
list2.ForEach(i => i.Notification += (MonitoredItem item, MonitoredItemNotificationEventArgs e) => {
foreach (var value in item.DequeueValues())
{
TestContext.Out.WriteLine("{0}: {1}, {2}, {3}", item.DisplayName, value.Value, value.SourceTimestamp, value.StatusCode);
}
});
subscription.AddItems(list);
subscription.ApplyChanges();
subscription.SetPublishingMode(false);
Assert.False(subscription.PublishingEnabled);
subscription.SetPublishingMode(true);
Assert.True(subscription.PublishingEnabled);
Assert.False(subscription.PublishingStopped);
subscription.Priority = 200;
subscription.Modify();
// save
Session.Save(m_subscriptionTestXml);
Thread.Sleep(5000);
OutputSubscriptionInfo(TestContext.Out, subscription);
subscription.ConditionRefresh();
var sre = Assert.Throws <ServiceResultException>(() => subscription.Republish(subscription.SequenceNumber));
Assert.AreEqual(StatusCodes.BadMessageNotAvailable, sre.StatusCode);
subscription.RemoveItems(list);
subscription.ApplyChanges();
subscription.RemoveItem(list2.First());
result = Session.RemoveSubscription(subscription);
Assert.True(result);
}
/// <summary>
/// Creates a new group item.
/// </summary>
public MonitoredItem CreateItem(Subscription subscription)
{
if (subscription == null) throw new ArgumentNullException("subscription");
MonitoredItem monitoredItem = new MonitoredItem(subscription.DefaultItem);
monitoredItem.QueueSize = 1;
if (!new MonitoredItemEditDlg().ShowDialog(subscription.Session, monitoredItem))
{
return null;
}
subscription.AddItem(monitoredItem);
subscription.ChangesCompleted();
return monitoredItem;
}
/// <summary>
/// Reads an verifies all of the nodes.
/// </summary>
private bool DoQueueSizeTest(bool modifyQueueSize)
{
// follow tree from each starting node.
bool success = true;
// collection writeable variables that don't change during the test.
lock (m_variables)
{
m_lastWriteTime = DateTime.MinValue;
m_writeDelayed = false;
m_writeTimerCounter++;
m_variables.Clear();
// collection writeable variables that don't change during the test.
for (int ii = 0; ii < WriteableVariables.Count; ii++)
{
AddVariableToTest(WriteableVariables[ii], m_variables, false);
}
// reduce list based on coverage.
List<TestVariable> variables = new List<TestVariable>();
int counter = 0;
foreach (TestVariable variable in m_variables)
{
if (!CheckCoverage(ref counter))
{
continue;
}
variables.Add(variable);
}
// check if there is anything to work with.
if (variables.Count == 0)
{
Log("WARNING: No writeable variables found.");
Log(WriteTest.g_WriteableVariableHelpText);
return true;
}
m_variables.Clear();
m_variables.AddRange(variables);
ReadEURanges(m_variables);
InitialWrite();
// check if there is anything to work with.
if (m_variables.Count == 0)
{
Log("WARNING: No writeable variables found.");
Log(WriteTest.g_WriteableVariableHelpText);
return true;
}
Log("Starting QueueSizeTest for {0} Variables ({1}% Coverage, Start={2})", m_variables.Count, Configuration.Coverage, m_variables[0].Variable);
m_stopped = 0;
m_writeInterval = 1000;
m_useDeadbandValues = false;
m_errorEvent.Reset();
}
// create subscription.
Subscription subscription = new Subscription();
subscription.PublishingInterval = 5000;
subscription.PublishingEnabled = true;
subscription.Priority = 0;
subscription.KeepAliveCount = 100;
subscription.LifetimeCount = 100;
subscription.MaxNotificationsPerPublish = 100;
Session.AddSubscription(subscription);
subscription.Create();
m_publishingTime = subscription.CurrentPublishingInterval;
m_writerTimer = new Timer(DoWrite, m_writeTimerCounter, 0, m_writeInterval);
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
// create monitored items.
if (success)
{
lock (m_variables)
{
m_monitoredItems = new Dictionary<uint,TestVariable>();
for (int ii = 0; ii < m_variables.Count; ii++)
{
// servers that sample data values may not pick up boolean value changes.
if (m_variables[ii].DataType == BuiltInType.Boolean)
{
continue;
}
VariableNode variable = m_variables[ii].Variable;
for (int jj = 0; jj < 8; jj += 2)
{
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = variable.NodeId;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.RelativePath = null;
monitoredItem.IndexRange = null;
monitoredItem.SamplingInterval = 100;
monitoredItem.QueueSize = (uint)jj;
monitoredItem.DiscardOldest = true;
monitoredItem.Filter = null;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.Handle = m_variables[ii];
m_variables[ii].Notifications[monitoredItem.ClientHandle] = new List<Notification>();
m_monitoredItems[monitoredItem.ClientHandle] = m_variables[ii];
subscription.AddItem(monitoredItem);
}
for (int jj = 2; jj < 8; jj += 2)
{
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = variable.NodeId;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.RelativePath = null;
monitoredItem.IndexRange = null;
monitoredItem.SamplingInterval = 100;
monitoredItem.QueueSize = (uint)jj;
monitoredItem.DiscardOldest = false;
monitoredItem.Filter = null;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.Handle = m_variables[ii];
m_variables[ii].Notifications[monitoredItem.ClientHandle] = new List<Notification>();
m_monitoredItems[monitoredItem.ClientHandle] = m_variables[ii];
subscription.AddItem(monitoredItem);
}
}
}
subscription.ApplyChanges();
// check results.
foreach (MonitoredItem monitoredItem in subscription.MonitoredItems)
{
if (ServiceResult.IsBad(monitoredItem.Status.Error))
{
TestVariable variable = monitoredItem.Handle as TestVariable;
Log(
"Could not create MonitoredItem {0}. NodeId={1}, QueueSize={2}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.QueueSize);
success = false;
}
}
}
// modify sampling interval.
if (success)
{
if (modifyQueueSize)
{
if (!ModifyQueueSize(subscription))
{
success = false;
}
}
}
// wait for first data change.
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
// wait to write some values.
lock (m_variables)
{
m_writeCount = 0;
m_startTime = DateTime.UtcNow;
}
if (success)
{
double increment = MaxProgress/10;
double position = 0;
for (int ii = 0; ii < 20; ii++)
{
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
break;
}
position += increment;
ReportProgress(position);
}
}
int writeCount = 0;
lock (m_variables)
{
m_stopped = 1;
m_endTime = DateTime.UtcNow;
writeCount = m_writeCount;
m_writerTimer.Dispose();
m_writerTimer = null;
}
Session.RemoveSubscription(subscription);
// wait for last data change.
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
// validate results.
if (success)
{
double duration = CalculateInterval(m_startTime, m_endTime);
double expectedWrites = Math.Truncate(duration/m_writeInterval);
if (Math.Abs(expectedWrites - writeCount) > 1)
{
Log(
"WARNING: unexpected number of writes for monitored items: Expected={0}, Actual={1}",
expectedWrites,
writeCount);
}
lock (m_variables)
{
int errorCount = 0;
foreach (MonitoredItem monitoredItem in subscription.MonitoredItems)
{
if (errorCount > 10)
{
break;
}
TestVariable variable = (TestVariable)monitoredItem.Handle;
// ignore values if syntax errors occurred.
if (variable.WriteError)
{
continue;
}
double samplingInterval = monitoredItem.Status.SamplingInterval;
uint queueSize = monitoredItem.Status.QueueSize;
bool discardOldest = monitoredItem.Status.DiscardOldest;
double writesPerPublish = m_publishingTime/m_writeInterval;
double totalPublishes = duration/m_publishingTime;
IList<Notification> notifications = variable.Notifications[monitoredItem.ClientHandle];
int actualNotifications = 0;
int beforeIndex = 0;
int afterIndex = 0;
for (int ii = 0; ii < notifications.Count-1; ii++)
{
actualNotifications++;
Notification before = notifications[ii];
Notification after = notifications[ii+1];
double gap = CalculateInterval(before.Value.SourceTimestamp, after.Value.SourceTimestamp);
// check gap.
if (gap > m_writeInterval + samplingInterval + m_maximumTimingError)
{
bool unexpectedGap = true;
if (queueSize <= 1 || after.Value.StatusCode.Overflow || before.Value.StatusCode.Overflow)
{
unexpectedGap = false;
}
if (unexpectedGap)
{
Log(
"Too much time between consecutive samples: {0}, NodeId={1}, QueueSize={2}, DiscardOldest={3}, SampleIndex={4}, Gap={5}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.Status.QueueSize,
monitoredItem.Status.DiscardOldest,
ii,
gap);
success = false;
errorCount++;
continue;
}
}
// find the value that matches the before value.
beforeIndex = -1;
for (int jj = 0; jj < variable.Values.Count; jj++)
{
if (m_comparer.CompareVariant(variable.Values[jj].WrappedValue, before.Value.WrappedValue))
{
beforeIndex = jj;
break;
}
}
// find the value that matches the after value.
afterIndex = -1;
for (int jj = beforeIndex+1; jj < variable.Values.Count; jj++)
{
if (m_comparer.CompareVariant(variable.Values[jj].WrappedValue, after.Value.WrappedValue))
{
afterIndex = jj;
break;
}
}
// the final write may not have returned.
if (variable.Timestamps.Count > 0)
{
if (variable.Timestamps[variable.Timestamps.Count-1] < after.Value.SourceTimestamp)
{
continue;
}
}
if (beforeIndex < 0 || afterIndex < 0 || afterIndex <= beforeIndex)
{
Log(
"Could not find matching value for sample: {0}, NodeId={1}, QueueSize={2}, DiscardOldest={3}, BeforeIndex={4}, AfterIndex={5}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.Status.QueueSize,
monitoredItem.Status.DiscardOldest,
beforeIndex,
afterIndex);
success = false;
errorCount++;
continue;
}
// validate consecutive samples.
if (afterIndex - beforeIndex == 1)
{
bool unexpectedOverflow = false;
if (discardOldest)
{
if (after.Value.StatusCode.Overflow)
{
unexpectedOverflow = true;
}
}
else
{
if (before.Value.StatusCode.Overflow)
{
// overflow possible if the same value is reported scanned many times.
if (CalculateInterval(before.Timestamp, after.Timestamp) < m_publishingTime/2)
{
unexpectedOverflow = true;
}
}
}
if (unexpectedOverflow)
{
Log(
"Unexpected overflow between consecutive samples: {0}, NodeId={1}, QueueSize={2}, DiscardOldest={3}, SampleIndex={4}, Gap={5}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.Status.QueueSize,
monitoredItem.Status.DiscardOldest,
ii,
gap);
success = false;
errorCount++;
continue;
}
}
else
{
// check for overflow.
bool missingOverflow = false;
if (discardOldest)
{
if (!after.Value.StatusCode.Overflow)
{
missingOverflow = true;
}
}
else
{
if (!before.Value.StatusCode.Overflow)
{
missingOverflow = true;
}
}
// check for legimate overflows.
if (missingOverflow)
{
if (queueSize <= 1)
{
missingOverflow = false;
}
else if (writesPerPublish - queueSize <= 1)
{
missingOverflow = false;
}
}
if (missingOverflow)
{
Log(
"Missing overflow between non-consecutive samples: {0}, NodeId={1}, QueueSize={2}, DiscardOldest={3}, SampleIndex={4}, Gap={5}",
variable.Variable,
variable.Variable.NodeId,
monitoredItem.Status.QueueSize,
monitoredItem.Status.DiscardOldest,
ii,
gap);
success = false;
errorCount++;
continue;
}
}
}
}
}
}
lock (m_variables)
{
Log("Completed QueueSizeTest for {0} Nodes", m_variables.Count);
}
return success;
}
private void BoilerCB_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
if (m_session == null)
{
return;
}
if (m_subscription != null)
{
m_session.RemoveSubscription(m_subscription);
m_subscription = null;
}
ReferenceDescription boiler = (ReferenceDescription)BoilerCB.SelectedItem;
if (boiler == null)
{
return;
}
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 1000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.Boiler);
string[] browsePaths = new string[]
{
"1:PipeX001/1:FTX001/1:Output",
"1:DrumX001/1:LIX001/1:Output",
"1:PipeX002/1:FTX002/1:Output",
"1:LCX001/1:SetPoint",
};
List<NodeId> nodes = ClientUtils.TranslateBrowsePaths(
m_session,
(NodeId)boiler.NodeId,
wellKnownNamespaceUris,
browsePaths);
Control[] controls = new Control[]
{
InputPipeFlowTB,
DrumLevelTB,
OutputPipeFlowTB,
DrumLevelSetPointTB
};
for (int ii = 0; ii < nodes.Count; ii++)
{
controls[ii].Text = "---";
if (nodes[ii] != null)
{
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = nodes[ii];
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Handle = controls[ii];
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
}
}
m_subscription.ApplyChanges();
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Tests the session keep alive when there are no errors.
/// </summary>
private bool DoKeepAliveTest()
{
bool success = true;
double increment = MaxProgress / 3;
double position = 0;
m_keepAliveCount = 0;
int currentKeepAlive = Session.KeepAliveInterval;
List <Subscription> subscriptions = new List <Subscription>();
KeepAliveEventHandler handler = new KeepAliveEventHandler(Session_KeepAlive);
try
{
Session.KeepAlive += handler;
// add several subscriptions with long publish intervals.
for (int publishingInterval = 10000; publishingInterval <= 20000; publishingInterval += 1000)
{
Subscription subscription = new Subscription();
subscription.MaxMessageCount = 100;
subscription.LifetimeCount = 100;
subscription.KeepAliveCount = 10;
subscription.PublishingEnabled = true;
subscription.PublishingInterval = publishingInterval;
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = VariableIds.Server_ServerStatus_CurrentTime;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = -1;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
subscription.AddItem(monitoredItem);
Session.AddSubscription(subscription);
subscription.Create();
subscriptions.Add(subscription);
}
// get a value to read.
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = VariableIds.Server_ServerStatus;
nodeToRead.AttributeId = Attributes.Value;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
nodesToRead.Add(nodeToRead);
int testDuration = 5000;
// make sure the keep alives come at the expected rate.
for (int keepAliveInterval = 500; keepAliveInterval < 2000; keepAliveInterval += 500)
{
m_keepAliveCount = 0;
DateTime start = DateTime.UtcNow;
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticsInfos = null;
Session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticsInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticsInfos, nodesToRead);
ServerStatusDataType status = ExtensionObject.ToEncodeable(results[0].Value as ExtensionObject) as ServerStatusDataType;
if (status == null)
{
Log("Server did not return a valid ServerStatusDataType structure. Value={0}, Status={1}", results[0].WrappedValue, results[0].StatusCode);
return(false);
}
if ((DateTime.UtcNow - start).TotalSeconds > 1)
{
Log("Unexpected delay reading the ServerStatus structure. Delay={0}s", (DateTime.UtcNow - start).TotalSeconds);
return(false);
}
Log("Setting keep alive interval to {0}ms.", keepAliveInterval);
Session.KeepAliveInterval = keepAliveInterval;
if (m_errorEvent.WaitOne(testDuration, false))
{
Log("Unexpected error waiting for session keep alives. {0}", m_error.ToLongString());
return(false);
}
if (m_keepAliveCount < testDuration / keepAliveInterval)
{
Log("Missing session keep alives. Expected={0}, Actual={1}", testDuration / keepAliveInterval, m_keepAliveCount);
return(false);
}
Log("{0} keep alives received in {1}ms.", m_keepAliveCount, testDuration);
position += increment;
ReportProgress(position);
}
ReportProgress(MaxProgress);
}
finally
{
Session.RemoveSubscriptions(subscriptions);
Session.KeepAliveInterval = currentKeepAlive;
Session.KeepAlive -= handler;
}
return(success);
}
/// <summary>
/// Connects the specified endpoint.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
public async void Connect(ConfiguredEndpoint endpoint)
{
if (endpoint != null && m_endpoint != null && endpoint.EndpointUrl != m_endpoint.EndpointUrl)
{
m_adminCredentials = null;
}
if (endpoint == null)
{
endpoint = m_endpoint;
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
}
if (m_session != null)
{
m_session.Dispose();
m_session = null;
}
m_session = await Session.Create(
m_application.ApplicationConfiguration,
endpoint,
true,
false,
m_application.ApplicationName,
60000,
null,
m_preferredLocales);
m_endpoint = m_session.ConfiguredEndpoint;
if (m_session.Factory.GetSystemType(Opc.Ua.DataTypeIds.TrustListDataType) == null)
{
m_session.Factory.AddEncodeableTypes(typeof(Opc.Ua.DataTypeIds).Assembly);
}
RaiseConnectionStatusChangedEvent();
m_session.ReturnDiagnostics = DiagnosticsMasks.SymbolicIdAndText;
m_session.KeepAlive += Session_KeepAlive;
Subscription subscription = new Subscription();
subscription.Handle = this;
subscription.DisplayName = null;
subscription.PublishingInterval = 1000;
subscription.KeepAliveCount = 10;
subscription.LifetimeCount = 100;
subscription.MaxNotificationsPerPublish = 1000;
subscription.PublishingEnabled = true;
subscription.TimestampsToReturn = TimestampsToReturn.Neither;
m_session.AddSubscription(subscription);
subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = Opc.Ua.VariableIds.Server_ServerStatus;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
monitoredItem.Handle = typeof(ServerStatusDataType);
monitoredItem.Notification += ServerStatus_Notification;
subscription.AddItem(monitoredItem);
subscription.ApplyChanges();
}
/// <summary>
/// Creates the subscription.
/// </summary>
private void CreateSubscription()
{
if (m_session == null)
{
return;
}
m_subscription = new Subscription();
m_subscription.Handle = this;
m_subscription.DisplayName = null;
m_subscription.PublishingInterval = 1000;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 100;
m_subscription.MaxNotificationsPerPublish = 1000;
m_subscription.PublishingEnabled = true;
m_subscription.TimestampsToReturn = TimestampsToReturn.Both;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
m_monitoredItem = new MonitoredItem();
m_monitoredItem.StartNodeId = m_nodeId;
m_monitoredItem.AttributeId = Attributes.Value;
m_monitoredItem.SamplingInterval = (int)SamplingIntervalNP.Value;
m_monitoredItem.QueueSize = 1000;
m_monitoredItem.DiscardOldest = true;
// specify aggregate filter.
if (AggregateCB.SelectedItem != null)
{
AggregateFilter filter = new AggregateFilter();
if (StartTimeCK.Checked)
{
filter.StartTime = StartTimeDP.Value.ToUniversalTime();
}
else
{
filter.StartTime = DateTime.UtcNow;
}
filter.ProcessingInterval = (double)ResampleIntervalNP.Value;
filter.AggregateType = ((AvailableAggregate)AggregateCB.SelectedItem).NodeId;
if (filter.AggregateType != null)
{
m_monitoredItem.Filter = filter;
}
}
m_monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(m_monitoredItem);
m_subscription.ApplyChanges();
SubscriptionStateChanged();
}
private async Task CreateAndRunClient()
{
Console.WriteLine("1 - Create an Application Configuration.");
ExitCodeValue = ExitCode.ErrorCreateApplication;
ApplicationConfiguration config = this.CreateApplicationConfiguration();
await config.Validate(ApplicationType.Client);
bool haveAppCertificate = config.SecurityConfiguration.ApplicationCertificate.Certificate != null;
ApplicationInstance application = new ApplicationInstance(config);
if (haveAppCertificate)
{
config.ApplicationUri = Utils.GetApplicationUriFromCertificate(config.SecurityConfiguration.ApplicationCertificate.Certificate);
config.CertificateValidator.CertificateValidation += new CertificateValidationEventHandler(CertificateValidator_CertificateValidation);
}
else
{
// Check if any certificates were mounted and secure connection was desired
if (Directory.Exists(ClientPKIPath))
{
throw new ArgumentException("Application certificates passed as secrets could not be used. Make sure application subject name is AkriClient, the certs are in der format, and the private key in pfx format");
}
Console.WriteLine("Application certificates not mounted, using unsecure connection with Security Policy None");
}
Console.WriteLine("Client is using a certificate with subject " + config.SecurityConfiguration.ApplicationCertificate.SubjectName);
Console.WriteLine("2 - Discover endpoints of {0}.", DiscoveryURL);
ExitCodeValue = ExitCode.ErrorDiscoverEndpoints;
EndpointDescription selectedEndpoint = CoreClientUtils.SelectEndpoint(DiscoveryURL, haveAppCertificate, (int)TimeSpan.FromSeconds(15).TotalMilliseconds);
Console.WriteLine(" Selected endpoint uses: {0}",
selectedEndpoint.SecurityPolicyUri.Substring(selectedEndpoint.SecurityPolicyUri.LastIndexOf('#') + 1));
Console.WriteLine("3 - Create a session with OPC UA server.");
ExitCodeValue = ExitCode.ErrorCreateSession;
var endpointConfiguration = EndpointConfiguration.Create(config);
var endpoint = new ConfiguredEndpoint(null, selectedEndpoint, endpointConfiguration);
Session = await Session.Create(config, endpoint, false, "Akri Client", (uint)TimeSpan.FromSeconds(60).TotalMilliseconds, new UserIdentity(new AnonymousIdentityToken()), null);
// Register keep alive handler to monitor the status of the session
Session.KeepAlive += Client_KeepAlive;
Console.WriteLine("4 - Browse the OPC UA server namespace.");
DoBrowse();
Console.WriteLine("5 - Create a subscription with publishing interval of 1 second.");
ExitCodeValue = ExitCode.ErrorCreateSubscription;
var subscription = new Subscription(Session.DefaultSubscription)
{
PublishingInterval = (int)TimeSpan.FromSeconds(1).TotalMilliseconds
};
Console.WriteLine("6 - Add node {0} to the subscription.", Program.MonitoredNodeId.Identifier);
ExitCodeValue = ExitCode.ErrorMonitoredItem;
var monitoredNode = new MonitoredItem(subscription.DefaultItem)
{
DisplayName = Program.MonitoredNodeId.Identifier.ToString(),
StartNodeId = Program.MonitoredNodeId,
};
monitoredNode.Notification += OnNotification;
subscription.AddItem(monitoredNode);
Console.WriteLine("7 - Add the subscription to the session.");
// TODO: Find way to detect if passed improper NodeID, since if NodeID is not valid, no error is thrown by server
ExitCodeValue = ExitCode.ErrorAddSubscription;
Session.AddSubscription(subscription);
subscription.Create();
Console.WriteLine("8 - Running...Press Ctrl-C to exit...");
ExitCodeValue = ExitCode.ErrorRunning;
}
/// <summary>
/// Adds a item to a subscription.
/// </summary>
private void Subscribe(Subscription subscription, ReferenceDescription reference)
{
MonitoredItem monitoredItem = new MonitoredItem(subscription.DefaultItem);
monitoredItem.DisplayName = subscription.Session.NodeCache.GetDisplayText(reference);
monitoredItem.StartNodeId = (NodeId)reference.NodeId;
monitoredItem.NodeClass = (NodeClass)reference.NodeClass;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = 0;
monitoredItem.QueueSize = 1;
// add condition fields to any event filter.
EventFilter filter = monitoredItem.Filter as EventFilter;
if (filter != null)
{
monitoredItem.AttributeId = Attributes.EventNotifier;
monitoredItem.QueueSize = 0;
}
subscription.AddItem(monitoredItem);
subscription.ApplyChanges();
}
/// <summary>
/// Creates the subscription.
/// </summary>
private void CreateSubscription()
{
if (m_session == null)
{
return;
}
m_subscription = new Subscription();
m_subscription.Handle = this;
m_subscription.DisplayName = null;
m_subscription.PublishingInterval = 500;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 100;
m_subscription.MaxNotificationsPerPublish = 1000;
m_subscription.PublishingEnabled = true;
m_subscription.TimestampsToReturn = TimestampsToReturn.Both;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = m_nodeId;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 1000;
monitoredItem.DiscardOldest = true;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
// verify that the item was created successfully.
if (ServiceResult.IsBad(monitoredItem.Status.Error))
{
throw new ServiceResultException(monitoredItem.Status.Error);
}
}
public async Task AddSubscriptionAsync()
{
var subscription = new Subscription();
// check keepAlive
int keepAlive = 0;
m_session.KeepAlive += (Session sender, KeepAliveEventArgs e) => { keepAlive++; };
// add current time
var list = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusCurrentTime", StartNodeId = VariableIds.Server_ServerStatus_CurrentTime
}
};
list.ForEach(i => i.Notification += (MonitoredItem item, MonitoredItemNotificationEventArgs e) => {
foreach (var value in item.DequeueValues())
{
TestContext.Out.WriteLine("{0}: {1}, {2}, {3}", item.DisplayName, value.Value, value.SourceTimestamp, value.StatusCode);
}
});
subscription = new Subscription(m_session.DefaultSubscription);
TestContext.Out.WriteLine("MaxMessageCount: {0}", subscription.MaxMessageCount);
TestContext.Out.WriteLine("MaxNotificationsPerPublish: {0}", subscription.MaxNotificationsPerPublish);
TestContext.Out.WriteLine("MinLifetimeInterval: {0}", subscription.MinLifetimeInterval);
subscription.AddItem(list.First());
Assert.AreEqual(1, subscription.MonitoredItemCount);
Assert.True(subscription.ChangesPending);
bool result = await m_session.RemoveSubscriptionAsync(subscription);
Assert.False(result);
result = await m_session.RemoveSubscriptionsAsync(new List <Subscription>() { subscription });
Assert.False(result);
result = m_session.AddSubscription(subscription);
Assert.True(result);
result = m_session.AddSubscription(subscription);
Assert.False(result);
result = await m_session.RemoveSubscriptionsAsync(new List <Subscription>() { subscription });
Assert.True(result);
result = await m_session.RemoveSubscriptionAsync(subscription);
Assert.False(result);
result = m_session.AddSubscription(subscription);
Assert.True(result);
await subscription.CreateAsync().ConfigureAwait(false);
// add state
var list2 = new List <MonitoredItem> {
new MonitoredItem(subscription.DefaultItem)
{
DisplayName = "ServerStatusState", StartNodeId = VariableIds.Server_ServerStatus_State
}
};
list2.ForEach(i => i.Notification += (MonitoredItem item, MonitoredItemNotificationEventArgs e) => {
foreach (var value in item.DequeueValues())
{
TestContext.Out.WriteLine("{0}: {1}, {2}, {3}", item.DisplayName, value.Value, value.SourceTimestamp, value.StatusCode);
}
});
subscription.AddItems(list);
await subscription.ApplyChangesAsync().ConfigureAwait(false);
await subscription.SetPublishingModeAsync(false).ConfigureAwait(false);
Assert.False(subscription.PublishingEnabled);
await subscription.SetPublishingModeAsync(true).ConfigureAwait(false);
Assert.True(subscription.PublishingEnabled);
Assert.False(subscription.PublishingStopped);
subscription.Priority = 200;
await subscription.ModifyAsync().ConfigureAwait(false);
// save
m_session.Save(SubscriptionTestXml);
await Task.Delay(5000).ConfigureAwait(false);
TestContext.Out.WriteLine("CurrentKeepAliveCount : {0}", subscription.CurrentKeepAliveCount);
TestContext.Out.WriteLine("CurrentPublishingEnabled: {0}", subscription.CurrentPublishingEnabled);
TestContext.Out.WriteLine("CurrentPriority : {0}", subscription.CurrentPriority);
TestContext.Out.WriteLine("PublishTime : {0}", subscription.PublishTime);
TestContext.Out.WriteLine("LastNotificationTime : {0}", subscription.LastNotificationTime);
TestContext.Out.WriteLine("SequenceNumber : {0}", subscription.SequenceNumber);
TestContext.Out.WriteLine("NotificationCount : {0}", subscription.NotificationCount);
TestContext.Out.WriteLine("LastNotification : {0}", subscription.LastNotification);
TestContext.Out.WriteLine("Notifications : {0}", subscription.Notifications.Count());
TestContext.Out.WriteLine("OutstandingMessageWorker: {0}", subscription.OutstandingMessageWorkers);
await subscription.ConditionRefreshAsync().ConfigureAwait(false);
var sre = Assert.Throws <ServiceResultException>(() => subscription.Republish(subscription.SequenceNumber));
Assert.AreEqual(StatusCodes.BadMessageNotAvailable, sre.StatusCode);
subscription.RemoveItems(list);
await subscription.ApplyChangesAsync().ConfigureAwait(false);
subscription.RemoveItem(list2.First());
result = await m_session.RemoveSubscriptionAsync(subscription).ConfigureAwait(false);
Assert.True(result);
}
private void AddSubscription()
{
try
{
if (m_session == null)
{
return;
}
if (m_subscription != null)
{
m_session.RemoveSubscription(m_subscription);
m_subscription = null;
}
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 5000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 5000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
for (int ii = 0; ii < tanksRef.Count; ii++)
{
// filter the node (should be the tank)
if (tanksRef[ii].BrowseName.Name.Contains(TankDataTypes.tanks))
{
BrowseDescription n = new BrowseDescription();
n.NodeId = (NodeId)tanksRef[ii].NodeId;
n.BrowseDirection = BrowseDirection.Forward;
n.IncludeSubtypes = true;
n.NodeClassMask = (uint)(NodeClass.Variable);
n.ResultMask = (uint)(BrowseResultMask.All);
ReferenceDescriptionCollection props = ClientUtils.Browse(
m_session,
n,
false);
if (props.Count > 0)
{
for (int jj = 0; jj < props.Count; jj++)
{
// filter the Properties of the tank
if (TankDataTypes.containsProp(props[jj].DisplayName.Text))
{
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = (NodeId)props[jj].NodeId;
monitoredItem.DisplayName = props[jj].BrowseName.Name;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
}
}
}
}
}
m_subscription.ApplyChanges();
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
/// <summary>
/// Add the <see cref="MonitoredItem"/> to the subscription.
/// Derived tests should call this method after having configured the
/// <see cref="MonitoredItem"/> definition, e.g. with filters.
/// </summary>
protected void AddMonitoredItem()
{
_subscription.AddItem(MonitoredItem);
_subscription.ApplyChanges();
}
/// <summary>
/// Connects to a server.
/// </summary>
private void Server_ConnectMI_Click(object sender, EventArgs e)
{
try
{
// disconnect any existing session.
Server_DisconnectMI_Click(sender, e);
InitialStateTB.Text = "1";
FinalStateTB.Text = "100";
// create the session.
EndpointDescription endpointDescription = SelectEndpoint();
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(m_configuration);
ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
m_session = Session.Create(
m_configuration,
endpoint,
true,
m_configuration.ApplicationName,
60000,
null,
null);
// set up keep alive callback.
m_session.KeepAliveInterval = 2000;
m_session.KeepAlive += new KeepAliveEventHandler(Session_KeepAlive);
// this client has built-in knowledge of the information model used by the server.
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.Methods);
string[] browsePaths = new string[]
{
"1:My Process/1:State",
"1:My Process",
"1:My Process/1:Start"
};
List <NodeId> nodes = FormUtils.TranslateBrowsePaths(
m_session,
ObjectIds.ObjectsFolder,
wellKnownNamespaceUris,
browsePaths);
// subscribe to the state if available.
if (nodes.Count > 0 && !NodeId.IsNull(nodes[0]))
{
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 1000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = nodes[0];
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
}
// save the object/method
if (nodes.Count > 2)
{
m_objectNode = nodes[1];
m_methodNode = nodes[2];
}
ConnectedLB.Text = "Connected";
ServerUrlLB.Text = endpointDescription.EndpointUrl;
LastKeepAliveTimeLB.Text = "---";
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Tests the session reconnect.
/// </summary>
private bool DoReconnectTest()
{
double increment = MaxProgress/6;
double position = 0;
bool success = true;
lock (m_messages)
{
m_messages.Clear();
}
int currentKeepAlive = Session.KeepAliveInterval;
List<Subscription> subscriptions = new List<Subscription>();
KeepAliveEventHandler keepAliveHandler = new KeepAliveEventHandler(Session_Reconnect);
NotificationEventHandler notificationHandler = new NotificationEventHandler(Session_Notification);
try
{
Session.KeepAlive += keepAliveHandler;
Session.Notification += notificationHandler;
for (int publishingInterval = 1000; publishingInterval <= 10000; publishingInterval += 1000)
{
Subscription subscription = new Subscription();
subscription.MaxMessageCount = 100;
subscription.LifetimeCount = 100;
subscription.KeepAliveCount = 10;
subscription.PublishingEnabled = true;
subscription.PublishingInterval = publishingInterval;
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = VariableIds.Server_ServerStatus_CurrentTime;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = -1;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
subscription.AddItem(monitoredItem);
Session.AddSubscription(subscription);
subscription.Create();
subscriptions.Add(subscription);
}
m_keepAliveCount = 0;
Session.KeepAliveInterval = 1000;
Log("Setting keep alive interval to {0}ms.", Session.KeepAliveInterval);
int testDuration = 3000;
for (int ii = 0; ii < 6; ii++)
{
Session.Reconnect();
Log("Session reconnected. KeepAlives={0}", m_keepAliveCount);
if (m_errorEvent.WaitOne(testDuration, false))
{
Log("Unexpected error waiting for session keep alives. {0}", m_error.ToLongString());
return false;
}
position += increment;
ReportProgress(position);
}
}
finally
{
Session.RemoveSubscriptions(subscriptions);
Session.KeepAliveInterval = currentKeepAlive;
Session.KeepAlive -= keepAliveHandler;
Session.Notification -= notificationHandler;
}
ReportProgress(MaxProgress);
lock (m_messages)
{
foreach (KeyValuePair<uint,List<uint>> entry in m_messages)
{
entry.Value.Sort();
for (int ii = 0; ii < entry.Value.Count-1; ii++)
{
if (entry.Value[ii+1] - entry.Value[ii] > 1)
{
Log("Missing message. Subscription={0}, SequenceNumber={1}-{2}", entry.Key, entry.Value[ii]+1, entry.Value[ii+1]-1);
}
if (entry.Value[ii+1] == entry.Value[ii])
{
// Log("Duplicate message. Subscription={0}, SequenceNumber={1}", entry.Key, entry.Value[ii]);
}
}
}
}
return success;
}
/// <summary>
/// Creates the subscription.
/// </summary>
private void CreateSubscription()
{
// create the default subscription.
m_subscription = new Subscription();
m_subscription.DisplayName = null;
m_subscription.PublishingInterval = 1000;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 100;
m_subscription.MaxNotificationsPerPublish = 1000;
m_subscription.PublishingEnabled = true;
m_subscription.TimestampsToReturn = TimestampsToReturn.Both;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
// a table used to track event types.
m_eventTypeMappings = new Dictionary<NodeId, NodeId>();
NodeId knownEventId = ExpandedNodeId.ToNodeId(ObjectTypeIds.SystemCycleStatusEventType, m_session.NamespaceUris);
m_knownEventTypes = new Dictionary<NodeId, Type>();
m_knownEventTypes.Add(knownEventId, typeof(SystemCycleStatusEventState));
TypeDeclaration type = new TypeDeclaration();
type.NodeId = ExpandedNodeId.ToNodeId(ObjectTypeIds.SystemCycleStatusEventType, m_session.NamespaceUris);
type.Declarations = ClientUtils.CollectInstanceDeclarationsForType(m_session, type.NodeId);
// the filter to use.
m_filter = new FilterDeclaration(type, null);
// declate callback.
m_MonitoredItem_Notification = new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
// create a monitored item based on the current filter settings.
m_monitoredItem = new MonitoredItem();
m_monitoredItem.StartNodeId = Opc.Ua.ObjectIds.Server;
m_monitoredItem.AttributeId = Attributes.EventNotifier;
m_monitoredItem.SamplingInterval = 0;
m_monitoredItem.QueueSize = 1000;
m_monitoredItem.DiscardOldest = true;
m_monitoredItem.Filter = m_filter.GetFilter();
// set up callback for notifications.
m_monitoredItem.Notification += m_MonitoredItem_Notification;
m_subscription.AddItem(m_monitoredItem);
m_subscription.ApplyChanges();
}
/// <summary>
/// Synchronize monitored items and triggering configuration in subscription
/// </summary>
/// <param name="rawSubscription"></param>
/// <param name="monitoredItems"></param>
/// <returns></returns>
private async Task SetMonitoredItemsAsync(
Subscription rawSubscription, IEnumerable <MonitoredItemModel> monitoredItems)
{
if (monitoredItems == null)
{
return;
}
// Synchronize the desired items with the state of the raw subscription
var desiredState = monitoredItems
.Select(m => new MonitoredItemWrapper(m, _logger))
.ToHashSetSafe();
var currentState = rawSubscription.MonitoredItems
.Select(m => m.Handle)
.OfType <MonitoredItemWrapper>()
.ToHashSetSafe();
var applyChanges = false;
// Remove monitored items not in desired state
foreach (var toRemove in currentState.Except(desiredState))
{
_logger.Debug("Removing monitored item '{item}'...", toRemove);
toRemove.Item.Notification -= OnMonitoredItemChanged;
rawSubscription.RemoveItem(toRemove.Item);
applyChanges = true;
}
// Re-associate detached handles
foreach (var detached in rawSubscription.MonitoredItems
.Where(m => m.Handle == null))
{
// TODO: Claim monitored item
rawSubscription.RemoveItem(detached);
}
var nowMonitored = new List <MonitoredItemWrapper>();
var codec = _outer._codec.Create(rawSubscription.Session.MessageContext);
// Add new monitored items not in current state
foreach (var toAdd in desiredState.Except(currentState))
{
_logger.Debug("Adding new monitored item '{item}'...", toAdd);
// Create monitored item
toAdd.Create(rawSubscription.Session, codec);
toAdd.Item.Notification += OnMonitoredItemChanged;
rawSubscription.AddItem(toAdd.Item);
nowMonitored.Add(toAdd);
applyChanges = true;
}
// Update monitored items that have changed
var desiredUpdates = desiredState.Intersect(currentState)
.ToDictionary(k => k, v => v);
foreach (var toUpdate in currentState.Intersect(desiredState))
{
if (toUpdate.MergeWith(desiredUpdates[toUpdate]))
{
_logger.Debug("Updating monitored item '{item}'...", toUpdate);
applyChanges = true;
}
nowMonitored.Add(toUpdate);
}
if (applyChanges)
{
rawSubscription.ApplyChanges();
foreach (var monitoredItem in nowMonitored)
{
if (monitoredItem.Item.Status.Error != null &&
StatusCode.IsBad(monitoredItem.Item.Status.Error.StatusCode))
{
_logger.Error("Error while monitoring node {id} in subscription " +
"{subscriptionId}, status code: {code}",
monitoredItem.Item.StartNodeId, monitoredItem.Item.Subscription.Id,
monitoredItem.Item.Status.Error.StatusCode);
}
}
var count = rawSubscription.MonitoredItems.Count(m => m.Status.Error == null);
kMonitoredItems.WithLabels(rawSubscription.Id.ToString()).Set(count);
_logger.Information("Now monitoring {count} nodes in subscription " +
"{subscriptionId} (Session: {sessionId}).", count, rawSubscription.Id,
rawSubscription.Session.SessionName);
}
var map = nowMonitored.ToDictionary(
k => k.Template.Id ?? k.Template.StartNodeId, v => v);
foreach (var item in nowMonitored.ToList())
{
if (item.Template.TriggerId != null &&
map.TryGetValue(item.Template.TriggerId, out var trigger))
{
trigger?.AddTriggerLink(item.ServerId.GetValueOrDefault());
}
}
// Set up any new trigger configuration if needed
foreach (var item in nowMonitored.ToList())
{
if (item.GetTriggeringLinks(out var added, out var removed))
{
var response = await rawSubscription.Session.SetTriggeringAsync(
null, rawSubscription.Id, item.ServerId.GetValueOrDefault(),
new UInt32Collection(added), new UInt32Collection(removed));
}
}
// Change monitoring mode of all items if necessary
foreach (var change in nowMonitored.GroupBy(i => i.GetMonitoringModeChange()))
{
if (change.Key == null)
{
continue;
}
await rawSubscription.Session.SetMonitoringModeAsync(null,
rawSubscription.Id, change.Key.Value,
new UInt32Collection(change.Select(i => i.ServerId ?? 0)));
}
_currentlyMonitored = nowMonitored;
// Set timer to check connection periodically
if (_currentlyMonitored.Count > 0)
{
_timer.Change(TimeSpan.FromSeconds(10), Timeout.InfiniteTimeSpan);
}
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
// browse the instances in the server.
//BrowseCTRL.Initialize(m_session, ObjectIds.ObjectsFolder, ReferenceTypeIds.Organizes, ReferenceTypeIds.Aggregates);
//verify if Session is established
if (m_session != null)
{
//verify if the Subscription was not already created
if (m_subscription == null)
{
//create the subscritpion
m_subscription = new Subscription(m_session.DefaultSubscription);
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000; //1000msec interval
m_session.AddSubscription(m_subscription);
m_subscription.Create();
}
//Add myVar to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=myVar1";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
myVar_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add model to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=6;i=6023";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Model_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add myArrayVar to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=myArrayVar";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
myArrayVar_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add Start_Piece to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Start_Piece";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Start_Piece_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//**********************************************************************************
//Add Change Mould to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Mould_Changed";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Mould_Changed_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add Change Mould to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Change_Mould";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Change_Mould_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//Add Mould_tobeused to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Mould_tobeused";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Mould_tobeused_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
//**********************************************************************************
//Add atual_state to monitored items
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
monitoredItem.StartNodeId = "ns=3;s=Actual_State";
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = 1000;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
//get handle number
Actual_State_handle = monitoredItem.ClientHandle;
//define event handler for this item, and then add to subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(monitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
DataValueCollection results = Read_Value("ns=3;s=Mould_1");
DataValueCollection results1 = Read_Value("ns=3;s=Mould_2");
string Mould_1Value = (string)results[0].Value;
string Mould_2Value = (string)results1[0].Value;
comboBox1.Items.Add(Mould_1Value);
comboBox1.Items.Add(Mould_2Value);
}
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
if (m_session == null)
{
StartBTN.Enabled = false;
return;
}
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
// this client has built-in knowledge of the information model used by the server.
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.Methods);
string[] browsePaths = new string[]
{
"1:My Process/1:State",
"1:My Process",
"1:My Process/1:Start"
};
List <NodeId> nodes = ClientUtils.TranslateBrowsePaths(
m_session,
ObjectIds.ObjectsFolder,
wellKnownNamespaceUris,
browsePaths);
// subscribe to the state if available.
if (nodes.Count > 0 && !NodeId.IsNull(nodes[0]))
{
m_subscription = new Subscription();
m_subscription.PublishingEnabled = true;
m_subscription.PublishingInterval = 1000;
m_subscription.Priority = 1;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 20;
m_subscription.MaxNotificationsPerPublish = 1000;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = nodes[0];
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
m_subscription.AddItem(monitoredItem);
m_subscription.ApplyChanges();
}
// save the object/method
if (nodes.Count > 2)
{
m_objectNode = nodes[1];
m_methodNode = nodes[2];
}
InitialStateTB.Text = "1";
FinalStateTB.Text = "100";
StartBTN.Enabled = true;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditEventForm"/> class.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="subscription">The subscription.</param>
public AuditEventForm(Session session, Subscription subscription)
{
InitializeComponent();
m_session = session;
m_subscription = subscription;
// a table used to track event types.
m_eventTypeMappings = new Dictionary<NodeId, NodeId>();
// the filter to use.
m_filter = new FilterDefinition();
m_filter.AreaId = ObjectIds.Server;
m_filter.Severity = EventSeverity.Min;
m_filter.IgnoreSuppressedOrShelved = true;
m_filter.EventTypes = new NodeId[] { ObjectTypeIds.AuditUpdateMethodEventType };
// find the fields of interest.
m_filter.SelectClauses = m_filter.ConstructSelectClauses(m_session, ObjectTypeIds.AuditUpdateMethodEventType);
// declate callback.
m_MonitoredItem_Notification = new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
// create a monitored item based on the current filter settings.
m_monitoredItem = m_filter.CreateMonitoredItem(m_session);
// set up callback for notifications.
m_monitoredItem.Notification += m_MonitoredItem_Notification;
m_subscription.AddItem(m_monitoredItem);
m_subscription.ApplyChanges();
}
/// <summary>
/// Updates the application after connecting to or disconnecting from the server.
/// </summary>
private void Server_ConnectComplete(object sender, EventArgs e)
{
try
{
m_session = ConnectServerCTRL.Session;
// check for disconnect.
if (m_session == null)
{
if (m_auditEventForm != null)
{
m_auditEventForm.Close();
m_auditEventForm = null;
}
return;
}
// set a suitable initial state.
if (m_session != null && !m_connectedOnce)
{
m_connectedOnce = true;
}
// create the default subscription.
m_subscription = new Subscription();
m_subscription.DisplayName = null;
m_subscription.PublishingInterval = 1000;
m_subscription.KeepAliveCount = 10;
m_subscription.LifetimeCount = 100;
m_subscription.MaxNotificationsPerPublish = 1000;
m_subscription.PublishingEnabled = true;
m_subscription.TimestampsToReturn = TimestampsToReturn.Both;
m_session.AddSubscription(m_subscription);
m_subscription.Create();
// must specify the fields that the form is interested in.
m_filter.SelectClauses = m_filter.ConstructSelectClauses(
m_session,
NodeId.Parse("ns=2;s=4:2"),
NodeId.Parse("ns=2;s=4:1"),
ObjectTypeIds.DialogConditionType,
ObjectTypeIds.ExclusiveLimitAlarmType,
ObjectTypeIds.NonExclusiveLimitAlarmType);
// create a monitored item based on the current filter settings.
m_monitoredItem = m_filter.CreateMonitoredItem(m_session);
// set up callback for notifications.
m_monitoredItem.Notification += m_MonitoredItem_Notification;
m_subscription.AddItem(m_monitoredItem);
m_subscription.ApplyChanges();
// send an initial refresh.
Conditions_RefreshMI_Click(sender, e);
ConditionsMI.Enabled = true;
ViewMI.Enabled = true;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
public MonitoredItemView CreateMonitoredItem(uint subscriptionId, ushort namespaceIndex, string identifierNode, int samplingInterval, bool discardOldest, uint queueSize, int monitoringMode, int filterTrigger, uint deadbandType, double deadbandValue)
{
Subscription sub = GetSubscription(subscriptionId);
NodeId node;
//Initialize Filter Parameters
DataChangeTrigger _trigger;
string filterTriggerView;
switch (filterTrigger)
{
case 0:
_trigger = DataChangeTrigger.Status;
filterTriggerView = "Status";
break;
case 1:
_trigger = DataChangeTrigger.StatusValue;
filterTriggerView = "StatusValue";
break;
case 2:
_trigger = DataChangeTrigger.StatusValueTimestamp;
filterTriggerView = "StatusValueTimestamp";
break;
default:
_trigger = DataChangeTrigger.StatusValue;
filterTriggerView = "StatusValue";
break;
}
string deadbandTypeView;
switch (deadbandType)
{
case 0:
deadbandTypeView = "None";
break;
case 1:
deadbandTypeView = "Absolute";
break;
case 2:
deadbandTypeView = "Percent";
break;
default:
deadbandTypeView = null;
break;
}
DataChangeFilter filter = new DataChangeFilter()
{
Trigger = _trigger,
DeadbandType = deadbandType,
DeadbandValue = deadbandValue
};
//Initialize Monitored Item Parameters
MonitoringMode _monitoringMode;
switch (monitoringMode)
{
case 0:
_monitoringMode = MonitoringMode.Disabled;
break;
case 1:
_monitoringMode = MonitoringMode.Sampling;
break;
case 2:
_monitoringMode = MonitoringMode.Reporting;
break;
default:
_monitoringMode = MonitoringMode.Reporting;
break;
}
//Set NodeId della variabile che si vuole leggere con gestione dell'identifier sia string che integer
node = new NodeId(identifierNode, namespaceIndex);
try
{
session.ReadNode(node);
}
catch (ServiceResultException)
{ throw new NoNodeToReadException("Node not found!"); }
MonitoredItem monitoredItem = new MonitoredItem(clientHandle)
{
AttributeId = Attributes.Value,
DiscardOldest = discardOldest,
Filter = filter,
MonitoringMode = _monitoringMode,
NodeClass = NodeClass.Variable,
QueueSize = queueSize,
SamplingInterval = samplingInterval,
StartNodeId = node
};
clientHandle++; //Identifier di un singolo monitored item --> univoco solo all'interno della subscription
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(OnNotificationItem);
//Aggiunge l'item tra i monitored items della subscription senza crearlo
sub.AddItem(monitoredItem);
//Se aggiungiamo altri monitoredItem la funzione successiva li creerà tutti
//Comunica con il server e crea effettivamente il monitoredItem
IList <MonitoredItem> createdMonitoredItems = sub.CreateItems();
sub.ApplyChanges();
//Questa funzione ritorna la lista dei monitoredItems creati al momento della chiamata
return(new MonitoredItemView(monitoredItem.ClientHandle, monitoredItem.ResolvedNodeId.NamespaceIndex, monitoredItem.ResolvedNodeId.Identifier.ToString(), subscriptionId, monitoredItem.SamplingInterval, filterTriggerView, deadbandTypeView, deadbandValue));
}
/// <summary>
/// Creates the subscription.
/// </summary>
private void CreateSubscription()
{
if (m_subscription != null)
{
m_subscription.Dispose();
m_subscription = null;
}
// get the current session.
Session session = m_server.Session;
if (session == null)
{
return;
}
// create the subscription.
m_subscription = new Subscription();
m_subscription.PublishingEnabled = Active;
m_subscription.PublishingInterval = (int)Math.Max(BufferTime, 1000);
m_subscription.KeepAliveCount = (uint)Math.Max(Math.Ceiling(((double)KeepAlive)/m_subscription.PublishingInterval), 10);
m_subscription.LifetimeCount = m_subscription.KeepAliveCount*3;
m_subscription.MaxNotificationsPerPublish = MaxSize;
m_subscription.TimestampsToReturn = TimestampsToReturn.Neither;
m_subscription.Priority = 0;
m_subscription.FastEventCallback = OnEventNotification;
m_subscription.DisableMonitoredItemCache = true;
session.AddSubscription(m_subscription);
m_subscription.Create();
// update the monitored items.
EventFilter filter = m_filter.GetFilter();
MonitoringMode monitoringMode = (Active)?MonitoringMode.Reporting:MonitoringMode.Disabled;
foreach (MonitoredItem monitoredItem in m_notifiers.Values)
{
monitoredItem.Filter = filter;
monitoredItem.MonitoringMode = monitoringMode;
m_subscription.AddItem(monitoredItem);
}
m_subscription.ApplyChanges();
}
/// <summary>
/// Reads an verifies all of the nodes.
/// </summary>
private bool DoDeadbandTest(bool modifyDeadband)
{
// follow tree from each starting node.
bool success = true;
// collection writeable variables that don't change during the test.
lock (m_variables)
{
m_lastWriteTime = DateTime.MinValue;
m_writeDelayed = false;
m_writeTimerCounter++;
m_variables.Clear();
// collection writeable variables that don't change during the test.
for (int ii = 0; ii < WriteableVariables.Count; ii++)
{
AddVariableToTest(WriteableVariables[ii], m_variables, true);
}
// reduce list based on coverage.
List<TestVariable> variables = new List<TestVariable>();
int counter = 0;
foreach (TestVariable variable in m_variables)
{
if (!CheckCoverage(ref counter))
{
continue;
}
variables.Add(variable);
}
// check if there is anything to work with.
if (variables.Count == 0)
{
Log("WARNING: No writeable variables found.");
Log(WriteTest.g_WriteableVariableHelpText);
return true;
}
m_variables.Clear();
m_variables.AddRange(variables);
ReadEURanges(m_variables);
InitialWrite();
// check if there is anything to work with.
if (m_variables.Count == 0)
{
Log("WARNING: No writeable variables found.");
Log(WriteTest.g_WriteableVariableHelpText);
return true;
}
Log("Starting DeadbandTest for {0} Variables ({1}% Coverage, Start={2})", m_variables.Count, Configuration.Coverage, m_variables[0].Variable);
m_stopped = 0;
m_writeInterval = 1000;
m_deadbandCounter = 0;
m_useDeadbandValues = true;
m_errorEvent.Reset();
}
Subscription subscription = new Subscription();
subscription.PublishingInterval = 1000;
subscription.PublishingEnabled = true;
subscription.Priority = 0;
subscription.KeepAliveCount = 100;
subscription.LifetimeCount = 100;
subscription.MaxNotificationsPerPublish = 100;
Session.AddSubscription(subscription);
subscription.Create();
m_publishingTime = subscription.CurrentPublishingInterval;
m_writerTimer = new Timer(DoWrite, m_writeTimerCounter, 0, m_writeInterval);
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
DataChangeFilter[] filters = new DataChangeFilter[5];
if (success)
{
DataChangeFilter filter = new DataChangeFilter();
filter.DeadbandType = (uint)DeadbandType.Absolute;
filter.DeadbandValue = 2;
filter.Trigger = DataChangeTrigger.StatusValue;
filters[0] = filter;
filter = new DataChangeFilter();
filter.DeadbandType = (uint)DeadbandType.Absolute;
filter.DeadbandValue = 5;
filter.Trigger = DataChangeTrigger.StatusValue;
filters[1] = filter;
filter = new DataChangeFilter();
filter.DeadbandType = (uint)DeadbandType.Absolute;
filter.DeadbandValue = 10;
filter.Trigger = DataChangeTrigger.StatusValue;
filters[2] = filter;
filter = new DataChangeFilter();
filter.DeadbandType = (uint)DeadbandType.Percent;
filter.DeadbandValue = 1;
filter.Trigger = DataChangeTrigger.StatusValue;
filters[3] = filter;
filter = new DataChangeFilter();
filter.DeadbandType = (uint)DeadbandType.Percent;
filter.DeadbandValue = 10;
filter.Trigger = DataChangeTrigger.StatusValue;
filters[4] = filter;
lock (m_variables)
{
m_monitoredItems = new Dictionary<uint,TestVariable>();
for (int ii = 0; ii < m_variables.Count; ii++)
{
VariableNode variable = m_variables[ii].Variable;
for (int jj = 0; jj < filters.Length; jj++)
{
if (m_variables[ii].EURange == null && filters[jj].DeadbandType == (uint)DeadbandType.Percent)
{
continue;
}
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = variable.NodeId;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.RelativePath = null;
monitoredItem.IndexRange = null;
monitoredItem.SamplingInterval = 100;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
monitoredItem.Filter = filters[jj];
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.Handle = m_variables[ii];
m_variables[ii].Notifications[monitoredItem.ClientHandle] = new List<Notification>();
m_monitoredItems[monitoredItem.ClientHandle] = m_variables[ii];
subscription.AddItem(monitoredItem);
}
}
}
subscription.ApplyChanges();
// check results.
foreach (MonitoredItem monitoredItem in subscription.MonitoredItems)
{
if (!CheckDeadbandError(monitoredItem))
{
success = false;
break;
}
}
}
// modify sampling interval.
if (success)
{
if (modifyDeadband)
{
if (!ModifyDeadband(subscription))
{
success = false;
}
}
}
// wait for first data change.
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
lock (m_variables)
{
m_writeCount = 0;
m_startTime = DateTime.UtcNow;
}
if (success)
{
double increment = MaxProgress/10;
double position = 0;
for (int ii = 0; ii < 20; ii++)
{
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
break;
}
position += increment;
ReportProgress(position);
}
}
int writeCount = 0;
lock (m_variables)
{
m_stopped = 1;
m_endTime = DateTime.UtcNow;
writeCount = m_writeCount;
m_writerTimer.Dispose();
m_writerTimer = null;
}
Session.RemoveSubscription(subscription);
// wait for last data change.
if (m_errorEvent.WaitOne(1000, false))
{
success = false;
}
if (success)
{
double duration = CalculateInterval(m_startTime, m_endTime);
double expectedWrites = Math.Truncate(duration/m_writeInterval);
if (Math.Abs(expectedWrites - writeCount) > 1)
{
Log(
"WARNING: unexpected number of writes for monitored items: Expected={0}, Actual={1}",
expectedWrites,
writeCount);
}
lock (m_variables)
{
int errorCount = 0;
foreach (MonitoredItem monitoredItem in subscription.MonitoredItems)
{
if (ServiceResult.IsBad(monitoredItem.Status.Error))
{
continue;
}
DataChangeFilter filter = monitoredItem.Status.Filter as DataChangeFilter;
if (filter == null)
{
continue;
}
if (errorCount > 10)
{
break;
}
TestVariable variable = (TestVariable)monitoredItem.Handle;
double writesPerPublish = m_publishingTime/m_writeInterval;
double totalPublishes = duration/m_publishingTime;
Range euRange = variable.EURange;
if (euRange != null)
{
if (euRange.High - euRange.Low <= 0)
{
Log(
"Invalid EU range for variable {0}. NodeId={1}, EURange={2}, EURange={3}",
variable.Variable,
variable.Variable.NodeId,
variable.EURangeNode.NodeId,
euRange);
success = false;
errorCount++;
continue;
}
}
IList<Notification> notifications = variable.Notifications[monitoredItem.ClientHandle];
for (int ii = 0; ii < notifications.Count-1; ii++)
{
Notification before = notifications[ii];
Notification after = notifications[ii+1];
decimal difference = CalculateDifference(before.Value.Value, after.Value.Value);
if (filter.DeadbandType == (uint)DeadbandType.Absolute)
{
if (difference < (decimal)filter.DeadbandValue)
{
Log(
"Values did not exceed deadband {0}. NodeId={1}, DeadbandType={2}, Deadband={3}, Before={4}, After={5}",
variable.Variable,
variable.Variable.NodeId,
(DeadbandType)filter.DeadbandType,
filter.DeadbandValue,
before.Value.WrappedValue,
after.Value.WrappedValue);
success = false;
errorCount++;
continue;
}
}
if (filter.DeadbandType == (uint)DeadbandType.Percent)
{
double range = euRange.High - euRange.Low;
if (((double)difference)/range < filter.DeadbandValue/range)
{
Log(
"Values did not exceed deadband {0}. NodeId={1}, DeadbandType={2}, Deadband={3}, Before={4}, After={5}, EURange={6}",
variable.Variable,
variable.Variable.NodeId,
(DeadbandType)filter.DeadbandType,
filter.DeadbandValue,
before.Value.WrappedValue,
after.Value.WrappedValue,
euRange);
success = false;
errorCount++;
continue;
}
}
}
}
}
}
lock (m_variables)
{
Log("Completed DeadbandTest for {0} Nodes", m_variables.Count);
}
return success;
}
public void Initialize(Session session, Subscription subscription)
{
m_Session = session;
m_Subscription = subscription;
listView1.Items.Clear();
// Now monitor the server object for AuditSession Events
NodeId serverNodeId = new NodeId(Objects.Server);
Node serverNode = m_Session.NodeCache.Find(serverNodeId) as Node;
MonitoredItem serverItem = new MonitoredItem(m_Subscription.DefaultItem);
serverItem.StartNodeId = serverNode.NodeId;
serverItem.NodeClass = NodeClass.Object;
m_Subscription.AddItem(serverItem);
serverItem.Notification += m_ItemNotification;
AddSessions();
m_Subscription.ModifyItems();
m_Subscription.ApplyChanges();
}
public virtual bool MonitorTag(Subscription subscription, out string error, bool bApplySubscription = true, bool bReadInitialValue = true)
{
error = null;
if (subscription == null || subscription.Session == null)
{
error = "Error: No OPC session.";
return(false);
}
lock (subscription.MonitoredItems)
{
if (MyMonitoredItem != null && !subscription.MonitoredItems.Contains(MyMonitoredItem))
{
// Monitored item was removed: recreate from scratch. Otherwise modify in place
MyMonitoredItem = null;
}
if (!this.IsSubscribedAsThing && !this.IsSubscribedAsProperty)
{
// Nothing to be monitored
error = "Error: Nothing to be monitored";
return(false);
}
if (TheThing.GetSafePropertyBool(MyBaseThing, "DontMonitor") || SampleRate < -1)
{
return(false);
}
// can only subscribe to local variables.
//if (TagRef == null || TagRef.NodeId.IsAbsolute || TagRef.NodeClass != NodeClass.Variable)
var resolvedNodeId = GetResolvedNodeIdName();
if (resolvedNodeId == null) // || NodeId.IsAbsolute || TagRef.NodeClass != NodeClass.Variable)
{
error = "Error: No or invalid NodeId";
return(false);
}
var previousMonitoredItem = subscription.MonitoredItems.FirstOrDefault(mi => mi.Handle == this || this.RefersToSamePropertyAndTag(mi.Handle));
if (previousMonitoredItem != null)
{
if (!previousMonitoredItem.StartNodeId.Equals(resolvedNodeId))
{
TheBaseAssets.MySYSLOG.WriteToLog(78201, TSM.L(eDEBUG_LEVELS.OFF) ? null : new TSM("OPC", $"[{MyOPCServer.GetLogAddress()}] Internal Error - monitored item {previousMonitoredItem.StartNodeId} replaced with {resolvedNodeId}. Change will not take effect!", eMsgLevel.l4_Message));
}
MyMonitoredItem = previousMonitoredItem;
}
else
{
MyMonitoredItem = new MonitoredItem(subscription.DefaultItem);
}
//MyMonitoredItem.StartNodeId = (NodeId)TagRef.NodeId;
MyMonitoredItem.StartNodeId = resolvedNodeId;
MyMonitoredItem.AttributeId = Attributes.Value;
MyMonitoredItem.DisplayName = DisplayName; // Utils.Format("{0}", TagRef);
MyMonitoredItem.MonitoringMode = MonitoringMode.Reporting;
if ((!this.HistoryStartTime.HasValue || this.HistoryStartTime.Value == DateTimeOffset.MinValue) && MyOPCServer.DefHistoryStartTime != DateTimeOffset.MinValue)
{
this.HistoryStartTime = MyOPCServer.DefHistoryStartTime;
}
if (this.HistoryStartTime.HasValue && this.HistoryStartTime.Value != DateTimeOffset.MinValue)
{
MyMonitoredItem.Filter = new AggregateFilter()
{
StartTime = this.HistoryStartTime.Value.UtcDateTime,
ProcessingInterval = this.SampleRate,
AggregateType = ObjectIds.AggregateFunction_Interpolative,
};
MyMonitoredItem.QueueSize = uint.MaxValue;
MyMonitoredItem.SamplingInterval = 0;
}
else
{
DataChangeFilter filter = null;
// TODO Remove this special case: pass parameters for deadband filters and StatusValueTimestamp (this breaks P08!!!)
if (this.DeadbandFilterValue != 0)
{
filter = new DataChangeFilter
{
DeadbandType = (uint)(this.DeadbandFilterValue > 0 ? DeadbandType.Absolute : DeadbandType.Percent),
DeadbandValue = Math.Abs(this.DeadbandFilterValue)
};
}
if (ChangeTrigger != 1)
{
if (filter == null)
{
filter = new DataChangeFilter();
}
filter.Trigger = (DataChangeTrigger)ChangeTrigger;
}
if (filter != null)
{
MyMonitoredItem.Filter = filter;
}
MyMonitoredItem.SamplingInterval = SampleRate;
// For Events, the sample rate should be 0 (per spec), but is really ignored and thus should not affect the aggregate sample rate for the server
// All other sample rates are at least 50ms per other checks
if (SampleRate <= subscription.PublishingInterval * 2 && SampleRate > 0)
{
// 3.220: PublishingInterval is now independent of the sample rate: it only affects the frequency of the traffic from the server, not the content
//MyOPCServer.Subscription.PublishingInterval = SampleRate;
// Request the QueueSize to be 50 times the expected data points, so that no data is lost in normal operation
MyMonitoredItem.QueueSize = (uint)Math.Ceiling((((double)subscription.PublishingInterval) / SampleRate) * 50);
if (MyMonitoredItem.QueueSize < 50)
{
MyMonitoredItem.QueueSize = 50;
}
}
else
{
MyMonitoredItem.QueueSize = 50; // Request at least 50
}
}
MyMonitoredItem.DiscardOldest = true;
MyMonitoredItem.Notification -= MonitoredItem_Notification;
MyMonitoredItem.Notification += MonitoredItem_Notification;
TheOPCMonitoredItemBase previousTag = null;
if (previousMonitoredItem != null && previousMonitoredItem.Handle != this)
{
previousTag = previousMonitoredItem.Handle as TheOPCMonitoredItemBase;
if (previousTag != null)
{
previousTag.ReleaseMonitoredItem();
}
}
MyMonitoredItem.Handle = this;
InitializeMonitoredItem(previousTag);
if (previousMonitoredItem == null)
{
subscription.AddItem(MyMonitoredItem);
}
}
if (bApplySubscription)
{
#if OLD_UA
var items = subscription.ApplyChanges();
if (!items.Contains(MyMonitoredItem))
#else
subscription.ApplyChanges();
if (!subscription.MonitoredItems.Contains(MyMonitoredItem))
#endif
{
TheBaseAssets.MySYSLOG.WriteToLog(78201, TSM.L(eDEBUG_LEVELS.ESSENTIALS) ? null : new TSM("OPC", $"[{MyOPCServer.GetLogAddress()}] Internal Error: Monitored item not found after applying changes {GetNodeIdForLogs()}. Actual values: Sampling {MyMonitoredItem.Status.SamplingInterval}, Queue {MyMonitoredItem.Status.QueueSize}", eMsgLevel.l1_Error));
error = "Error: Monitored item not found after applying changes";
return(false);
}
else
{
TheBaseAssets.MySYSLOG.WriteToLog(78201, TSM.L(eDEBUG_LEVELS.VERBOSE) ? null : new TSM("OPC", $"[{MyOPCServer.GetLogAddress()}] Added monitored item {GetNodeIdForLogs()}. Actual values: Sampling {MyMonitoredItem.Status.SamplingInterval}, Queue {MyMonitoredItem.Status.QueueSize}", eMsgLevel.l4_Message));
}
}
if (ServiceResult.IsBad(MyMonitoredItem.Status.Error))
{
TheThing.SetSafePropertyString(MyBaseThing, "LastMessage", MyMonitoredItem.Status.Error.StatusCode.ToString());
TheBaseAssets.MySYSLOG.WriteToLog(78201, TSM.L(eDEBUG_LEVELS.FULLVERBOSE) ? null : new TSM("OPC", $"[{MyOPCServer.GetLogAddress()}] Error adding monitored item {GetNodeIdForLogs()}", eMsgLevel.l4_Message, MyMonitoredItem.Status.Error.ToString()));
error = "Error: " + MyMonitoredItem.Status.Error.ToString();
return(false);
}
else
{
MyOPCServer.RegisterEvent("DisconnectComplete", sinkDisconnected);
}
TheThing.SetSafePropertyBool(MyBaseThing, "IsActive", true);
return(true);
}
