private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { try { MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification; if (notification == null) { return; } DataValue value = notification.Value as DataValue; if (value == null) { return; } using (var encoder = new JsonEncoder(monitoredItem.Subscription.Session.MessageContext, false)) { string applicationURI = monitoredItem.Subscription.Session.Endpoint.Server.ApplicationUri; encoder.WriteString("ApplicationUri", applicationURI); encoder.WriteString("DisplayName", monitoredItem.DisplayName); encoder.WriteNodeId("MonitoredItem", monitoredItem.ResolvedNodeId); // suppress output of server timestamp in json by setting it to minvalue value.ServerTimestamp = DateTime.MinValue; encoder.WriteDataValue("Value", value); string json = encoder.CloseAndReturnText(); var properties = new Dictionary <string, string>(); properties.Add("content-type", "application/opcua+uajson"); properties.Add("deviceName", Id); if (SharedAccessKey != null) { properties.Add("source", "mapping"); properties.Add("deviceKey", SharedAccessKey); } try { Module.Publish(new Message(json, properties)); } catch (Exception ex) { Console.WriteLine("Opc.Ua.Client.SampleModule: Failed to publish message, dropping..."); Console.WriteLine(ex.ToString()); } } } catch (Exception exception) { Console.WriteLine("Opc.Ua.Client.SampleModule: Error processing monitored item notification."); Console.WriteLine(exception.ToString()); } }
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> /// Updates the display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { if (m_session == null) { return; } MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification; if (notification == null) { return; } ListViewItem.ListViewSubItem item = (ListViewItem.ListViewSubItem)monitoredItem.Handle; item.Text = Utils.Format("{0}", notification.Value.WrappedValue); } catch (Exception exception) { MessageBox.Show(exception.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
/// <summary> /// Updates the display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { EventFieldList notification = e.NotificationValue as EventFieldList; if (notification == null) { return; } // check the type of event. NodeId eventTypeId = FormUtils.FindEventType(monitoredItem, notification); // ignore unknown events. if (NodeId.IsNull(eventTypeId)) { return; } // construct the audit object. AuditUpdateMethodEventState audit = FormUtils.ConstructEvent( m_session, monitoredItem, notification, m_eventTypeMappings) as AuditUpdateMethodEventState; if (audit == null) { return; } ListViewItem item = new ListViewItem(String.Empty); item.SubItems.Add(String.Empty); // Source item.SubItems.Add(String.Empty); // Type item.SubItems.Add(String.Empty); // Method item.SubItems.Add(String.Empty); // Status item.SubItems.Add(String.Empty); // Time item.SubItems.Add(String.Empty); // Message item.SubItems.Add(String.Empty); // Arguments // look up the condition type metadata in the local cache. INode type = m_session.NodeCache.Find(audit.TypeDefinitionId); // Source if (audit.SourceName != null) { item.SubItems[0].Text = Utils.Format("{0}", audit.SourceName.Value); } else { item.SubItems[0].Text = null; } // Type if (type != null) { item.SubItems[1].Text = Utils.Format("{0}", type); } else { item.SubItems[1].Text = null; } // look up the method metadata in the local cache. INode method = m_session.NodeCache.Find(BaseVariableState.GetValue(audit.MethodId)); // Method if (method != null) { item.SubItems[2].Text = Utils.Format("{0}", method); } else { item.SubItems[2].Text = null; } // Status if (audit.Status != null) { item.SubItems[3].Text = Utils.Format("{0}", audit.Status.Value); } else { item.SubItems[3].Text = null; } // Time if (audit.Time != null) { item.SubItems[4].Text = Utils.Format("{0:HH:mm:ss.fff}", audit.Time.Value.ToLocalTime()); } else { item.SubItems[4].Text = null; } // Message if (audit.Message != null) { item.SubItems[5].Text = Utils.Format("{0}", audit.Message.Value); } else { item.SubItems[5].Text = null; } // Arguments if (audit.InputArguments != null) { item.SubItems[6].Text = Utils.Format("{0}", new Variant(audit.InputArguments.Value)); } else { item.SubItems[6].Text = null; } item.Tag = audit; EventsLV.Items.Add(item); // adjust the width of the columns. for (int ii = 0; ii < EventsLV.Columns.Count; ii++) { EventsLV.Columns[ii].Width = -2; } } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
/// <summary> /// Processes a new notification. /// </summary> public void NotificationReceived(MonitoredItemNotificationEventArgs e) { MonitoredItemNotification change = e.NotificationValue as MonitoredItemNotification; if (change == null) { return; } if (m_monitoredItem != null) { if (m_monitoredItem.ClientHandle != change.ClientHandle) { return; } } // add new change. List<MonitoredItemNotification> changes = new List<MonitoredItemNotification>(); changes.Add(change); // fill in earlier changes. if (m_showHistory) { foreach (ListViewItem listItem in ItemsLV.Items) { change = listItem.Tag as MonitoredItemNotification; if (change == null) { continue; } if (m_monitoredItem != null) { if (m_monitoredItem.ClientHandle != change.ClientHandle) { continue; } } changes.Add(change); if (changes.Count >= MaxChangeCount) { break; } } } UpdateChanges(changes, 1); AdjustColumns(); }
/// <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; } ItemNotificationHandler(monitoredItem, e); }
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> /// Processes a new notification. /// </summary> public void NotificationReceived(MonitoredItemNotificationEventArgs e) { EventFieldList eventFields = e.NotificationValue as EventFieldList; if (eventFields == null) { return; } if (m_monitoredItem != null) { if (m_monitoredItem.ClientHandle != eventFields.ClientHandle) { return; } } // get the events. List<EventFieldList> events = new List<EventFieldList>(); events.Add(eventFields); // fill in earlier events. foreach (ListViewItem listItem in ItemsLV.Items) { eventFields = listItem.Tag as EventFieldList; if (m_monitoredItem != null) { if (m_monitoredItem.ClientHandle != eventFields.ClientHandle) { continue; } } if (eventFields != null) { events.Add(eventFields); } if (events.Count >= MaxEventCount) { break; } } UpdateEvents(events, 1); AdjustColumns(); }
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) { MessageBox.Show(exception.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
/// <summary> /// Processes a Publish response from the server. /// </summary> void ItemNotification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { //Utils.Trace("Enter: {0}", MethodBase.GetCurrentMethod()); if (InvokeRequired) { BeginInvoke(new MonitoredItemNotificationEventHandler(ItemNotification), monitoredItem, e); //Utils.Trace("Leave: InvokeRequired {0}", MethodBase.GetCurrentMethod()); return; } else if (!IsHandleCreated) { //Utils.Trace("Leave: !IsHandleCreated {0}", MethodBase.GetCurrentMethod()); return; } try { if (monitoredItem != null) { ListViewItem[] lvis = ServerListView.Items.Find(monitoredItem.Subscription.Session.SessionId.ToString(), false); if (lvis.Length == 1) { int IndexOfKey = lvis[0].SubItems.IndexOfKey(monitoredItem.StartNodeId.Identifier.ToString()); if (IndexOfKey > -1) { //Utils.Trace("ItemNotification NodeId.Identifier: {0}", monitoredItem.NodeId.Identifier.ToString()); MonitoredItemNotification change = e.NotificationValue as MonitoredItemNotification; if (monitoredItem.StartNodeId == Variables.Server_ServerStatus_State) { lvis[0].SubItems[IndexOfKey].Text = ((ServerState)(int)change.Value.Value).ToString(); } else if (monitoredItem.StartNodeId == Variables.Server_ServerStatus_CurrentTime || monitoredItem.StartNodeId == Variables.Server_ServerStatus_StartTime) { DateTime dateTime = DateTime.Parse(change.Value.Value.ToString()); lvis[0].SubItems[IndexOfKey].Text = dateTime.ToLocalTime().ToString(); } else { lvis[0].SubItems[IndexOfKey].Text = change.Value.Value.ToString(); } } } } } catch (Exception exception) { GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); } }
private async void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (e.NotificationValue == null) { return; } await Dispatcher.RunAsync(CoreDispatcherPriority.Normal,() => { try { XmlEncoder encoder = new XmlEncoder(monitoredItem.Subscription.Session.MessageContext); e.NotificationValue.Encode(encoder); ServerStatusTB.Text = encoder.Close(); } catch (Exception ex) { Utils.Trace(ex, "Error processing monitored item notification."); } }); }
/// <summary> /// Updates the display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { // check for valid notification. EventFieldList notification = e.NotificationValue as EventFieldList; if (notification == null) { return; } // check if monitored item has changed. if (!Object.ReferenceEquals(m_monitoredItem, monitoredItem)) { return; } // check if the filter has changed. if (notification.EventFields.Count != m_filter.Fields.Count+1) { return; } if (m_displayConditions) { NodeId eventTypeId = m_filter.GetValue<NodeId>(Opc.Ua.BrowseNames.EventType, notification.EventFields, null); if (eventTypeId == Opc.Ua.ObjectTypeIds.RefreshStartEventType) { EventsLV.Items.Clear(); } if (eventTypeId == Opc.Ua.ObjectTypeIds.RefreshEndEventType) { return; } } // create an item and add to top of list. ListViewItem item = CreateListItem(m_filter, notification.EventFields); if (item.ListView == null) { EventsLV.Items.Insert(0, item); } // adjust the width of the columns. for (int ii = 0; ii < EventsLV.Columns.Count; ii++) { EventsLV.Columns[ii].Width = -2; } } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
/// <summary> /// Updates the display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { if (m_session == null) { return; } MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification; if (notification == null) { return; } ListViewItem item = (ListViewItem)monitoredItem.Handle; item.SubItems[5].Text = Utils.Format("{0}", notification.Value.WrappedValue); item.SubItems[6].Text = Utils.Format("{0}", notification.Value.StatusCode); item.SubItems[7].Text = Utils.Format("{0:HH:mm:ss.fff}", notification.Value.SourceTimestamp.ToLocalTime()); } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
private static void OnNotification(MonitoredItem item, MonitoredItemNotificationEventArgs e) { foreach (var value in item.DequeueValues()) { Console.WriteLine("{0}: {1}, {2}, {3}", item.DisplayName, value.Value, value.SourceTimestamp, value.StatusCode); } }
/// <summary> /// Processes a Publish response from the UA server. /// </summary> /// <param name="monitoredItem"></param> /// <param name="e"></param> void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { try { EventFieldList eventFields = e.NotificationValue as EventFieldList; if (eventFields == null) { return; } if (monitoredItem != null) { if (monitoredItem.ClientHandle != eventFields.ClientHandle) { return; } } INode eventUA = monitoredItem.GetEventType(eventFields); EventCategory cat = FindEventCatInfo(eventUA.BrowseName.ToString()); if (cat == null) return; // The event is not of a category that we recognize. if (cat.EventType == OpcRcw.Ae.Constants.CONDITION_EVENT) { NodeId branchId = monitoredItem.GetFieldValue(eventFields, Opc.Ua.ObjectTypes.ConditionType, Opc.Ua.BrowseNames.BranchId) as NodeId; if (!NodeId.IsNull(branchId)) return; // We don't support condition branches in the COM Proxy } EventNotification ev = new EventNotification(); ev.EventId = monitoredItem.GetFieldValue(eventFields, Opc.Ua.ObjectTypes.BaseEventType, new QualifiedName(Opc.Ua.BrowseNames.EventId)) as byte[]; ev.SourceID = System.Convert.ToString(monitoredItem.GetFieldValue(eventFields, Opc.Ua.ObjectTypes.BaseEventType, new QualifiedName(Opc.Ua.BrowseNames.SourceName))); ev.Time = System.Convert.ToDateTime(monitoredItem.GetFieldValue(eventFields, Opc.Ua.ObjectTypes.BaseEventType, new QualifiedName(Opc.Ua.BrowseNames.Time))); ev.Message = System.Convert.ToString(monitoredItem.GetFieldValue(eventFields, Opc.Ua.ObjectTypes.BaseEventType, new QualifiedName(Opc.Ua.BrowseNames.Message))); ev.EventType = cat.EventType; ev.EventCategory = cat.CategoryID; ev.Severity = System.Convert.ToInt32(monitoredItem.GetFieldValue(eventFields, Opc.Ua.ObjectTypes.BaseEventType, new QualifiedName(Opc.Ua.BrowseNames.Severity))); List<EventAttribute> Attrs = GetEventAttributes(cat.CategoryID); UniqueList<string> strEventNodeIds = new UniqueList<string>(); foreach (EventAttribute attr in Attrs) if (attr.strEventNodeId != "") strEventNodeIds.AddUnique(attr.strEventNodeId); ev.EventAttributes = new Dictionary<int, object>(); foreach (EventAttribute attr in m_configFile.Attributes) { foreach (string strEventNodeId in strEventNodeIds) { if (attr.strEventNodeId == strEventNodeId) { object value = monitoredItem.GetFieldValue(eventFields, (NodeId)attr.strEventNodeId, new QualifiedName(attr.BrowseName, attr.BrowseNameNSIndex)); if (value == null) { ev.EventAttributes.Add(attr.AttributeID, ""); } else if ((value.GetType() != null) & (short)ComUtils.GetVarType(value) != 0) { ev.EventAttributes.Add(attr.AttributeID, value); } else { // any value with a UA type that does not have a corresponding COM type will be returned as a string ev.EventAttributes.Add(attr.AttributeID, value.ToString()); } } } } //Condition-Related Event properties ev.ConditionName = ""; ev.SubConditionName = ""; ev.ChangeMask = 0; ev.NewState = OpcRcw.Ae.Constants.CONDITION_ENABLED | OpcRcw.Ae.Constants.CONDITION_ACKED; ev.Quality = OpcRcw.Da.Qualities.OPC_QUALITY_GOOD; ev.AckRequired = false; ev.ActiveTime = DateTime.Now; ev.Cookie = 0; if (ev.EventType == OpcRcw.Ae.Constants.CONDITION_EVENT) SetConditionEventFields(monitoredItem, eventFields, ev, cat); //Tracking Events and for Condition-Related Events which are acknowledgment notifications if (cat.EventType == OpcRcw.Ae.Constants.TRACKING_EVENT) ev.ActorID = System.Convert.ToString(monitoredItem.GetFieldValue(eventFields, (NodeId)eventUA.NodeId, new QualifiedName(Opc.Ua.BrowseNames.ClientUserId))); IncomingEventHandler eventHandler = new IncomingEventHandler(); //extract the area associated with this event. AreaNode areaNode; string[] areas = null; if (m_notifiers.TryGetValue(monitoredItem.ClientHandle, out areaNode)) { areas = new string[] { areaNode.AreaName }; } eventHandler.ProcessEventNotificationList(ev, areas); } catch (Exception ex) { Utils.Trace(ex, "Unexpected error in MonitoredItem_Notification"); } }
/// <summary> /// Updates the display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { // check for valid notification. EventFieldList notification = e.NotificationValue as EventFieldList; if (notification == null) { return; } // check if monitored item has changed. if (!Object.ReferenceEquals(m_monitoredItem, monitoredItem)) { return; } // check if the filter has changed. if (notification.EventFields.Count != m_filter.Fields.Count+1) { return; } // create an item and add to top of list. ListViewItem item = CreateListItem(m_filter, notification.EventFields); EventsLV.Items.Insert(0, item); // adjust the width of the columns. for (int ii = 0; ii < EventsLV.Columns.Count; ii++) { EventsLV.Columns[ii].Width = -2; } } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
/// <summary> /// Processes a Publish response from the UA server for AddressSpace changes. /// </summary> /// <param name="monitoredItem"></param> /// <param name="e"></param> void AddressSpaceChange_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { try { EventFieldList eventFields = e.NotificationValue as EventFieldList; if (eventFields == null) { return; } if (monitoredItem != null) { if (monitoredItem.ClientHandle != eventFields.ClientHandle) { return; } } INode eventUA = monitoredItem.GetEventType(eventFields); if (eventUA.NodeId == new NodeId(Opc.Ua.ObjectTypes.BaseModelChangeEventType)) { //TODO:if we get this event we know a change was made, but we do not know what so we will beed to get all EventTypes and compare and update our config data } else if (eventUA.NodeId != new NodeId(Opc.Ua.ObjectTypes.GeneralModelChangeEventType)) { //We are not interested in any other event, so we will return. //If we can set the where clause on the filter for this item, this else clause can be removed. return; } else { object v = monitoredItem.GetFieldValue(eventFields, Opc.Ua.ObjectTypes.GeneralModelChangeEventType, new QualifiedName(Opc.Ua.BrowseNames.Changes)); //ChangeStructureDataTypeCollection changes = (ChangeStructureDataTypeCollection) monitoredItem.GetFieldValue(eventFields, ObjectTypes.GeneralModelChangeEventType, new QualifiedName(GeneralModelChangeEvent.Names.Changes)); } } catch (Exception ex) { Utils.Trace(ex, "Unexpected error in AddressSpaceChange_Notification"); } }
/// <summary> /// Processes a Publish repsonse from the server. /// </summary> void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (InvokeRequired) { BeginInvoke(m_MonitoredItemNotification, monitoredItem, e); return; } else if (!IsHandleCreated) { return; } try { // ignore notifications for other monitored items. if (!Object.ReferenceEquals(m_monitoredItem, monitoredItem)) { return; } // notify controls of the change. EventsCTRL.NotificationReceived(e); DataChangesCTRL.NotificationReceived(e); if (e != null) { MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification; LatestValueCTRL.ShowValue(notification, true); } // update item status. UpdateStatus(); } catch (Exception exception) { GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); } }
/// <summary> /// Updates the display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { EventFieldList notification = e.NotificationValue as EventFieldList; if (notification == null) { return; } // check the type of event. NodeId eventTypeId = FormUtils.FindEventType(monitoredItem, notification); // ignore unknown events. if (NodeId.IsNull(eventTypeId)) { return; } // check for refresh start. if (eventTypeId == ObjectTypeIds.RefreshStartEventType) { ConditionsLV.Items.Clear(); return; } // check for refresh end. if (eventTypeId == ObjectTypeIds.RefreshEndEventType) { return; } // construct the condition object. ConditionState condition = FormUtils.ConstructEvent( m_session, monitoredItem, notification, m_eventTypeMappings) as ConditionState; if (condition == null) { return; } // look for existing entry. ListViewItem item = null; for (int ii = 0; ii < ConditionsLV.Items.Count; ii++) { ConditionState current = (ConditionState)ConditionsLV.Items[ii].Tag; // the combination of a condition and branch id uniquely identify an item in the display. if (current.NodeId == condition.NodeId && BaseVariableState.GetValue(current.BranchId) == BaseVariableState.GetValue(condition.BranchId)) { // match found but watch out for out of order events (async processing can cause this to happen). if (BaseVariableState.GetValue(current.Time) > BaseVariableState.GetValue(condition.Time)) { return; } item = ConditionsLV.Items[ii]; break; } } // create a new entry. if (item == null) { item = new ListViewItem(String.Empty); item.SubItems.Add(String.Empty); // Condition item.SubItems.Add(String.Empty); // Branch item.SubItems.Add(String.Empty); // Type item.SubItems.Add(String.Empty); // Severity item.SubItems.Add(String.Empty); // Time item.SubItems.Add(String.Empty); // State item.SubItems.Add(String.Empty); // Message item.SubItems.Add(String.Empty); // Comment ConditionsLV.Items.Add(item); } // look up the condition type metadata in the local cache. INode type = m_session.NodeCache.Find(condition.TypeDefinitionId); // Source if (condition.SourceName != null) { item.SubItems[0].Text = Utils.Format("{0}", condition.SourceName.Value); } else { item.SubItems[0].Text = null; } // Condition if (condition.ConditionName != null) { item.SubItems[1].Text = Utils.Format("{0}", condition.ConditionName.Value); } else { item.SubItems[1].Text = null; } // Branch if (condition.BranchId != null && !NodeId.IsNull(condition.BranchId.Value)) { item.SubItems[2].Text = Utils.Format("{0}", condition.BranchId.Value); } else { item.SubItems[2].Text = null; } // Type if (type != null) { item.SubItems[3].Text = Utils.Format("{0}", type); } else { item.SubItems[3].Text = null; } // Severity if (condition.Severity != null) { item.SubItems[4].Text = Utils.Format("{0}", (EventSeverity)condition.Severity.Value); } else { item.SubItems[4].Text = null; } // Time if (condition.Time != null) { item.SubItems[5].Text = Utils.Format("{0:HH:mm:ss.fff}", condition.Time.Value.ToLocalTime()); } else { item.SubItems[5].Text = null; } // State if (condition.EnabledState != null && condition.EnabledState.EffectiveDisplayName != null) { item.SubItems[6].Text = Utils.Format("{0}", condition.EnabledState.EffectiveDisplayName.Value); } else { item.SubItems[6].Text = null; } // Message if (condition.Message != null) { item.SubItems[7].Text = Utils.Format("{0}", condition.Message.Value); } else { item.SubItems[7].Text = null; } // Comment if (condition.Comment != null) { item.SubItems[8].Text = Utils.Format("{0}", condition.Comment.Value); } else { item.SubItems[8].Text = null; } item.Tag = condition; // set the color based on the retain bit. if (!BaseVariableState.GetValue(condition.Retain)) { item.ForeColor = Color.DimGray; } else { if (NodeId.IsNull(BaseVariableState.GetValue(condition.BranchId))) { item.ForeColor = Color.Empty; } else { item.ForeColor = Color.DarkGray; } } // adjust the width of the columns. for (int ii = 0; ii < ConditionsLV.Columns.Count; ii++) { ConditionsLV.Columns[ii].Width = -2; } } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
/// <summary> /// Updates the display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { if (!Object.ReferenceEquals(monitoredItem.Subscription, m_subscription)) { return; } MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification; if (notification == null) { return; } AddValue(notification.Value, null); m_dataset.AcceptChanges(); ResultsDV.FirstDisplayedCell = ResultsDV.Rows[ResultsDV.Rows.Count - 1].Cells[0]; } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
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 display with a new value for a monitored variable. /// </summary> private void MonitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new MonitoredItemNotificationEventHandler(MonitoredItem_Notification), monitoredItem, e); return; } try { EventFieldList notification = e.NotificationValue as EventFieldList; if (notification == null) { return; } // check the type of event. NodeId eventTypeId = ClientUtils.FindEventType(monitoredItem, notification); // ignore unknown events. if (NodeId.IsNull(eventTypeId)) { return; } // construct the audit object. SystemCycleStatusEventState status = ClientUtils.ConstructEvent( m_session, monitoredItem, notification, m_knownEventTypes, m_eventTypeMappings) as SystemCycleStatusEventState; if (e == null) { return; } ListViewItem item = new ListViewItem(String.Empty); item.SubItems.Add(String.Empty); // Source item.SubItems.Add(String.Empty); // Type item.SubItems.Add(String.Empty); // CycleId item.SubItems.Add(String.Empty); // Step item.SubItems.Add(String.Empty); // Time item.SubItems.Add(String.Empty); // Message // look up the condition type metadata in the local cache. INode type = m_session.NodeCache.Find(status.TypeDefinitionId); // Source if (status.SourceName != null) { item.SubItems[0].Text = Utils.Format("{0}", status.SourceName.Value); } else { item.SubItems[0].Text = null; } // Type if (type != null) { item.SubItems[1].Text = Utils.Format("{0}", type); } else { item.SubItems[1].Text = null; } // CycleId if (status.CycleId != null) { item.SubItems[2].Text = Utils.Format("{0}", status.CycleId.Value); } else { item.SubItems[2].Text = null; } // Step if (status.CurrentStep != null && status.CurrentStep.Value != null) { item.SubItems[3].Text = Utils.Format("{0}", status.CurrentStep.Value.Name); } else { item.SubItems[3].Text = null; } // Time if (status.Time != null) { item.SubItems[4].Text = Utils.Format("{0:HH:mm:ss.fff}", status.Time.Value.ToLocalTime()); } else { item.SubItems[4].Text = null; } // Message if (status.Message != null) { item.SubItems[5].Text = Utils.Format("{0}", status.Message.Value); } else { item.SubItems[5].Text = null; } item.Tag = status; EventsLV.Items.Add(item); // adjust the width of the columns. for (int ii = 0; ii < EventsLV.Columns.Count; ii++) { EventsLV.Columns[ii].Width = -2; } } 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> /// /// </summary> /// <param name="monitoredItem"></param> /// <param name="e"></param> protected virtual void ItemNotificationHandler(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { try { if (monitoredItem != null) { Opc.Ua.MonitoredItemNotification change = e.NotificationValue as Opc.Ua.MonitoredItemNotification; if (change != null) { DataValue dv = change.Value; if (dv != null) { ListViewItem[] lvis = ItemsLV.Items.Find(monitoredItem.ClientHandle.ToString(), false); if (lvis.Length > 0) { DiagnosticListViewItem dlvi = lvis[0].Tag as DiagnosticListViewItem; dlvi.UpdateInListView(lvis[0], dv, m_Session); } } else { Utils.Trace("dv is null: {0}", 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; if (eventType == new NodeId(ObjectTypes.AuditAddNodesEventType)) { } else { } } else { Utils.Trace("eventFields is null " + MethodBase.GetCurrentMethod()); } } } } catch (Exception exception) { GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); } }