/// <summary> /// Creates the monitored item based on the current definition. /// </summary> /// <param name="session">The session.</param> /// <returns>The monitored item.</returns> public MonitoredItem CreateMonitoredItem(Session session) { // choose the server object by default. if (AreaId == null) { AreaId = ObjectIds.Server; } // create the item with the filter. MonitoredItem monitoredItem = new MonitoredItem(); monitoredItem.DisplayName = null; monitoredItem.StartNodeId = AreaId; monitoredItem.RelativePath = null; monitoredItem.NodeClass = NodeClass.Object; monitoredItem.AttributeId = Attributes.EventNotifier; monitoredItem.IndexRange = null; monitoredItem.Encoding = null; monitoredItem.MonitoringMode = MonitoringMode.Reporting; monitoredItem.SamplingInterval = 0; monitoredItem.QueueSize = UInt32.MaxValue; monitoredItem.DiscardOldest = true; monitoredItem.Filter = ConstructFilter(session); // save the definition as the handle. monitoredItem.Handle = this; return monitoredItem; }
/// <summary> /// Prompts the user to specify the browse options. /// </summary> public bool ShowDialog(Session session, MonitoredItem monitoredItem) { if (monitoredItem == null) throw new ArgumentNullException("monitoredItem"); DataChangeFilter filter = monitoredItem.Filter as DataChangeFilter; if (filter == null) { filter = new DataChangeFilter(); filter.Trigger = DataChangeTrigger.StatusValue; filter.DeadbandValue = 0; filter.DeadbandType = (uint)(int)DeadbandType.None; } TriggerCB.SelectedItem = filter.Trigger; DeadbandTypeCB.SelectedItem = (DeadbandType)(int)filter.DeadbandType; DeadbandNC.Value = (decimal)filter.DeadbandValue; if (ShowDialog() != DialogResult.OK) { return false; } filter.Trigger = (DataChangeTrigger)TriggerCB.SelectedItem; filter.DeadbandType = Convert.ToUInt32(DeadbandTypeCB.SelectedItem); filter.DeadbandValue = (double)DeadbandNC.Value; monitoredItem.Filter = filter; return true; }
/// <summary> /// Displays the dialog. /// </summary> public void Show(MonitoredItem monitoredItem) { if (monitoredItem == null) throw new ArgumentNullException("monitoredItem"); Show(); BringToFront(); // remove previous subscription. if (m_monitoredItem != null) { monitoredItem.Subscription.StateChanged -= m_SubscriptionStateChanged; monitoredItem.Subscription.PublishStatusChanged -= m_PublishStatusChanged; monitoredItem.Notification -= m_MonitoredItemNotification; } // start receiving notifications from the new subscription. m_monitoredItem = monitoredItem; m_subscription = null; if (m_monitoredItem != null) { m_subscription = monitoredItem.Subscription; m_monitoredItem.Subscription.StateChanged += m_SubscriptionStateChanged; m_monitoredItem.Subscription.PublishStatusChanged += m_PublishStatusChanged; m_monitoredItem.Notification += m_MonitoredItemNotification; } WindowMI_Click(WindowStatusMI, null); WindowMI_Click(WindowLatestValueMI, null); MonitoredItemsCTRL.Initialize(m_monitoredItem); EventsCTRL.Initialize(m_subscription, m_monitoredItem); DataChangesCTRL.Initialize(m_subscription, m_monitoredItem); LatestValueCTRL.ShowValue(m_monitoredItem, false); }
/// <summary> /// Displays the dialog. /// </summary> public object ShowDialog(object value, MonitoredItem monitoredItem) { m_value = Utils.Clone(value); ValueCTRL.MonitoredItem = monitoredItem; ValueCTRL.ShowValue(m_value); if (ShowDialog() != DialogResult.OK) { return null; } return m_value; }
/// <summary> /// Initializes a new instance of the <see cref="MonitoredItem"/> class. /// </summary> /// <param name="template">The template used to specify the monitoring parameters.</param> /// <param name="copyEventHandlers">if set to <c>true</c> the event handlers are copied.</param> public MonitoredItem(MonitoredItem template, bool copyEventHandlers) { Initialize(); if (template != null) { string displayName = template.DisplayName; if (displayName != null) { // remove any existing numeric suffix. int index = displayName.LastIndexOf(' '); if (index != -1) { try { displayName = displayName.Substring(0, index); } catch { // not a numeric suffix. } } } m_handle = template.m_handle; m_displayName = Utils.Format("{0} {1}", displayName, m_clientHandle); m_startNodeId = template.m_startNodeId; m_relativePath = template.m_relativePath; m_attributeId = template.m_attributeId; m_indexRange = template.m_indexRange; m_encoding = template.m_encoding; m_monitoringMode = template.m_monitoringMode; m_samplingInterval = template.m_samplingInterval; m_filter = (MonitoringFilter)Utils.Clone(template.m_filter); m_queueSize = template.m_queueSize; m_discardOldest = template.m_discardOldest; m_attributesModified = true; if (copyEventHandlers) { m_Notification = template.m_Notification; } // this ensures the state is consistent with the node class. NodeClass = template.m_nodeClass; } }
private void connectVariable(Opc.Ua.Client.MonitoredItem item, Opc.Ua.Client.MonitoredItemNotificationEventArgs e) { BaseVariableState varNode; if (connectedVariables.TryGetValue(item, out varNode)) { MonitoredItemNotification datachange = e.NotificationValue as MonitoredItemNotification; if (datachange == null) { return; } varNode.Value = datachange.Value.WrappedValue; } else { throw new Exception("monitored item is not connected to a Node in Collector Nodes"); } }
/// <summary> /// Prompts the user to edit the monitored item. /// </summary> public bool ShowDialog(Session session, MonitoredItem monitoredItem, bool isEvent) { if (!monitoredItem.Created) { NodeBTN.Session = session; NodeBTN.SelectedNode = monitoredItem.StartNodeId; } // hide fields not used for events. NodeLB.Visible = !monitoredItem.Created; NodeTB.Visible = !monitoredItem.Created; NodeBTN.Visible = !monitoredItem.Created; AttributeLB.Visible = !isEvent && !monitoredItem.Created; AttributeCB.Visible = !isEvent && !monitoredItem.Created; IndexRangeLB.Visible = !isEvent && !monitoredItem.Created; IndexRangeTB.Visible = !isEvent && !monitoredItem.Created; DataEncodingLB.Visible = !isEvent && !monitoredItem.Created; DataEncodingCB.Visible = !isEvent && !monitoredItem.Created; MonitoringModeLB.Visible = !monitoredItem.Created; MonitoringModeCB.Visible = !monitoredItem.Created; SamplingIntervalLB.Visible = true; SamplingIntervalUP.Visible = true; QueueSizeLB.Visible = !isEvent; QueueSizeUP.Visible = !isEvent; DiscardOldestLB.Visible = true; DiscardOldestCK.Visible = true; DeadbandTypeLB.Visible = !isEvent; DeadbandTypeCB.Visible = !isEvent; DeadbandValueLB.Visible = !isEvent; DeadbandValueUP.Visible = !isEvent; TriggerTypeLB.Visible = !isEvent; TriggerTypeCB.Visible = !isEvent; // fill in values. SamplingIntervalUP.Value = monitoredItem.SamplingInterval; DiscardOldestCK.Checked = monitoredItem.DiscardOldest; if (!isEvent) { AttributeCB.SelectedIndex = (int)(monitoredItem.AttributeId - 1); IndexRangeTB.Text = monitoredItem.IndexRange; MonitoringModeCB.SelectedItem = monitoredItem.MonitoringMode; QueueSizeUP.Value = monitoredItem.QueueSize; DataChangeFilter filter = monitoredItem.Filter as DataChangeFilter; if (filter != null) { DeadbandTypeCB.SelectedItem = (DeadbandType)filter.DeadbandType; DeadbandValueUP.Value = (decimal)filter.DeadbandValue; TriggerTypeCB.SelectedItem = filter.Trigger; } if (!monitoredItem.Created) { // fetch the available encodings for the first node in the list from the server. IVariableBase variable = session.NodeCache.Find(monitoredItem.StartNodeId) as IVariableBase; DataEncodingCB.Items.Add(new EncodingInfo()); DataEncodingCB.SelectedIndex = 0; if (variable != null) { if (session.NodeCache.IsTypeOf(variable.DataType, Opc.Ua.DataTypeIds.Structure)) { foreach (INode encoding in session.NodeCache.Find(variable.DataType, Opc.Ua.ReferenceTypeIds.HasEncoding, false, true)) { DataEncodingCB.Items.Add(new EncodingInfo() { EncodingName = encoding.BrowseName }); if (monitoredItem.Encoding == encoding.BrowseName) { DataEncodingCB.SelectedIndex = DataEncodingCB.Items.Count - 1; } } } } } } else { AttributeCB.SelectedIndex = ((int)Attributes.EventNotifier - 1); } if (base.ShowDialog() != DialogResult.OK) { return false; } // update monitored item. if (!monitoredItem.Created) { monitoredItem.StartNodeId = NodeBTN.SelectedNode; monitoredItem.DisplayName = session.NodeCache.GetDisplayText(monitoredItem.StartNodeId); monitoredItem.RelativePath = null; monitoredItem.AttributeId = (uint)(AttributeCB.SelectedIndex + 1); monitoredItem.MonitoringMode = (MonitoringMode)MonitoringModeCB.SelectedItem; } monitoredItem.SamplingInterval = (int)SamplingIntervalUP.Value; monitoredItem.DiscardOldest = DiscardOldestCK.Checked; if (!isEvent) { if (!monitoredItem.Created) { monitoredItem.IndexRange = IndexRangeTB.Text.Trim(); monitoredItem.Encoding = ((EncodingInfo)DataEncodingCB.SelectedItem).EncodingName; } monitoredItem.QueueSize = (uint)QueueSizeUP.Value; DataChangeTrigger trigger = (DataChangeTrigger)TriggerTypeCB.SelectedItem; DeadbandType deadbandType = (DeadbandType)DeadbandTypeCB.SelectedItem; if (monitoredItem.Filter != null || deadbandType != DeadbandType.None || trigger != DataChangeTrigger.StatusValue) { DataChangeFilter filter = new DataChangeFilter(); filter.DeadbandType = (uint)deadbandType; filter.DeadbandValue = (double)DeadbandValueUP.Value; filter.Trigger = trigger; monitoredItem.Filter = filter; } } else { if (!monitoredItem.Created) { monitoredItem.IndexRange = null; monitoredItem.Encoding = null; } monitoredItem.QueueSize = 0; monitoredItem.Filter = new EventFilter(); } return true; }
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> /// 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> /// Prompts the user to specify the browse options. /// </summary> public bool ShowDialog(Session session, MonitoredItem monitoredItem) { return ShowDialog(session, monitoredItem, false); }
/// <summary> /// Shows all fields for the current condition. /// </summary> public bool ShowDialog(MonitoredItem monitoredItem, EventFieldList eventFields) { // build a sorted list of non-null fields. List<string> fieldNames = new List<string>(); List<Variant> fieldValues = new List<Variant>(); // use the filter from the monitored item to determine what is in each field. EventFilter filter = monitoredItem.Status.Filter as EventFilter; if (filter != null) { if (eventFields.EventFields[0].Value != null) { fieldNames.Add("ConditionId"); fieldValues.Add(eventFields.EventFields[0]); } for (int ii = 1; ii < filter.SelectClauses.Count; ii++) { object fieldValue = eventFields.EventFields[ii].Value; if (fieldValue == null) { continue; } StringBuilder displayName = new StringBuilder(); for (int jj = 0; jj < filter.SelectClauses[ii].BrowsePath.Count; jj++) { if (displayName.Length > 0) { displayName.Append('/'); } displayName.Append(filter.SelectClauses[ii].BrowsePath[jj].Name); } fieldNames.Add(displayName.ToString()); fieldValues.Add(eventFields.EventFields[ii]); } } // populate lists. for (int ii = 0; ii < fieldNames.Count; ii++) { ListViewItem item = new ListViewItem(fieldNames[ii]); item.SubItems.Add(Utils.Format("{0}", fieldValues[ii].Value)); item.SubItems.Add(Utils.Format("{0}", fieldValues[ii].Value.GetType().Name)); FieldsLV.Items.Add(item); } // adjust columns. for (int ii = 0; ii < FieldsLV.Columns.Count; ii++) { FieldsLV.Columns[ii].Width = -2; } // display the dialog. if (ShowDialog() != DialogResult.OK) { return false; } return true; }
/// <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> /// Initializes a new instance of the <see cref="MonitoredItem"/> class. /// </summary> /// <param name="template">The template used to specify the monitoring parameters.</param> public MonitoredItem(MonitoredItem template) : this(template, false) { }
/// <summary> /// Displays the items for the specified subscription in the control. /// </summary> public void Initialize(MonitoredItem monitoredItem) { // do nothing if same subscription provided. if (Object.ReferenceEquals(m_monitoredItem, monitoredItem)) { return; } m_monitoredItem = monitoredItem; m_subscription = null; Clear(); if (m_monitoredItem != null) { m_subscription = monitoredItem.Subscription; UpdateItems(); } }
void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (InvokeRequired) { BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { MonitoredItemNotification datachange = e.NotificationValue as MonitoredItemNotification; if (datachange == null) { return; } CurrentStateTB.Text = datachange.Value.WrappedValue.ToString(); } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
/// <summary> /// Updates the application after reconnecting to the server. /// </summary> private void Server_ReconnectComplete(object sender, EventArgs e) { try { m_session = ConnectServerCTRL.Session; foreach (Subscription subscription in m_session.Subscriptions) { m_subscription = subscription; break; } foreach (MonitoredItem monitoredItem in m_subscription.MonitoredItems) { m_monitoredItem = monitoredItem; break; } } 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> /// Sets the nodes in the control. /// </summary> public void Initialize(Subscription subscription, MonitoredItem monitoredItem) { if (subscription == null) throw new ArgumentNullException("subscription"); Clear(); // start receiving notifications from the new subscription. m_subscription = subscription; m_monitoredItem = monitoredItem; // get the events. List<EventFieldList> events = new List<EventFieldList>(); foreach (NotificationMessage message in m_subscription.Notifications) { foreach (EventFieldList eventFields in message.GetEvents(true)) { if (m_monitoredItem != null) { if (m_monitoredItem.ClientHandle != eventFields.ClientHandle) { continue; } } else { if (m_subscription.FindItemByClientHandle(eventFields.ClientHandle) == null) { continue; } } events.Add(eventFields); if (events.Count >= MaxEventCount) { break; } } if (events.Count >= MaxEventCount) { break; } } UpdateEvents(events, 0); AdjustColumns(); }
/// <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; }
private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { try { if (e.NotificationValue == null || monitoredItem.Subscription.Session == null) { return; } JsonEncoder encoder = new JsonEncoder( monitoredItem.Subscription.Session.MessageContext, false); encoder.WriteNodeId("MonitoredItem", monitoredItem.ResolvedNodeId); e.NotificationValue.Encode(encoder); var json = encoder.Close(); var bytes = new UTF8Encoding(false).GetBytes(json); foreach (var publisher in m_publishers) { try { publisher.Publish(new ArraySegment<byte>(bytes)); } catch(Exception ex) { Utils.Trace(ex, "Failed to publish message, dropping...."); } } } catch (Exception exception) { Utils.Trace(exception, "Error processing monitored item notification."); } }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void subscriptionDiagnosticsToolStripMenuItem_Click(object sender, EventArgs e) { try { if (listView1.SelectedItems.Count > 0) { ListViewItem lvi = listView1.SelectedItems[0]; Browser browser = new Browser(m_Session); browser.MaxReferencesReturned = 0; browser.BrowseDirection = BrowseDirection.Forward; browser.IncludeSubtypes = true; browser.NodeClassMask = (int)NodeClass.Variable; browser.ContinueUntilDone = true; browser.ReferenceTypeId = null; NodeId sessionNodeId = new NodeId(lvi.Tag.ToString()); ReferenceDescriptionCollection refs = browser.Browse(sessionNodeId); foreach (ReferenceDescription rf in refs) { if (m_Session.TypeTree.IsTypeOf(new ExpandedNodeId(rf.TypeDefinition), new ExpandedNodeId(VariableTypes.SubscriptionDiagnosticsArrayType))) { MonitoredItem mi = new MonitoredItem(m_Subscription.DefaultItem); NodeId id = new NodeId(rf.NodeId.ToString()); INode node = m_Session.NodeCache.Find(id); mi.StartNodeId = id; mi.NodeClass = node.NodeClass; mi.AttributeId = Attributes.Value; mi.DisplayName = m_Session.NodeCache.GetDisplayText(node); mi.MonitoringMode = MonitoringMode.Reporting; m_Subscription.PublishingEnabled = true; m_Subscription.AddItem(mi); m_Subscription.ModifyItems(); m_Subscription.ApplyChanges(); MonitoredItemDlg dlg = new MonitoredItemDlg(); m_Forms.Add(dlg); dlg.Show(mi); break; } } } } catch (Exception exception) { GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); } }
/// <summary> /// Displays the items for the specified subscription in the control. /// </summary> public void Initialize(Subscription subscription) { // do nothing if same subscription provided. if (Object.ReferenceEquals(m_subscription, subscription)) { return; } m_monitoredItem = null; m_subscription = subscription; Clear(); if (m_subscription != null) { UpdateItems(); } }
public DateTimeMonitoredItem(MonitoredItem template) : base(template) { }
/// <summary> /// Creates a new monitored item and adds it to the subscription. /// </summary> private MonitoredItem CreateMonitoredItem(NodeId notifierId) { MonitoredItem monitoredItem = new MonitoredItem(); monitoredItem.DisplayName = null; monitoredItem.StartNodeId = notifierId; monitoredItem.RelativePath = null; monitoredItem.NodeClass = NodeClass.Object; monitoredItem.AttributeId = Attributes.EventNotifier; monitoredItem.IndexRange = null; monitoredItem.Encoding = null; monitoredItem.MonitoringMode = MonitoringMode.Reporting; monitoredItem.SamplingInterval = 0; monitoredItem.QueueSize = UInt32.MaxValue; monitoredItem.DiscardOldest = true; return monitoredItem; }
/// <summary> /// Initializes a new instance of the <see cref="MonitoredItem"/> class. /// </summary> /// <param name="template">The template used to specify the monitoring parameters.</param> /// <param name="copyEventHandlers">if set to <c>true</c> the event handlers are copied.</param> public MonitoredItem(MonitoredItem template, bool copyEventHandlers) : this(template, copyEventHandlers, false) { }
private void NewMI_Click(object sender, EventArgs e) { try { if (m_state != DisplayState.EditItems) { return; } MonitoredItem monitoredItem = null; foreach (DataGridViewRow row in ItemsDV.SelectedRows) { DataRowView source = row.DataBoundItem as DataRowView; monitoredItem = (MonitoredItem)source.Row[0]; break; } if (monitoredItem == null) { monitoredItem = new MonitoredItem(m_subscription.DefaultItem); } else { monitoredItem = new MonitoredItem(monitoredItem); } if (new EditMonitoredItemDlg().ShowDialog(m_session, monitoredItem, true)) { m_subscription.AddItem(monitoredItem); DataRow row = m_dataset.Tables[0].NewRow(); monitoredItem.Handle = row; UpdateRow(row, monitoredItem); m_dataset.Tables[0].Rows.Add(row); } } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
/// <summary> /// Processes a Publish response from the server. /// </summary> /// void ItemNotification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (InvokeRequired) { BeginInvoke(new MonitoredItemNotificationEventHandler(ItemNotification), monitoredItem, e); return; } else if (!IsHandleCreated) { return; } try { if (monitoredItem != null) { string Key = monitoredItem.StartNodeId.Identifier.ToString() + "." + monitoredItem.RelativePath; ListViewItem[] lvis = listView1.Items.Find(Key, true); Opc.Ua.MonitoredItemNotification change = e.NotificationValue as Opc.Ua.MonitoredItemNotification; if(change != null) { DataValue dv = change.Value; if (lvis.Length == 1) { ListViewItem lvi = lvis[0]; int subindex = lvi.SubItems.IndexOfKey(Key); ListViewItem.ListViewSubItem si = lvi.SubItems[subindex]; TypedMonitoredItem mi = si.Tag as TypedMonitoredItem; if (mi != null) { if (mi.ClientHandle == monitoredItem.ClientHandle) { if (dv != null && dv.Value != null) { if (monitoredItem.Status.Id == StatusCodes.BadNodeIdUnknown) { // Randy said we would get this, but we don't RemoveSessionItem(lvi, true); } else { si.Text = mi.ToString(dv); } } else { // This is what we get RemoveSessionItem(lvi, true); } } else { Utils.Trace("(mi.ClientHandle != monitoredItem.ClientHandle " + MethodBase.GetCurrentMethod()); } } else { Utils.Trace("mi is null " + MethodBase.GetCurrentMethod()); } } else { Utils.Trace("lvis.Length != 1 " + MethodBase.GetCurrentMethod()); } } else { EventFieldList eventFields = e.NotificationValue as EventFieldList; if (eventFields != null) { // get the event fields. NodeId eventType = monitoredItem.GetFieldValue(eventFields, ObjectTypes.BaseEventType, BrowseNames.EventType) as NodeId; string sourceName = monitoredItem.GetFieldValue(eventFields, ObjectTypes.BaseEventType, BrowseNames.SourceName) as string; DateTime? time = monitoredItem.GetFieldValue(eventFields, ObjectTypes.BaseEventType, BrowseNames.Time) as DateTime?; ushort? severity = monitoredItem.GetFieldValue(eventFields, ObjectTypes.BaseEventType, BrowseNames.Severity) as ushort?; LocalizedText message = monitoredItem.GetFieldValue(eventFields, ObjectTypes.BaseEventType, BrowseNames.Message) as LocalizedText; NodeId sourceNode = monitoredItem.GetFieldValue(eventFields, ObjectTypes.BaseEventType, BrowseNames.SourceNode) as NodeId; //Utils.Trace("eventType: {0}, message: {1}, sourceName: {2} sourceNode: {3}", eventType.ToString(), message.Text.ToString(), sourceName.ToString(), sourceNode.ToString()); if (eventType == new NodeId(ObjectTypes.AuditActivateSessionEventType)) { Utils.Trace("AuditActivateSessionEventType detected " + MethodBase.GetCurrentMethod()); AddSessions(); m_Subscription.ModifyItems(); m_Subscription.ApplyChanges(); } } else { Utils.Trace("eventFields is null " + MethodBase.GetCurrentMethod()); } } } else { Utils.Trace("monitoredItem is null " + MethodBase.GetCurrentMethod()); } } catch (Exception exception) { GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); } }
/// <summary> /// Prompts the user to specify the browse options. /// </summary> public bool ShowDialog(Session session, MonitoredItem monitoredItem, bool editMonitoredItem) { if (monitoredItem == null) throw new ArgumentNullException("monitoredItem"); m_session = session; NodeIdCTRL.Browser = new Browser(session); if (editMonitoredItem) { // Disable the not changeable values NodeIdCTRL.Enabled = false; RelativePathTB.Enabled = false; NodeClassCB.Enabled = false; AttributeIdCB.Enabled = false; IndexRangeTB.Enabled = false; EncodingCB.Enabled = false; MonitoringModeCB.Enabled = false; DisplayNameTB.Text = monitoredItem.DisplayName; } else { uint monitoredItemsCount = 0; if (session != null && session.SubscriptionCount >= 1) { foreach (Subscription subscription in session.Subscriptions) { monitoredItemsCount += subscription.MonitoredItemCount; } } DisplayNameTB.Text = String.Format("MonitoredItem {0}", monitoredItemsCount + 1); } NodeIdCTRL.Identifier = monitoredItem.StartNodeId; RelativePathTB.Text = monitoredItem.RelativePath; NodeClassCB.SelectedItem = monitoredItem.NodeClass; AttributeIdCB.SelectedItem = Attributes.GetBrowseName(monitoredItem.AttributeId); IndexRangeTB.Text = monitoredItem.IndexRange; EncodingCB.Text = (monitoredItem.Encoding != null) ? monitoredItem.Encoding.Name : null; MonitoringModeCB.SelectedItem = monitoredItem.MonitoringMode; SamplingIntervalNC.Value = 1000; DisableOldestCK.Checked = monitoredItem.DiscardOldest; if (monitoredItem.SamplingInterval >= 0) { SamplingIntervalNC.Value = (decimal)monitoredItem.SamplingInterval; } QueueSizeNC.Value = monitoredItem.QueueSize; if (ShowDialog() != DialogResult.OK) { return false; } monitoredItem.DisplayName = DisplayNameTB.Text; monitoredItem.NodeClass = (NodeClass)NodeClassCB.SelectedItem; monitoredItem.StartNodeId = NodeIdCTRL.Identifier; monitoredItem.RelativePath = RelativePathTB.Text; monitoredItem.AttributeId = Attributes.GetIdentifier((string)AttributeIdCB.SelectedItem); monitoredItem.IndexRange = IndexRangeTB.Text; monitoredItem.MonitoringMode = (MonitoringMode)MonitoringModeCB.SelectedItem; monitoredItem.SamplingInterval = (int)SamplingIntervalNC.Value; monitoredItem.QueueSize = (uint)QueueSizeNC.Value; monitoredItem.DiscardOldest = DisableOldestCK.Checked; if (!String.IsNullOrEmpty(EncodingCB.Text)) { monitoredItem.Encoding = new QualifiedName(EncodingCB.Text); } return true; }
public TypedMonitoredItem(MonitoredItem template) : base(template) { }
/// <summary> /// Adds items to the subscription. /// </summary> public void AddItems(params NodeId[] itemsToMonitor) { if (itemsToMonitor != null) { SetDisplayState(DisplayState.EditItems); for (int ii = 0; ii < itemsToMonitor.Length; ii++) { if (itemsToMonitor[ii] == null) { continue; } DataRow row = m_dataset.Tables[0].NewRow(); MonitoredItem monitoredItem = new MonitoredItem(m_subscription.DefaultItem); monitoredItem.StartNodeId = itemsToMonitor[ii]; monitoredItem.AttributeId = Attributes.EventNotifier; monitoredItem.NodeClass = NodeClass.Object; monitoredItem.IndexRange = null; monitoredItem.Encoding = null; monitoredItem.Handle = row; m_subscription.AddItem(monitoredItem); UpdateRow(row, monitoredItem); m_dataset.Tables[0].Rows.Add(row); } } }
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(); }
/// <summary> /// Updates the row with the monitored item. /// </summary> private void UpdateRow(DataRow row, MonitoredItem monitoredItem) { row[0] = monitoredItem; row[1] = ImageList.Images[ClientUtils.GetImageIndex(monitoredItem.AttributeId, null)]; row[2] = m_session.NodeCache.GetDisplayText(monitoredItem.StartNodeId) + "/" + Attributes.GetBrowseName(monitoredItem.AttributeId); row[3] = monitoredItem.MonitoringMode; row[4] = monitoredItem.SamplingInterval; row[5] = monitoredItem.DiscardOldest; }