Samuele Locatelli
2353 lines
83 KiB
C#
2353 lines
83 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2020 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Client;
|
|
|
|
namespace Opc.Ua.Client.Controls
|
|
{
|
|
/// <summary>
|
|
/// Displays the results from a history read operation.
|
|
/// </summary>
|
|
public partial class HistoryDataListView : UserControl
|
|
{
|
|
#region Constructors
|
|
/// <summary>
|
|
/// Constructs a new instance.
|
|
/// </summary>
|
|
public HistoryDataListView()
|
|
{
|
|
InitializeComponent();
|
|
ResultsDV.AutoGenerateColumns = false;
|
|
LeftPN.Enabled = false;
|
|
|
|
ReadTypeCB.Items.Add(HistoryReadType.Raw);
|
|
ReadTypeCB.Items.Add(HistoryReadType.Processed);
|
|
ReadTypeCB.Items.Add(HistoryReadType.Modified);
|
|
ReadTypeCB.Items.Add(HistoryReadType.AtTime);
|
|
ReadTypeCB.Items.Add(HistoryReadType.Subscribe);
|
|
ReadTypeCB.Items.Add(HistoryReadType.Insert);
|
|
ReadTypeCB.Items.Add(HistoryReadType.InsertReplace);
|
|
ReadTypeCB.Items.Add(HistoryReadType.Replace);
|
|
ReadTypeCB.Items.Add(HistoryReadType.Remove);
|
|
ReadTypeCB.Items.Add(HistoryReadType.DeleteRaw);
|
|
ReadTypeCB.Items.Add(HistoryReadType.DeleteModified);
|
|
ReadTypeCB.Items.Add(HistoryReadType.DeleteAtTime);
|
|
ReadTypeCB.SelectedIndex = 0;
|
|
|
|
m_dataset = new DataSet();
|
|
m_dataset.Tables.Add("Results");
|
|
|
|
m_dataset.Tables[0].Columns.Add("Index", typeof(int));
|
|
m_dataset.Tables[0].Columns.Add("SourceTimestamp", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("ServerTimestamp", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("Value", typeof(Variant));
|
|
m_dataset.Tables[0].Columns.Add("StatusCode", typeof(StatusCode));
|
|
m_dataset.Tables[0].Columns.Add("HistoryInfo", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("UpdateType", typeof(HistoryUpdateType));
|
|
m_dataset.Tables[0].Columns.Add("UpdateTime", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("UserName", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("DataValue", typeof(DataValue));
|
|
m_dataset.Tables[0].Columns.Add("UpdateResult", typeof(StatusCode));
|
|
|
|
m_dataset.Tables[0].DefaultView.Sort = "Index";
|
|
|
|
ResultsDV.DataSource = m_dataset.Tables[0];
|
|
}
|
|
#endregion
|
|
|
|
#region HistoryReadType Class
|
|
/// <summary>
|
|
/// The type history read operation.
|
|
/// </summary>
|
|
public enum HistoryReadType
|
|
{
|
|
/// <summary>
|
|
/// Subscribe to data changes.
|
|
/// </summary>
|
|
Subscribe,
|
|
|
|
/// <summary>
|
|
/// Read raw data.
|
|
/// </summary>
|
|
Raw,
|
|
|
|
/// <summary>
|
|
/// Read modified data.
|
|
/// </summary>
|
|
Modified,
|
|
|
|
/// <summary>
|
|
/// Read data at the specified times.
|
|
/// </summary>
|
|
AtTime,
|
|
|
|
/// <summary>
|
|
/// Read processed data.
|
|
/// </summary>
|
|
Processed,
|
|
|
|
/// <summary>
|
|
/// Insert data.
|
|
/// </summary>
|
|
Insert,
|
|
|
|
/// <summary>
|
|
/// Insert or replace data.
|
|
/// </summary>
|
|
InsertReplace,
|
|
|
|
/// <summary>
|
|
/// Replace data.
|
|
/// </summary>
|
|
Replace,
|
|
|
|
/// <summary>
|
|
/// Remove data.
|
|
/// </summary>
|
|
Remove,
|
|
|
|
/// <summary>
|
|
/// Delete raw data.
|
|
/// </summary>
|
|
DeleteRaw,
|
|
|
|
/// <summary>
|
|
/// Delete modified data.
|
|
/// </summary>
|
|
DeleteModified,
|
|
|
|
/// <summary>
|
|
/// Delete data at the specified times.
|
|
/// </summary>
|
|
DeleteAtTime
|
|
}
|
|
#endregion
|
|
|
|
#region AvailableAggregate Class
|
|
/// <summary>
|
|
/// An aggregate supported by server.
|
|
/// </summary>
|
|
private class AvailableAggregate
|
|
{
|
|
public NodeId NodeId { get; set; }
|
|
public string DisplayName { get; set; }
|
|
|
|
public override string ToString()
|
|
{
|
|
return DisplayName;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region AvailableSession Class
|
|
/// <summary>
|
|
/// A session available in the conntrol.
|
|
/// </summary>
|
|
private class AvailableSession
|
|
{
|
|
public Session Session { get; set; }
|
|
|
|
public override string ToString()
|
|
{
|
|
return Session.SessionName;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region PropertyWithHistory Class
|
|
/// <summary>
|
|
/// Stores the metadata about a property with history to read or update.
|
|
/// </summary>
|
|
private class PropertyWithHistory
|
|
{
|
|
public PropertyWithHistory()
|
|
{
|
|
}
|
|
|
|
public PropertyWithHistory(ReferenceDescription reference, byte accessLevel)
|
|
{
|
|
DisplayText = reference.ToString();
|
|
NodeId = (NodeId)reference.NodeId;
|
|
BrowseName = reference.BrowseName;
|
|
AccessLevel = accessLevel;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return DisplayText;
|
|
}
|
|
|
|
public string DisplayText;
|
|
public NodeId NodeId;
|
|
public QualifiedName BrowseName;
|
|
public byte AccessLevel;
|
|
}
|
|
#endregion
|
|
|
|
#region Private Fields
|
|
private Session m_session;
|
|
private Subscription m_subscription;
|
|
private MonitoredItem m_monitoredItem;
|
|
private NodeId m_nodeId;
|
|
private DataSet m_dataset;
|
|
private int m_nextId;
|
|
private bool m_isSubscribed;
|
|
private HistoryReadDetails m_details;
|
|
private HistoryReadValueId m_nodeToContinue;
|
|
private bool m_timesChanged;
|
|
private HistoricalDataConfigurationState m_configuration;
|
|
private List<PropertyWithHistory> m_properties;
|
|
#endregion
|
|
|
|
#region Public Members
|
|
/// <summary>
|
|
/// The node id to use.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public NodeId NodeId
|
|
{
|
|
get
|
|
{
|
|
return m_nodeId;
|
|
}
|
|
|
|
set
|
|
{
|
|
m_nodeId = value;
|
|
|
|
if (m_session != null)
|
|
{
|
|
NodeIdTB.Text = m_session.NodeCache.GetDisplayText(m_nodeId);
|
|
}
|
|
else
|
|
{
|
|
if (NodeId.IsNull(m_nodeId))
|
|
{
|
|
NodeIdTB.Text = String.Empty;
|
|
}
|
|
else
|
|
{
|
|
NodeIdTB.Text = m_nodeId.ToString();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The type of read operation.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public HistoryReadType ReadType
|
|
{
|
|
get { return (HistoryReadType)ReadTypeCB.SelectedItem; }
|
|
set { ReadTypeCB.SelectedItem = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The start time for the query.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public DateTime StartTime
|
|
{
|
|
get
|
|
{
|
|
if (StartTimeCK.Checked)
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
return StartTimeDP.Value;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value < Utils.TimeBase)
|
|
{
|
|
StartTimeCK.Checked = false;
|
|
return;
|
|
}
|
|
|
|
if (value.Kind == DateTimeKind.Local)
|
|
{
|
|
value = value.ToUniversalTime();
|
|
}
|
|
|
|
StartTimeCK.Checked = true;
|
|
StartTimeDP.Value = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The end time for the query.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public DateTime EndTime
|
|
{
|
|
get
|
|
{
|
|
if (EndTimeCK.Checked)
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
return EndTimeDP.Value;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value < Utils.TimeBase)
|
|
{
|
|
EndTimeCK.Checked = false;
|
|
return;
|
|
}
|
|
|
|
if (value.Kind == DateTimeKind.Local)
|
|
{
|
|
value = value.ToUniversalTime();
|
|
}
|
|
|
|
EndTimeCK.Checked = true;
|
|
EndTimeDP.Value = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// THe maximum number of values to return.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public uint MaxReturnValues
|
|
{
|
|
get
|
|
{
|
|
if (MaxReturnValuesCK.Checked)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return (uint)MaxReturnValuesNP.Value;
|
|
}
|
|
|
|
set
|
|
{
|
|
MaxReturnValuesCK.Checked = value != 0;
|
|
MaxReturnValuesNP.Value = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If true the bounds are returned in the query.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ReturnBounds
|
|
{
|
|
get
|
|
{
|
|
return ReturnBoundsCK.Checked;
|
|
}
|
|
|
|
set
|
|
{
|
|
ReturnBoundsCK.Checked = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The aggregate to calculate.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public NodeId Aggregate
|
|
{
|
|
get
|
|
{
|
|
AvailableAggregate aggregate = AggregateCB.SelectedItem as AvailableAggregate;
|
|
|
|
if (aggregate == null)
|
|
{
|
|
return NodeId.Null;
|
|
}
|
|
|
|
return aggregate.NodeId;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (NodeId.IsNull(value))
|
|
{
|
|
AggregateCB.SelectedIndex = -1;
|
|
return;
|
|
}
|
|
|
|
foreach (AvailableAggregate aggregate in AggregateCB.Items)
|
|
{
|
|
if (aggregate.NodeId == value)
|
|
{
|
|
AggregateCB.SelectedItem = value;
|
|
return;
|
|
|
|
}
|
|
}
|
|
|
|
throw new ArgumentException("Aggregate does match one of the available aggregates.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The processing interval to use.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public double ProcessingInterval
|
|
{
|
|
get { return (double)ProcessingIntervalNP.Value; }
|
|
set { ProcessingIntervalNP.Value = (decimal)value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the session.
|
|
/// </summary>
|
|
public void ChangeSession(Session session)
|
|
{
|
|
if (Object.ReferenceEquals(session, m_session))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_session != null)
|
|
{
|
|
DeleteSubscription();
|
|
m_session = null;
|
|
}
|
|
|
|
if (session == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_session = session;
|
|
m_dataset.Clear();
|
|
LeftPN.Enabled = m_session != null;
|
|
|
|
if (m_session != null)
|
|
{
|
|
AggregateCB.Items.Clear();
|
|
|
|
ILocalNode node = m_session.NodeCache.Find(ObjectIds.Server_ServerCapabilities_AggregateFunctions) as ILocalNode;
|
|
|
|
if (node != null)
|
|
{
|
|
foreach (IReference reference in node.References.Find(ReferenceTypeIds.HierarchicalReferences, false, true, m_session.TypeTree))
|
|
{
|
|
ILocalNode aggregate = m_session.NodeCache.Find(reference.TargetId) as ILocalNode;
|
|
|
|
if (aggregate != null && aggregate.TypeDefinitionId == ObjectTypeIds.AggregateFunctionType)
|
|
{
|
|
AvailableAggregate item = new AvailableAggregate();
|
|
item.NodeId = aggregate.NodeId;
|
|
item.DisplayName = m_session.NodeCache.GetDisplayText(aggregate);
|
|
AggregateCB.Items.Add(item);
|
|
}
|
|
}
|
|
|
|
if (AggregateCB.Items.Count == 0)
|
|
{
|
|
AggregateCB.Items.Add(new AvailableAggregate() { NodeId = ObjectIds.AggregateFunction_Interpolative, DisplayName = BrowseNames.AggregateFunction_Interpolative });
|
|
AggregateCB.Items.Add(new AvailableAggregate() { NodeId = ObjectIds.AggregateFunction_Average, DisplayName = BrowseNames.AggregateFunction_Average });
|
|
AggregateCB.Items.Add(new AvailableAggregate() { NodeId = ObjectIds.AggregateFunction_TimeAverage, DisplayName = BrowseNames.AggregateFunction_TimeAverage });
|
|
AggregateCB.Items.Add(new AvailableAggregate() { NodeId = ObjectIds.AggregateFunction_Total, DisplayName = BrowseNames.AggregateFunction_Total });
|
|
AggregateCB.Items.Add(new AvailableAggregate() { NodeId = ObjectIds.AggregateFunction_Count, DisplayName = BrowseNames.AggregateFunction_Count });
|
|
}
|
|
|
|
if (AggregateCB.Items.Count > 0)
|
|
{
|
|
AggregateCB.SelectedIndex = 0;
|
|
}
|
|
}
|
|
|
|
SubscriptionStateChanged();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the control after the session has reconnected.
|
|
/// </summary>
|
|
public void SessionReconnected(Session session)
|
|
{
|
|
m_session = session;
|
|
|
|
if (m_session != null)
|
|
{
|
|
foreach (Subscription subscription in m_session.Subscriptions)
|
|
{
|
|
if (Object.ReferenceEquals(subscription.Handle, this))
|
|
{
|
|
m_subscription = subscription;
|
|
|
|
foreach (MonitoredItem monitoredItem in subscription.MonitoredItems)
|
|
{
|
|
m_monitoredItem = monitoredItem;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the node monitored by the control.
|
|
/// </summary>
|
|
public void ChangeNode(NodeId nodeId)
|
|
{
|
|
m_nodeId = nodeId;
|
|
m_configuration = null;
|
|
m_properties = null;
|
|
PropertyCB.Items.Clear();
|
|
m_dataset.Clear();
|
|
NodeIdTB.Text = m_session.NodeCache.GetDisplayText(m_nodeId);
|
|
|
|
if (!NodeId.IsNull(nodeId))
|
|
{
|
|
m_properties = FindPropertiesWithHistory();
|
|
|
|
if (m_properties == null || m_properties.Count <= 1)
|
|
{
|
|
PropertyLB.Visible = false;
|
|
PropertyCB.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
PropertyCB.Items.AddRange((object[])m_properties.ToArray());
|
|
PropertyCB.SelectedIndex = 0;
|
|
PropertyLB.Visible = true;
|
|
PropertyCB.Visible = true;
|
|
}
|
|
|
|
m_configuration = ReadConfiguration();
|
|
|
|
if (StatusCode.IsBad(m_configuration.Stepped.StatusCode))
|
|
{
|
|
this.ReadTypeCB.Enabled = false;
|
|
this.ReadTypeCB.SelectedItem = HistoryReadType.Subscribe;
|
|
}
|
|
else
|
|
{
|
|
this.ReadTypeCB.Enabled = true;
|
|
|
|
if (!m_timesChanged)
|
|
{
|
|
DateTime startTime = ReadFirstDate();
|
|
|
|
if (startTime != DateTime.MinValue)
|
|
{
|
|
StartTimeDP.Value = startTime;
|
|
}
|
|
|
|
DateTime endTime = ReadLastDate();
|
|
|
|
if (endTime != DateTime.MinValue)
|
|
{
|
|
EndTimeDP.Value = endTime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_subscription != null)
|
|
{
|
|
MonitoredItem monitoredItem = new MonitoredItem(m_monitoredItem);
|
|
monitoredItem.StartNodeId = nodeId;
|
|
|
|
m_subscription.AddItem(monitoredItem);
|
|
m_subscription.RemoveItem(m_monitoredItem);
|
|
m_monitoredItem = monitoredItem;
|
|
|
|
monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
|
|
|
|
m_subscription.ApplyChanges();
|
|
SubscriptionStateChanged();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the sort order for the control.
|
|
/// </summary>
|
|
/// <param name="mostRecentFirst">If true the most recent entries are displayed first.</param>
|
|
public void SetSortOrder(bool mostRecentFirst)
|
|
{
|
|
if (m_dataset != null && m_dataset.Tables.Count > 0)
|
|
{
|
|
if (mostRecentFirst)
|
|
{
|
|
m_dataset.Tables[0].DefaultView.Sort = "Index DESC";
|
|
}
|
|
else
|
|
{
|
|
m_dataset.Tables[0].DefaultView.Sort = "Index";
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A kludge to get around the stupid designer that keeps setting property values to bogus defaults.
|
|
/// </summary>
|
|
public void Reset()
|
|
{
|
|
NodeId = null;
|
|
ReadType = HistoryReadType.Raw;
|
|
StartTime = DateTime.MinValue;
|
|
EndTime = DateTime.MinValue;
|
|
Aggregate = null;
|
|
|
|
StartTimeCK.Checked = true;
|
|
EndTimeCK.Checked = false;
|
|
MaxReturnValuesCK.Checked = true;
|
|
MaxReturnValuesNP.Value = 10;
|
|
m_timesChanged = false;
|
|
ProcessingIntervalNP.Value = 5000;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shows the configuration.
|
|
/// </summary>
|
|
public void ShowConfiguration()
|
|
{
|
|
if (m_session != null)
|
|
{
|
|
if (m_configuration != null)
|
|
{
|
|
new ViewNodeStateDlg().ShowDialog(m_session, m_configuration, null);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
/// <summary>
|
|
/// Recursively collects the variables in a NodeState and returns a collection of BrowsePaths.
|
|
/// </summary>
|
|
public void GetBrowsePathFromNodeState(
|
|
ISystemContext context,
|
|
NodeId rootId,
|
|
NodeState parent,
|
|
RelativePath parentPath,
|
|
BrowsePathCollection browsePaths)
|
|
{
|
|
List<BaseInstanceState> children = new List<BaseInstanceState>();
|
|
parent.GetChildren(context, children);
|
|
|
|
for (int ii = 0; ii < children.Count; ii++)
|
|
{
|
|
BaseInstanceState child = children[ii];
|
|
|
|
BrowsePath browsePath = new BrowsePath();
|
|
browsePath.StartingNode = rootId;
|
|
browsePath.Handle = child;
|
|
|
|
if (parentPath != null)
|
|
{
|
|
browsePath.RelativePath.Elements.AddRange(parentPath.Elements);
|
|
}
|
|
|
|
RelativePathElement element = new RelativePathElement();
|
|
element.ReferenceTypeId = child.ReferenceTypeId;
|
|
element.IsInverse = false;
|
|
element.IncludeSubtypes = false;
|
|
element.TargetName = child.BrowseName;
|
|
|
|
browsePath.RelativePath.Elements.Add(element);
|
|
|
|
if (child.NodeClass == NodeClass.Variable)
|
|
{
|
|
browsePaths.Add(browsePath);
|
|
}
|
|
|
|
GetBrowsePathFromNodeState(context, rootId, child, browsePath.RelativePath, browsePaths);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the historical configuration for the node.
|
|
/// </summary>
|
|
private List<PropertyWithHistory> FindPropertiesWithHistory()
|
|
{
|
|
BrowseDescription nodeToBrowse = new BrowseDescription();
|
|
nodeToBrowse.NodeId = m_nodeId;
|
|
nodeToBrowse.ReferenceTypeId = Opc.Ua.ReferenceTypeIds.HasProperty;
|
|
nodeToBrowse.IncludeSubtypes = true;
|
|
nodeToBrowse.BrowseDirection = BrowseDirection.Forward;
|
|
nodeToBrowse.NodeClassMask = 0;
|
|
nodeToBrowse.ResultMask = (uint)(BrowseResultMask.DisplayName | BrowseResultMask.BrowseName);
|
|
|
|
ReferenceDescriptionCollection references = ClientUtils.Browse(m_session, nodeToBrowse, false);
|
|
|
|
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
|
|
|
|
for (int ii = 0; ii < references.Count; ii++)
|
|
{
|
|
if (references[ii].NodeId.IsAbsolute)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ReadValueId nodeToRead = new ReadValueId();
|
|
nodeToRead.NodeId = (NodeId)references[ii].NodeId;
|
|
nodeToRead.AttributeId = Attributes.AccessLevel;
|
|
nodeToRead.Handle = references[ii];
|
|
nodesToRead.Add(nodeToRead);
|
|
}
|
|
|
|
List<PropertyWithHistory> properties = new List<PropertyWithHistory>();
|
|
properties.Add(new PropertyWithHistory() { DisplayText = "(none)", NodeId = m_nodeId, AccessLevel = AccessLevels.HistoryReadOrWrite });
|
|
|
|
if (nodesToRead.Count > 0)
|
|
{
|
|
DataValueCollection values = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.Read(
|
|
null,
|
|
0,
|
|
TimestampsToReturn.Neither,
|
|
nodesToRead,
|
|
out values,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(values, nodesToRead);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
|
|
for (int ii = 0; ii < nodesToRead.Count; ii++)
|
|
{
|
|
byte accessLevel = values[ii].GetValue<byte>(0);
|
|
|
|
if ((accessLevel & AccessLevels.HistoryRead) != 0)
|
|
{
|
|
properties.Add(new PropertyWithHistory((ReferenceDescription)nodesToRead[ii].Handle, accessLevel));
|
|
}
|
|
}
|
|
}
|
|
|
|
return properties;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the historical configuration for the node.
|
|
/// </summary>
|
|
private HistoricalDataConfigurationState ReadConfiguration()
|
|
{
|
|
// load the defaults for the historical configuration object.
|
|
HistoricalDataConfigurationState configuration = new HistoricalDataConfigurationState(null);
|
|
|
|
configuration.Definition = new PropertyState<string>(configuration);
|
|
configuration.MaxTimeInterval = new PropertyState<double>(configuration);
|
|
configuration.MinTimeInterval = new PropertyState<double>(configuration);
|
|
configuration.ExceptionDeviation = new PropertyState<double>(configuration);
|
|
configuration.ExceptionDeviationFormat = new PropertyState<ExceptionDeviationFormat>(configuration);
|
|
configuration.StartOfArchive = new PropertyState<DateTime>(configuration);
|
|
configuration.StartOfOnlineArchive = new PropertyState<DateTime>(configuration);
|
|
|
|
configuration.Create(
|
|
m_session.SystemContext,
|
|
null,
|
|
Opc.Ua.BrowseNames.HAConfiguration,
|
|
null,
|
|
false);
|
|
|
|
// get the browse paths to query.
|
|
RelativePathElement element = new RelativePathElement();
|
|
element.ReferenceTypeId = Opc.Ua.ReferenceTypeIds.HasHistoricalConfiguration;
|
|
element.IsInverse = false;
|
|
element.IncludeSubtypes = false;
|
|
element.TargetName = Opc.Ua.BrowseNames.HAConfiguration;
|
|
|
|
RelativePath relativePath = new RelativePath();
|
|
relativePath.Elements.Add(element);
|
|
|
|
BrowsePathCollection pathsToTranslate = new BrowsePathCollection();
|
|
|
|
GetBrowsePathFromNodeState(
|
|
m_session.SystemContext,
|
|
m_nodeId,
|
|
configuration,
|
|
relativePath,
|
|
pathsToTranslate);
|
|
|
|
// translate browse paths.
|
|
BrowsePathResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.TranslateBrowsePathsToNodeIds(
|
|
null,
|
|
pathsToTranslate,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, pathsToTranslate);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, pathsToTranslate);
|
|
|
|
// build list of values to read.
|
|
ReadValueIdCollection valuesToRead = new ReadValueIdCollection();
|
|
|
|
for (int ii = 0; ii < pathsToTranslate.Count; ii++)
|
|
{
|
|
BaseVariableState variable = (BaseVariableState)pathsToTranslate[ii].Handle;
|
|
variable.Value = null;
|
|
variable.StatusCode = StatusCodes.BadNotSupported;
|
|
|
|
if (StatusCode.IsBad(results[ii].StatusCode) || results[ii].Targets.Count == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (results[ii].Targets[0].RemainingPathIndex == UInt32.MaxValue && !results[ii].Targets[0].TargetId.IsAbsolute)
|
|
{
|
|
variable.NodeId = (NodeId)results[ii].Targets[0].TargetId;
|
|
|
|
ReadValueId valueToRead = new ReadValueId();
|
|
valueToRead.NodeId = variable.NodeId;
|
|
valueToRead.AttributeId = Attributes.Value;
|
|
valueToRead.Handle = variable;
|
|
valuesToRead.Add(valueToRead);
|
|
}
|
|
}
|
|
|
|
// read the values.
|
|
if (valuesToRead.Count > 0)
|
|
{
|
|
DataValueCollection values = null;
|
|
|
|
m_session.Read(
|
|
null,
|
|
0,
|
|
TimestampsToReturn.Neither,
|
|
valuesToRead,
|
|
out values,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(values, valuesToRead);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToRead);
|
|
|
|
for (int ii = 0; ii < valuesToRead.Count; ii++)
|
|
{
|
|
BaseVariableState variable = (BaseVariableState)valuesToRead[ii].Handle;
|
|
variable.WrappedValue = values[ii].WrappedValue;
|
|
variable.StatusCode = values[ii].StatusCode;
|
|
}
|
|
}
|
|
|
|
return configuration;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the first date in the archive (truncates milliseconds and converts to local).
|
|
/// </summary>
|
|
private DateTime ReadFirstDate()
|
|
{
|
|
// use the historical data configuration if available.
|
|
if (m_configuration != null)
|
|
{
|
|
if (StatusCode.IsGood(m_configuration.StartOfOnlineArchive.StatusCode))
|
|
{
|
|
return m_configuration.StartOfOnlineArchive.Value.ToLocalTime();
|
|
}
|
|
|
|
if (StatusCode.IsGood(m_configuration.StartOfArchive.StatusCode))
|
|
{
|
|
return m_configuration.StartOfArchive.Value.ToLocalTime();
|
|
}
|
|
}
|
|
|
|
// do it the hard way (may take a long time with some servers).
|
|
ReadRawModifiedDetails details = new ReadRawModifiedDetails();
|
|
details.StartTime = new DateTime(1970, 1, 1);
|
|
details.EndTime = DateTime.MinValue;
|
|
details.NumValuesPerNode = 1;
|
|
details.IsReadModified = false;
|
|
details.ReturnBounds = false;
|
|
|
|
HistoryReadValueId nodeToRead = new HistoryReadValueId();
|
|
nodeToRead.NodeId = m_nodeId;
|
|
|
|
HistoryReadValueIdCollection nodesToRead = new HistoryReadValueIdCollection();
|
|
nodesToRead.Add(nodeToRead);
|
|
|
|
HistoryReadResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(details),
|
|
TimestampsToReturn.Source,
|
|
false,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
Session.ValidateResponse(results, nodesToRead);
|
|
Session.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
HistoryData data = ExtensionObject.ToEncodeable(results[0].HistoryData) as HistoryData;
|
|
|
|
if (results == null)
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
DateTime startTime = data.DataValues[0].SourceTimestamp;
|
|
|
|
if (results[0].ContinuationPoint != null && results[0].ContinuationPoint.Length > 0)
|
|
{
|
|
nodeToRead.ContinuationPoint = results[0].ContinuationPoint;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(details),
|
|
TimestampsToReturn.Source,
|
|
true,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
Session.ValidateResponse(results, nodesToRead);
|
|
Session.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
}
|
|
|
|
startTime = new DateTime(startTime.Year, startTime.Month, startTime.Day, startTime.Hour, startTime.Minute, startTime.Second, 0, DateTimeKind.Utc);
|
|
startTime = startTime.ToLocalTime();
|
|
|
|
return startTime;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the last date in the archive (truncates milliseconds and converts to local).
|
|
/// </summary>
|
|
private DateTime ReadLastDate()
|
|
{
|
|
ReadRawModifiedDetails details = new ReadRawModifiedDetails();
|
|
details.StartTime = DateTime.MinValue;
|
|
details.EndTime = DateTime.UtcNow.AddDays(1);
|
|
details.NumValuesPerNode = 1;
|
|
details.IsReadModified = false;
|
|
details.ReturnBounds = false;
|
|
|
|
HistoryReadValueId nodeToRead = new HistoryReadValueId();
|
|
nodeToRead.NodeId = m_nodeId;
|
|
|
|
HistoryReadValueIdCollection nodesToRead = new HistoryReadValueIdCollection();
|
|
nodesToRead.Add(nodeToRead);
|
|
|
|
HistoryReadResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(details),
|
|
TimestampsToReturn.Source,
|
|
false,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
Session.ValidateResponse(results, nodesToRead);
|
|
Session.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
HistoryData data = ExtensionObject.ToEncodeable(results[0].HistoryData) as HistoryData;
|
|
|
|
if (data == null || data.DataValues.Count == 0)
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
DateTime endTime = data.DataValues[0].SourceTimestamp;
|
|
|
|
if (results[0].ContinuationPoint != null && results[0].ContinuationPoint.Length > 0)
|
|
{
|
|
nodeToRead.ContinuationPoint = results[0].ContinuationPoint;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(details),
|
|
TimestampsToReturn.Source,
|
|
true,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
Session.ValidateResponse(results, nodesToRead);
|
|
Session.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
}
|
|
|
|
endTime = new DateTime(endTime.Year, endTime.Month, endTime.Day, endTime.Hour, endTime.Minute, endTime.Second, 0, DateTimeKind.Utc);
|
|
endTime = endTime.AddSeconds(1);
|
|
endTime = endTime.ToLocalTime();
|
|
|
|
return endTime;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the subscription.
|
|
/// </summary>
|
|
private void CreateSubscription()
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_subscription = new Subscription();
|
|
m_subscription.Handle = this;
|
|
m_subscription.DisplayName = null;
|
|
m_subscription.PublishingInterval = 1000;
|
|
m_subscription.KeepAliveCount = 10;
|
|
m_subscription.LifetimeCount = 100;
|
|
m_subscription.MaxNotificationsPerPublish = 1000;
|
|
m_subscription.PublishingEnabled = true;
|
|
m_subscription.TimestampsToReturn = TimestampsToReturn.Both;
|
|
|
|
m_session.AddSubscription(m_subscription);
|
|
m_subscription.Create();
|
|
|
|
m_monitoredItem = new MonitoredItem();
|
|
m_monitoredItem.StartNodeId = m_nodeId;
|
|
m_monitoredItem.AttributeId = Attributes.Value;
|
|
m_monitoredItem.SamplingInterval = (int)SamplingIntervalNP.Value;
|
|
m_monitoredItem.QueueSize = 1000;
|
|
m_monitoredItem.DiscardOldest = true;
|
|
|
|
// specify aggregate filter.
|
|
if (AggregateCB.SelectedItem != null)
|
|
{
|
|
AggregateFilter filter = new AggregateFilter();
|
|
|
|
if (StartTimeCK.Checked)
|
|
{
|
|
filter.StartTime = StartTimeDP.Value.ToUniversalTime();
|
|
}
|
|
else
|
|
{
|
|
filter.StartTime = DateTime.UtcNow;
|
|
}
|
|
|
|
filter.ProcessingInterval = (double)ProcessingIntervalNP.Value;
|
|
filter.AggregateType = ((AvailableAggregate)AggregateCB.SelectedItem).NodeId;
|
|
|
|
if (filter.AggregateType != null)
|
|
{
|
|
m_monitoredItem.Filter = filter;
|
|
}
|
|
}
|
|
|
|
m_monitoredItem.Notification += new MonitoredItemNotificationEventHandler(MonitoredItem_Notification);
|
|
|
|
m_subscription.AddItem(m_monitoredItem);
|
|
m_subscription.ApplyChanges();
|
|
SubscriptionStateChanged();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the subscription.
|
|
/// </summary>
|
|
private void DeleteSubscription()
|
|
{
|
|
if (m_subscription != null)
|
|
{
|
|
m_subscription.Delete(true);
|
|
m_session.RemoveSubscription(m_subscription);
|
|
m_subscription = null;
|
|
m_monitoredItem = null;
|
|
}
|
|
|
|
SubscriptionStateChanged();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the controls after the subscription state changes.
|
|
/// </summary>
|
|
private void SubscriptionStateChanged()
|
|
{
|
|
if (m_monitoredItem != null)
|
|
{
|
|
if (ServiceResult.IsBad(m_monitoredItem.Status.Error))
|
|
{
|
|
StatusTB.Text = m_monitoredItem.Status.Error.ToString();
|
|
return;
|
|
}
|
|
|
|
StatusTB.Text = "Monitoring started.";
|
|
m_isSubscribed = true;
|
|
GoBTN.Enabled = false;
|
|
GoBTN.Visible = true;
|
|
StopBTN.Enabled = true;
|
|
NextBTN.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
StatusTB.Text = "Monitoring stopped.";
|
|
m_isSubscribed = false;
|
|
GoBTN.Enabled = true;
|
|
GoBTN.Visible = true;
|
|
StopBTN.Enabled = false;
|
|
NextBTN.Visible = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a value to the grid.
|
|
/// </summary>
|
|
private void AddValue(DataValue value, ModificationInfo modificationInfo)
|
|
{
|
|
DataRow row = m_dataset.Tables[0].NewRow();
|
|
|
|
m_nextId += 10000;
|
|
|
|
row[0] = m_nextId;
|
|
UpdateRow(row, value, modificationInfo);
|
|
|
|
m_dataset.Tables[0].Rows.Add(row);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates a value in the grid.
|
|
/// </summary>
|
|
private void UpdateRow(DataRow row, DataValue value, ModificationInfo modificationInfo)
|
|
{
|
|
row[1] = value.SourceTimestamp.ToLocalTime().ToString("HH:mm:ss.fff");
|
|
row[2] = value.ServerTimestamp.ToLocalTime().ToString("HH:mm:ss.fff");
|
|
row[3] = value.WrappedValue;
|
|
row[4] = new StatusCode(value.StatusCode.Code);
|
|
row[5] = value.StatusCode.AggregateBits.ToString();
|
|
|
|
if (modificationInfo != null)
|
|
{
|
|
row[6] = modificationInfo.UpdateType;
|
|
row[7] = modificationInfo.ModificationTime.ToLocalTime().ToString("HH:mm:ss");
|
|
row[8] = modificationInfo.UserName;
|
|
}
|
|
|
|
row[9] = value;
|
|
}
|
|
|
|
/// <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();
|
|
|
|
if (ResultsDV.Rows.Count > 0)
|
|
{
|
|
ResultsDV.FirstDisplayedCell = ResultsDV.Rows[ResultsDV.Rows.Count - 1].Cells[0];
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the next batch of history.
|
|
/// </summary>
|
|
private void ReadNext()
|
|
{
|
|
if (m_nodeToContinue == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
HistoryReadValueIdCollection nodesToRead = new HistoryReadValueIdCollection();
|
|
nodesToRead.Add(m_nodeToContinue);
|
|
|
|
HistoryReadResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(m_details),
|
|
TimestampsToReturn.Both,
|
|
false,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToRead);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
throw new ServiceResultException(results[0].StatusCode);
|
|
}
|
|
|
|
HistoryData values = ExtensionObject.ToEncodeable(results[0].HistoryData) as HistoryData;
|
|
DisplayResults(values);
|
|
|
|
// save any continuation point.
|
|
SaveContinuationPoint(m_details, m_nodeToContinue, results[0].ContinuationPoint);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the currently selected historical variable or property node id.
|
|
/// </summary>
|
|
private NodeId GetSelectedNode()
|
|
{
|
|
if (PropertyCB.SelectedIndex >= 0)
|
|
{
|
|
return ((PropertyWithHistory)PropertyCB.SelectedItem).NodeId;
|
|
}
|
|
|
|
return m_nodeId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the recent history.
|
|
/// </summary>
|
|
private void ReadRaw(bool isReadModified)
|
|
{
|
|
m_dataset.Clear();
|
|
|
|
ReadRawModifiedDetails details = new ReadRawModifiedDetails();
|
|
details.StartTime =(StartTimeCK.Checked)?StartTimeDP.Value.ToUniversalTime():DateTime.MinValue;
|
|
details.EndTime = (EndTimeCK.Checked)?EndTimeDP.Value.ToUniversalTime():DateTime.MinValue;
|
|
details.NumValuesPerNode = (MaxReturnValuesCK.Checked)?(uint)MaxReturnValuesNP.Value:0;
|
|
details.IsReadModified = isReadModified;
|
|
details.ReturnBounds = (isReadModified)?false:ReturnBoundsCK.Checked;
|
|
|
|
HistoryReadValueIdCollection nodesToRead = new HistoryReadValueIdCollection();
|
|
HistoryReadValueId nodeToRead = new HistoryReadValueId();
|
|
nodeToRead.NodeId = GetSelectedNode();
|
|
nodesToRead.Add(nodeToRead);
|
|
|
|
HistoryReadResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(details),
|
|
TimestampsToReturn.Both,
|
|
false,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToRead);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
throw new ServiceResultException(results[0].StatusCode);
|
|
}
|
|
|
|
HistoryData values = ExtensionObject.ToEncodeable(results[0].HistoryData) as HistoryData;
|
|
DisplayResults(values);
|
|
|
|
// save any continuation point.
|
|
SaveContinuationPoint(details, nodeToRead, results[0].ContinuationPoint);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the recent history.
|
|
/// </summary>
|
|
private void ReadAtTime()
|
|
{
|
|
m_dataset.Clear();
|
|
|
|
ReadAtTimeDetails details = new ReadAtTimeDetails();
|
|
details.UseSimpleBounds = UseSimpleBoundsCK.Checked;
|
|
|
|
// generate times
|
|
DateTime startTime = StartTimeDP.Value.ToUniversalTime();
|
|
|
|
for (int ii = 0; ii < MaxReturnValuesNP.Value; ii++)
|
|
{
|
|
details.ReqTimes.Add(startTime.AddMilliseconds((double)(ii*TimeStepNP.Value)));
|
|
}
|
|
|
|
HistoryReadValueIdCollection nodesToRead = new HistoryReadValueIdCollection();
|
|
HistoryReadValueId nodeToRead = new HistoryReadValueId();
|
|
nodeToRead.NodeId = GetSelectedNode();
|
|
nodesToRead.Add(nodeToRead);
|
|
|
|
HistoryReadResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(details),
|
|
TimestampsToReturn.Both,
|
|
false,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToRead);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
throw new ServiceResultException(results[0].StatusCode);
|
|
}
|
|
|
|
HistoryData values = ExtensionObject.ToEncodeable(results[0].HistoryData) as HistoryData;
|
|
DisplayResults(values);
|
|
|
|
// save any continuation point.
|
|
SaveContinuationPoint(details, nodeToRead, results[0].ContinuationPoint);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fetches the recent history.
|
|
/// </summary>
|
|
private void ReadProcessed()
|
|
{
|
|
m_dataset.Clear();
|
|
|
|
AvailableAggregate aggregate = (AvailableAggregate)AggregateCB.SelectedItem;
|
|
|
|
if (aggregate == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ReadProcessedDetails details = new ReadProcessedDetails();
|
|
details.StartTime = StartTimeDP.Value.ToUniversalTime();
|
|
details.EndTime = EndTimeDP.Value.ToUniversalTime();
|
|
details.ProcessingInterval = (double)ProcessingIntervalNP.Value;
|
|
details.AggregateType.Add(aggregate.NodeId);
|
|
details.AggregateConfiguration.UseServerCapabilitiesDefaults = true;
|
|
|
|
HistoryReadValueIdCollection nodesToRead = new HistoryReadValueIdCollection();
|
|
HistoryReadValueId nodeToRead = new HistoryReadValueId();
|
|
nodeToRead.NodeId = m_nodeId;
|
|
nodesToRead.Add(nodeToRead);
|
|
|
|
HistoryReadResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(details),
|
|
TimestampsToReturn.Both,
|
|
false,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToRead);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
throw new ServiceResultException(results[0].StatusCode);
|
|
}
|
|
|
|
HistoryData values = ExtensionObject.ToEncodeable(results[0].HistoryData) as HistoryData;
|
|
DisplayResults(values);
|
|
|
|
// save any continuation point.
|
|
SaveContinuationPoint(details, nodeToRead, results[0].ContinuationPoint);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves a continuation point for later use.
|
|
/// </summary>
|
|
private void SaveContinuationPoint(HistoryReadDetails details, HistoryReadValueId nodeToRead, byte[] continuationPoint)
|
|
{
|
|
// clear existing continuation point.
|
|
if (m_nodeToContinue != null)
|
|
{
|
|
HistoryReadValueIdCollection nodesToRead = new HistoryReadValueIdCollection();
|
|
nodesToRead.Add(m_nodeToContinue);
|
|
|
|
HistoryReadResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryRead(
|
|
null,
|
|
new ExtensionObject(m_details),
|
|
TimestampsToReturn.Neither,
|
|
true,
|
|
nodesToRead,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToRead);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
|
|
}
|
|
|
|
m_details = null;
|
|
m_nodeToContinue = null;
|
|
|
|
// save new continutation point.
|
|
if (continuationPoint != null && continuationPoint.Length > 0)
|
|
{
|
|
m_details = details;
|
|
m_nodeToContinue = nodeToRead;
|
|
m_nodeToContinue.ContinuationPoint = continuationPoint;
|
|
}
|
|
|
|
// update controls.
|
|
if (m_nodeToContinue != null)
|
|
{
|
|
GoBTN.Visible = false;
|
|
NextBTN.Visible = true;
|
|
NextBTN.Enabled = true;
|
|
StopBTN.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
GoBTN.Visible = true;
|
|
GoBTN.Enabled = true;
|
|
NextBTN.Visible = false;
|
|
StopBTN.Enabled = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the history.
|
|
/// </summary>
|
|
private void InsertReplace(PerformUpdateType updateType)
|
|
{
|
|
DataValueCollection values = new DataValueCollection();
|
|
|
|
foreach (DataRowView row in m_dataset.Tables[0].DefaultView)
|
|
{
|
|
DataValue value = (DataValue)row.Row[9];
|
|
values.Add(value);
|
|
}
|
|
|
|
bool isStructured = false;
|
|
|
|
PropertyWithHistory property = PropertyCB.SelectedItem as PropertyWithHistory;
|
|
|
|
if (property != null && property.BrowseName == Opc.Ua.BrowseNames.Annotations)
|
|
{
|
|
isStructured = true;
|
|
}
|
|
|
|
HistoryUpdateResultCollection results = InsertReplace(GetSelectedNode(), updateType, isStructured, values);
|
|
|
|
ResultsDV.Columns[ResultsDV.Columns.Count - 1].Visible = true;
|
|
|
|
for (int ii = 0; ii < m_dataset.Tables[0].DefaultView.Count; ii++)
|
|
{
|
|
m_dataset.Tables[0].DefaultView[ii].Row[10] = results[0].OperationResults[ii];
|
|
}
|
|
|
|
m_dataset.AcceptChanges();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the history.
|
|
/// </summary>
|
|
private HistoryUpdateResultCollection InsertReplace(NodeId nodeId, PerformUpdateType updateType, bool isStructure, IList<DataValue> values)
|
|
{
|
|
HistoryUpdateDetails details = null;
|
|
|
|
if (isStructure)
|
|
{
|
|
UpdateStructureDataDetails details2 = new UpdateStructureDataDetails();
|
|
details2.NodeId = nodeId;
|
|
details2.PerformInsertReplace = updateType;
|
|
details2.UpdateValues.AddRange(values);
|
|
details = details2;
|
|
}
|
|
else
|
|
{
|
|
UpdateDataDetails details2 = new UpdateDataDetails();
|
|
details2.NodeId = nodeId;
|
|
details2.PerformInsertReplace = updateType;
|
|
details2.UpdateValues.AddRange(values);
|
|
details = details2;
|
|
}
|
|
|
|
ExtensionObjectCollection nodesToUpdate = new ExtensionObjectCollection();
|
|
nodesToUpdate.Add(new ExtensionObject(details));
|
|
|
|
HistoryUpdateResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryUpdate(
|
|
null,
|
|
nodesToUpdate,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToUpdate);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToUpdate);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
throw new ServiceResultException(results[0].StatusCode);
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the block of data.
|
|
/// </summary>
|
|
private void DeleteRaw(bool isModified)
|
|
{
|
|
DeleteRawModifiedDetails details = new DeleteRawModifiedDetails();
|
|
details.NodeId = m_nodeId;
|
|
details.IsDeleteModified = isModified;
|
|
details.StartTime = StartTimeDP.Value;
|
|
details.EndTime = EndTimeDP.Value;
|
|
|
|
ExtensionObjectCollection nodesToUpdate = new ExtensionObjectCollection();
|
|
nodesToUpdate.Add(new ExtensionObject(details));
|
|
|
|
HistoryUpdateResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryUpdate(
|
|
null,
|
|
nodesToUpdate,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToUpdate);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToUpdate);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
throw new ServiceResultException(results[0].StatusCode);
|
|
}
|
|
|
|
ResultsDV.Columns[ResultsDV.Columns.Count - 1].Visible = false;
|
|
m_dataset.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes the history.
|
|
/// </summary>
|
|
private void DeleteAtTime()
|
|
{
|
|
DeleteAtTimeDetails details = new DeleteAtTimeDetails();
|
|
details.NodeId = m_nodeId;
|
|
|
|
foreach (DataRowView row in m_dataset.Tables[0].DefaultView)
|
|
{
|
|
DateTime value = (DateTime)row.Row[1];
|
|
details.ReqTimes.Add(value);
|
|
}
|
|
|
|
ExtensionObjectCollection nodesToUpdate = new ExtensionObjectCollection();
|
|
nodesToUpdate.Add(new ExtensionObject(details));
|
|
|
|
HistoryUpdateResultCollection results = null;
|
|
DiagnosticInfoCollection diagnosticInfos = null;
|
|
|
|
m_session.HistoryUpdate(
|
|
null,
|
|
nodesToUpdate,
|
|
out results,
|
|
out diagnosticInfos);
|
|
|
|
ClientBase.ValidateResponse(results, nodesToUpdate);
|
|
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToUpdate);
|
|
|
|
if (StatusCode.IsBad(results[0].StatusCode))
|
|
{
|
|
throw new ServiceResultException(results[0].StatusCode);
|
|
}
|
|
|
|
ResultsDV.Columns[ResultsDV.Columns.Count-1].Visible = true;
|
|
|
|
for (int ii = 0; ii < m_dataset.Tables[0].DefaultView.Count; ii++)
|
|
{
|
|
m_dataset.Tables[0].DefaultView[ii].Row[10] = results[0].OperationResults[ii];
|
|
}
|
|
|
|
m_dataset.AcceptChanges();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the results of a history operation.
|
|
/// </summary>
|
|
private void DisplayResults(HistoryData values)
|
|
{
|
|
HistoryModifiedData modifiedData = values as HistoryModifiedData;
|
|
|
|
if (modifiedData != null)
|
|
{
|
|
ResultsDV.Columns[5].Visible = true;
|
|
ResultsDV.Columns[6].Visible = true;
|
|
ResultsDV.Columns[7].Visible = true;
|
|
ResultsDV.Columns[8].Visible = false;
|
|
|
|
for (int ii = 0; ii < modifiedData.DataValues.Count; ii++)
|
|
{
|
|
AddValue(modifiedData.DataValues[ii], modifiedData.ModificationInfos[ii]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ResultsDV.Columns[5].Visible = false;
|
|
ResultsDV.Columns[6].Visible = false;
|
|
ResultsDV.Columns[7].Visible = false;
|
|
ResultsDV.Columns[8].Visible = false;
|
|
|
|
if (values != null)
|
|
{
|
|
foreach (DataValue value in values.DataValues)
|
|
{
|
|
AddValue(value, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_dataset.AcceptChanges();
|
|
}
|
|
|
|
private void NodeIdBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ReferenceDescription reference = new SelectNodeDlg().ShowDialog(
|
|
m_session,
|
|
Opc.Ua.ObjectIds.ObjectsFolder,
|
|
null,
|
|
"Select Variable",
|
|
Opc.Ua.ReferenceTypeIds.Organizes,
|
|
Opc.Ua.ReferenceTypeIds.Aggregates);
|
|
|
|
if (reference == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (reference.NodeId != m_nodeId)
|
|
{
|
|
ChangeNode((NodeId)reference.NodeId);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void SubscribeCK_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_session != null)
|
|
{
|
|
if (m_isSubscribed)
|
|
{
|
|
CreateSubscription();
|
|
}
|
|
else
|
|
{
|
|
DeleteSubscription();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void GoBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
m_dataset.Tables[0].Rows.Clear();
|
|
|
|
switch ((HistoryReadType)ReadTypeCB.SelectedItem)
|
|
{
|
|
case HistoryReadType.Subscribe:
|
|
{
|
|
CreateSubscription();
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Raw:
|
|
{
|
|
ReadRaw(false);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Modified:
|
|
{
|
|
ReadRaw(true);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Processed:
|
|
{
|
|
ReadProcessed();
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.AtTime:
|
|
{
|
|
ReadAtTime();
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Insert:
|
|
{
|
|
InsertReplace(PerformUpdateType.Insert);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Replace:
|
|
{
|
|
InsertReplace(PerformUpdateType.Replace);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.InsertReplace:
|
|
{
|
|
InsertReplace(PerformUpdateType.Update);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Remove:
|
|
{
|
|
InsertReplace(PerformUpdateType.Remove);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.DeleteRaw:
|
|
{
|
|
DeleteRaw(false);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.DeleteModified:
|
|
{
|
|
DeleteRaw(true);
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.DeleteAtTime:
|
|
{
|
|
DeleteAtTime();
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void NextBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
ReadNext();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void StopBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
DeleteSubscription();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void ReadTypeCB_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
HistoryReadType readType = (HistoryReadType)ReadTypeCB.SelectedItem;
|
|
|
|
switch (readType)
|
|
{
|
|
case HistoryReadType.Subscribe:
|
|
{
|
|
PropertyLB.Visible = false;
|
|
PropertyCB.Visible = false;
|
|
SamplingIntervalLB.Visible = true;
|
|
SamplingIntervalNP.Visible = true;
|
|
SamplingIntervalUnitsLB.Visible = true;
|
|
StartTimeLB.Visible = true;
|
|
StartTimeDP.Visible = true;
|
|
StartTimeCK.Visible = true;
|
|
StartTimeCK.Enabled = true;
|
|
StartTimeCK.Checked = false;
|
|
EndTimeLB.Visible = false;
|
|
EndTimeDP.Visible = false;
|
|
EndTimeCK.Visible = false;
|
|
MaxReturnValuesLB.Visible = false;
|
|
MaxReturnValuesNP.Visible = false;
|
|
MaxReturnValuesCK.Visible = false;
|
|
ReturnBoundsLB.Visible = false;
|
|
ReturnBoundsCK.Visible = false;
|
|
AggregateLB.Visible = true;
|
|
AggregateCB.Visible = true;
|
|
ResampleIntervalLB.Visible = true;
|
|
ProcessingIntervalNP.Visible = true;
|
|
ResampleIntervalUnitsLB.Visible = true;
|
|
TimeStepLB.Visible = false;
|
|
TimeStepNP.Visible = false;
|
|
TimeStepUnitsLB.Visible = false;
|
|
UseSimpleBoundsLB.Visible = false;
|
|
UseSimpleBoundsCK.Visible = false;
|
|
TimeShiftBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Raw:
|
|
{
|
|
PropertyLB.Visible = (m_properties != null && m_properties.Count > 1);
|
|
PropertyCB.Visible = (m_properties != null && m_properties.Count > 1);
|
|
SamplingIntervalLB.Visible = false;
|
|
SamplingIntervalNP.Visible = false;
|
|
SamplingIntervalUnitsLB.Visible = false;
|
|
StartTimeLB.Visible = true;
|
|
StartTimeDP.Visible = true;
|
|
StartTimeCK.Visible = true;
|
|
StartTimeCK.Enabled = true;
|
|
StartTimeCK.Checked = true;
|
|
EndTimeLB.Visible = true;
|
|
EndTimeDP.Visible = true;
|
|
EndTimeCK.Visible = true;
|
|
EndTimeCK.Enabled = true;
|
|
MaxReturnValuesLB.Visible = true;
|
|
MaxReturnValuesNP.Visible = true;
|
|
MaxReturnValuesCK.Visible = true;
|
|
MaxReturnValuesCK.Enabled = true;
|
|
MaxReturnValuesCK.Checked = true;
|
|
ReturnBoundsLB.Visible = true;
|
|
ReturnBoundsCK.Visible = true;
|
|
AggregateLB.Visible = false;
|
|
AggregateCB.Visible = false;
|
|
ResampleIntervalLB.Visible = false;
|
|
ProcessingIntervalNP.Visible = false;
|
|
ResampleIntervalUnitsLB.Visible = false;
|
|
TimeStepLB.Visible = false;
|
|
TimeStepNP.Visible = false;
|
|
TimeStepUnitsLB.Visible = false;
|
|
UseSimpleBoundsLB.Visible = false;
|
|
UseSimpleBoundsCK.Visible = false;
|
|
TimeShiftBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Modified:
|
|
{
|
|
PropertyLB.Visible = false;
|
|
PropertyCB.Visible = false;
|
|
SamplingIntervalLB.Visible = false;
|
|
SamplingIntervalNP.Visible = false;
|
|
SamplingIntervalUnitsLB.Visible = false;
|
|
StartTimeLB.Visible = true;
|
|
StartTimeDP.Visible = true;
|
|
StartTimeCK.Visible = true;
|
|
StartTimeCK.Enabled = true;
|
|
StartTimeCK.Checked = true;
|
|
EndTimeLB.Visible = true;
|
|
EndTimeDP.Visible = true;
|
|
EndTimeCK.Visible = true;
|
|
EndTimeCK.Enabled = true;
|
|
MaxReturnValuesLB.Visible = true;
|
|
MaxReturnValuesNP.Visible = true;
|
|
MaxReturnValuesCK.Visible = true;
|
|
MaxReturnValuesCK.Enabled = true;
|
|
MaxReturnValuesCK.Checked = true;
|
|
ReturnBoundsLB.Visible = false;
|
|
ReturnBoundsCK.Visible = false;
|
|
AggregateLB.Visible = false;
|
|
AggregateCB.Visible = false;
|
|
ResampleIntervalLB.Visible = false;
|
|
ProcessingIntervalNP.Visible = false;
|
|
ResampleIntervalUnitsLB.Visible = false;
|
|
TimeStepLB.Visible = false;
|
|
TimeStepNP.Visible = false;
|
|
TimeStepUnitsLB.Visible = false;
|
|
UseSimpleBoundsLB.Visible = false;
|
|
UseSimpleBoundsCK.Visible = false;
|
|
TimeShiftBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Processed:
|
|
{
|
|
PropertyLB.Visible = false;
|
|
PropertyCB.Visible = false;
|
|
SamplingIntervalLB.Visible = false;
|
|
SamplingIntervalNP.Visible = false;
|
|
SamplingIntervalUnitsLB.Visible = false;
|
|
StartTimeLB.Visible = true;
|
|
StartTimeDP.Visible = true;
|
|
StartTimeCK.Visible = true;
|
|
StartTimeCK.Enabled = false;
|
|
StartTimeCK.Checked = true;
|
|
EndTimeLB.Visible = true;
|
|
EndTimeDP.Visible = true;
|
|
EndTimeCK.Visible = true;
|
|
EndTimeCK.Enabled = false;
|
|
EndTimeCK.Checked = true;
|
|
MaxReturnValuesLB.Visible = false;
|
|
MaxReturnValuesNP.Visible = false;
|
|
MaxReturnValuesCK.Visible = false;
|
|
ReturnBoundsLB.Visible = false;
|
|
ReturnBoundsCK.Visible = false;
|
|
AggregateLB.Visible = true;
|
|
AggregateCB.Visible = true;
|
|
ResampleIntervalLB.Visible = true;
|
|
ProcessingIntervalNP.Visible = true;
|
|
ResampleIntervalUnitsLB.Visible = true;
|
|
TimeStepLB.Visible = false;
|
|
TimeStepNP.Visible = false;
|
|
TimeStepUnitsLB.Visible = false;
|
|
UseSimpleBoundsLB.Visible = false;
|
|
UseSimpleBoundsCK.Visible = false;
|
|
TimeShiftBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.AtTime:
|
|
{
|
|
PropertyLB.Visible = (m_properties != null && m_properties.Count > 1);
|
|
PropertyCB.Visible = (m_properties != null && m_properties.Count > 1);
|
|
SamplingIntervalLB.Visible = false;
|
|
SamplingIntervalNP.Visible = false;
|
|
SamplingIntervalUnitsLB.Visible = false;
|
|
StartTimeLB.Visible = true;
|
|
StartTimeDP.Visible = true;
|
|
StartTimeCK.Visible = true;
|
|
StartTimeCK.Enabled = false;
|
|
StartTimeCK.Checked = true;
|
|
EndTimeLB.Visible = false;
|
|
EndTimeDP.Visible = false;
|
|
EndTimeCK.Visible = false;
|
|
EndTimeCK.Enabled = false;
|
|
EndTimeCK.Checked = false;
|
|
MaxReturnValuesLB.Visible = true;
|
|
MaxReturnValuesNP.Visible = true;
|
|
MaxReturnValuesCK.Visible = true;
|
|
MaxReturnValuesCK.Enabled = false;
|
|
MaxReturnValuesCK.Checked = true;
|
|
ReturnBoundsLB.Visible = false;
|
|
ReturnBoundsCK.Visible = false;
|
|
AggregateLB.Visible = false;
|
|
AggregateCB.Visible = false;
|
|
ResampleIntervalLB.Visible = false;
|
|
ProcessingIntervalNP.Visible = false;
|
|
ResampleIntervalUnitsLB.Visible = false;
|
|
TimeStepLB.Visible = true;
|
|
TimeStepNP.Visible = true;
|
|
TimeStepUnitsLB.Visible = true;
|
|
UseSimpleBoundsLB.Visible = true;
|
|
UseSimpleBoundsCK.Visible = true;
|
|
TimeShiftBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.Insert:
|
|
case HistoryReadType.InsertReplace:
|
|
case HistoryReadType.Replace:
|
|
case HistoryReadType.Remove:
|
|
{
|
|
PropertyLB.Visible = (m_properties != null && m_properties.Count > 1);
|
|
PropertyCB.Visible = (m_properties != null && m_properties.Count > 1);
|
|
SamplingIntervalLB.Visible = false;
|
|
SamplingIntervalNP.Visible = false;
|
|
SamplingIntervalUnitsLB.Visible = false;
|
|
StartTimeLB.Visible = false;
|
|
StartTimeDP.Visible = false;
|
|
StartTimeCK.Visible = false;
|
|
StartTimeCK.Enabled = false;
|
|
StartTimeCK.Checked = false;
|
|
EndTimeLB.Visible = false;
|
|
EndTimeDP.Visible = false;
|
|
EndTimeCK.Visible = false;
|
|
EndTimeCK.Enabled = false;
|
|
EndTimeCK.Checked = false;
|
|
MaxReturnValuesLB.Visible = false;
|
|
MaxReturnValuesNP.Visible = false;
|
|
MaxReturnValuesCK.Visible = false;
|
|
MaxReturnValuesCK.Enabled = false;
|
|
MaxReturnValuesCK.Checked = false;
|
|
ReturnBoundsLB.Visible = false;
|
|
ReturnBoundsCK.Visible = false;
|
|
AggregateLB.Visible = false;
|
|
AggregateCB.Visible = false;
|
|
ResampleIntervalLB.Visible = false;
|
|
ProcessingIntervalNP.Visible = false;
|
|
ResampleIntervalUnitsLB.Visible = false;
|
|
TimeStepLB.Visible = true;
|
|
TimeStepNP.Visible = true;
|
|
TimeStepUnitsLB.Visible = true;
|
|
UseSimpleBoundsLB.Visible = false;
|
|
UseSimpleBoundsCK.Visible = false;
|
|
TimeShiftBTN.Visible = true;
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.DeleteAtTime:
|
|
{
|
|
PropertyLB.Visible = false;
|
|
PropertyCB.Visible = false;
|
|
SamplingIntervalLB.Visible = false;
|
|
SamplingIntervalNP.Visible = false;
|
|
SamplingIntervalUnitsLB.Visible = false;
|
|
StartTimeLB.Visible = false;
|
|
StartTimeDP.Visible = false;
|
|
StartTimeCK.Visible = false;
|
|
StartTimeCK.Enabled = false;
|
|
StartTimeCK.Checked = false;
|
|
EndTimeLB.Visible = false;
|
|
EndTimeDP.Visible = false;
|
|
EndTimeCK.Visible = false;
|
|
EndTimeCK.Enabled = false;
|
|
EndTimeCK.Checked = false;
|
|
MaxReturnValuesLB.Visible = false;
|
|
MaxReturnValuesNP.Visible = false;
|
|
MaxReturnValuesCK.Visible = false;
|
|
MaxReturnValuesCK.Enabled = false;
|
|
MaxReturnValuesCK.Checked = false;
|
|
ReturnBoundsLB.Visible = false;
|
|
ReturnBoundsCK.Visible = false;
|
|
AggregateLB.Visible = false;
|
|
AggregateCB.Visible = false;
|
|
ResampleIntervalLB.Visible = false;
|
|
ProcessingIntervalNP.Visible = false;
|
|
ResampleIntervalUnitsLB.Visible = false;
|
|
TimeStepLB.Visible = false;
|
|
TimeStepNP.Visible = false;
|
|
TimeStepUnitsLB.Visible = false;
|
|
UseSimpleBoundsLB.Visible = false;
|
|
UseSimpleBoundsCK.Visible = false;
|
|
TimeShiftBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case HistoryReadType.DeleteRaw:
|
|
case HistoryReadType.DeleteModified:
|
|
{
|
|
PropertyLB.Visible = false;
|
|
PropertyCB.Visible = false;
|
|
SamplingIntervalLB.Visible = false;
|
|
SamplingIntervalNP.Visible = false;
|
|
SamplingIntervalUnitsLB.Visible = false;
|
|
StartTimeLB.Visible = true;
|
|
StartTimeDP.Visible = true;
|
|
StartTimeCK.Visible = true;
|
|
StartTimeCK.Enabled = false;
|
|
StartTimeCK.Checked = true;
|
|
EndTimeLB.Visible = true;
|
|
EndTimeDP.Visible = true;
|
|
EndTimeCK.Visible = true;
|
|
EndTimeCK.Enabled = false;
|
|
EndTimeCK.Checked = true;
|
|
EndTimeCK.Visible = false;
|
|
MaxReturnValuesNP.Visible = false;
|
|
MaxReturnValuesCK.Visible = false;
|
|
MaxReturnValuesCK.Enabled = false;
|
|
MaxReturnValuesCK.Checked = false;
|
|
ReturnBoundsLB.Visible = false;
|
|
ReturnBoundsCK.Visible = false;
|
|
AggregateLB.Visible = false;
|
|
AggregateCB.Visible = false;
|
|
ResampleIntervalLB.Visible = false;
|
|
ProcessingIntervalNP.Visible = false;
|
|
ResampleIntervalUnitsLB.Visible = false;
|
|
TimeStepLB.Visible = false;
|
|
TimeStepNP.Visible = false;
|
|
TimeStepUnitsLB.Visible = false;
|
|
UseSimpleBoundsLB.Visible = false;
|
|
UseSimpleBoundsCK.Visible = false;
|
|
TimeShiftBTN.Visible = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
private void StartTimeDP_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
m_timesChanged = true;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void DetectLimitsBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
DateTime startTime = ReadFirstDate();
|
|
|
|
if (startTime != DateTime.MinValue)
|
|
{
|
|
StartTimeDP.Value = startTime;
|
|
}
|
|
|
|
DateTime endTime = ReadLastDate();
|
|
|
|
if (endTime != DateTime.MinValue)
|
|
{
|
|
EndTimeDP.Value = endTime;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void StartTimeCK_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
StartTimeDP.Enabled = StartTimeCK.Checked;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void EndTimeCK_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
EndTimeDP.Enabled = EndTimeCK.Checked;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void MaxReturnValuesCK_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
MaxReturnValuesNP.Enabled = MaxReturnValuesCK.Checked;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void TimeShiftBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
foreach (DataRowView row in m_dataset.Tables[0].DefaultView)
|
|
{
|
|
DataValue value = (DataValue)row.Row[9];
|
|
value.SourceTimestamp = value.SourceTimestamp.AddMilliseconds((double)TimeStepNP.Value);
|
|
value.ServerTimestamp = value.ServerTimestamp.AddMilliseconds((double)TimeStepNP.Value);
|
|
|
|
row[1] = value.SourceTimestamp.ToLocalTime().ToString("HH:mm:ss.fff");
|
|
row[2] = value.ServerTimestamp.ToLocalTime().ToString("HH:mm:ss.fff");
|
|
}
|
|
|
|
m_dataset.AcceptChanges();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void InsertAnnotationMI_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
NodeId propertyId = null;
|
|
|
|
if (m_properties != null)
|
|
{
|
|
foreach (PropertyWithHistory property in m_properties)
|
|
{
|
|
if (property.BrowseName == Opc.Ua.BrowseNames.Annotations)
|
|
{
|
|
propertyId = property.NodeId;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (propertyId == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Annotation annotation = new EditAnnotationDlg().ShowDialog(m_session, null, null);
|
|
|
|
if (annotation != null)
|
|
{
|
|
List<DataValue> valuesToUpdate = new List<DataValue>();
|
|
|
|
foreach (DataGridViewRow row in ResultsDV.SelectedRows)
|
|
{
|
|
DataRowView source = row.DataBoundItem as DataRowView;
|
|
DataValue value = (DataValue)source.Row[9];
|
|
|
|
}
|
|
|
|
HistoryUpdateResultCollection results = InsertReplace(propertyId, PerformUpdateType.Insert, true, valuesToUpdate);
|
|
|
|
ResultsDV.Columns[ResultsDV.Columns.Count - 1].Visible = true;
|
|
|
|
for (int ii = 0; ii < ResultsDV.SelectedRows.Count; ii++)
|
|
{
|
|
DataGridViewRow row = ResultsDV.SelectedRows[ii];
|
|
DataRowView source = row.DataBoundItem as DataRowView;
|
|
source.Row[10] = results[0].OperationResults[ii];
|
|
}
|
|
|
|
m_dataset.AcceptChanges();
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void EditValueMI_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_session == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (DataGridViewRow row in ResultsDV.SelectedRows)
|
|
{
|
|
DataRowView source = row.DataBoundItem as DataRowView;
|
|
DataValue value = (DataValue)source.Row[9];
|
|
|
|
DataValue newValue = new EditDataValueDlg().ShowDialog(value, null, null);
|
|
|
|
if (newValue == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
UpdateRow(source.Row, newValue, null);
|
|
m_dataset.AcceptChanges();
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void ShowServerTimestampMI_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
ServerTimestampCH.Visible = ShowServerTimestampMI.Checked;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|