The event arguments provided when a new notification message arrives.
Inheritance: System.EventArgs
示例#1
0
        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());
            }
        }
示例#2
0
        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");
            }
        }
示例#3
0
        /// <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);
            }
        }
示例#4
0
        /// <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();
        }
示例#6
0
 /// <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();
        }
示例#9
0
        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);
            }
        }
示例#10
0
        /// <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.");
                }
            });
        }
示例#12
0
        /// <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);
            }
        }
示例#13
0
        /// <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);
     }
 }
示例#15
0
        /// <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");
            }
        }
示例#16
0
        /// <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);
            }
        }
示例#17
0
        /// <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");
            }
        }
示例#18
0
        /// <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);
            }
        }
示例#19
0
        /// <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);
            }
        }
示例#20
0
        /// <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);
            }
        }
示例#21
0
        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);
            }
        }
示例#22
0
        /// <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);
            }
        }
示例#23
0
    /// <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);
      }
    }
示例#24
0
    /// <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);
      }
    }