/// <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)
{
}
/// <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)
{
}
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;
}
