/// <summary>
/// Constructs a new instance.
/// </summary>
public DataChangeMonitoredItem(
MonitoredNode source,
uint id,
uint attributeId,
NumericRange indexRange,
QualifiedName dataEncoding,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval,
bool alwaysReportUpdates)
{
m_source = source;
m_id = id;
m_attributeId = attributeId;
m_indexRange = indexRange;
m_dataEncoding = dataEncoding;
m_timestampsToReturn = timestampsToReturn;
m_diagnosticsMasks = diagnosticsMasks;
m_monitoringMode = monitoringMode;
m_clientHandle = clientHandle;
m_samplingInterval = samplingInterval;
m_nextSampleTime = DateTime.UtcNow.Ticks;
m_readyToPublish = false;
m_readyToTrigger = false;
m_alwaysReportUpdates = alwaysReportUpdates;
}
/// <summary>
/// Applies the diagnostic mask if the object was initialize with a ServiceResult.
/// </summary>
public void ApplyDiagnosticMasks(DiagnosticsMasks diagnosticMasks, StringTable stringTable)
{
if (m_result != null)
{
m_statusCode = m_result.StatusCode;
m_diagnosticInfo = new DiagnosticInfo(m_result, diagnosticMasks, false, stringTable);
}
}
/// <summary>
/// Creates a fault message.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="exception">The exception.</param>
/// <returns>A fault message.</returns>
protected static ServiceFault CreateFault(IServiceRequest request, Exception exception)
{
DiagnosticsMasks diagnosticsMask = DiagnosticsMasks.ServiceNoInnerStatus;
ServiceFault fault = new ServiceFault();
if (request != null)
{
fault.ResponseHeader.Timestamp = DateTime.UtcNow;
fault.ResponseHeader.RequestHandle = request.RequestHeader.RequestHandle;
if (request.RequestHeader != null)
{
diagnosticsMask = (DiagnosticsMasks)request.RequestHeader.ReturnDiagnostics;
}
}
ServiceResult result = null;
ServiceResultException sre = exception as ServiceResultException;
if (sre != null)
{
result = new ServiceResult(sre);
Utils.Trace(
Utils.TraceMasks.Service,
"Service Fault Occured. Reason={0}",
result);
}
else
{
result = new ServiceResult(exception, StatusCodes.BadUnexpectedError);
Utils.Trace(exception, "SERVER - Unexpected Service Fault: {0}", exception.Message);
}
fault.ResponseHeader.ServiceResult = result.Code;
StringTable stringTable = new StringTable();
fault.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
result,
diagnosticsMask,
true,
stringTable);
fault.ResponseHeader.StringTable = stringTable.ToArray();
return(fault);
}
/// <summary>
/// Initializes the object with an exception.
/// </summary>
/// <remarks>
/// Initializes the object with an exception.
/// </remarks>
/// <param name="diagnosticsMask">A bitmask describing the type of diagnostic data</param>
/// <param name="exception">The exception to associated with the diagnostic data</param>
/// <param name="serviceLevel">The service level</param>
/// <param name="stringTable">A table of strings that may contain additional diagnostic data</param>
public DiagnosticInfo(
Exception exception,
DiagnosticsMasks diagnosticsMask,
bool serviceLevel,
StringTable stringTable) {
uint mask = (uint) diagnosticsMask;
if (!serviceLevel) {
mask >>= 5;
}
diagnosticsMask = (DiagnosticsMasks) mask;
Initialize(new ServiceResult(exception), diagnosticsMask, stringTable);
}
/// <summary>
/// Initializes the object with an exception.
/// </summary>
/// <remarks>
/// Initializes the object with an exception.
/// </remarks>
/// <param name="diagnosticsMask">The bitmask describing the diagnostic data</param>
/// <param name="result">The overall transaction result</param>
/// <param name="serviceLevel">The service level</param>
/// <param name="stringTable">A table of strings carrying more diagnostic data</param>
public DiagnosticInfo(
ServiceResult result,
DiagnosticsMasks diagnosticsMask,
bool serviceLevel,
StringTable stringTable) {
uint mask = (uint) diagnosticsMask;
if (!serviceLevel) {
mask >>= 5;
}
diagnosticsMask = (DiagnosticsMasks) mask;
Initialize(result, diagnosticsMask, stringTable);
}
/// <summary>
/// Constructs a new instance.
/// </summary>
public DataChangeMonitoredItem(
MonitoredNode source,
uint id,
uint attributeId,
NumericRange indexRange,
QualifiedName dataEncoding,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval,
uint queueSize,
bool discardOldest,
DataChangeFilter filter,
Range range,
bool alwaysReportUpdates)
{
m_source = source;
m_id = id;
m_attributeId = attributeId;
m_indexRange = indexRange;
m_dataEncoding = dataEncoding;
m_timestampsToReturn = timestampsToReturn;
m_diagnosticsMasks = diagnosticsMasks;
m_monitoringMode = monitoringMode;
m_clientHandle = clientHandle;
m_samplingInterval = samplingInterval;
m_nextSampleTime = DateTime.UtcNow.Ticks;
m_readyToPublish = false;
m_readyToTrigger = false;
m_resendData = false;
m_queue = null;
m_filter = filter;
m_range = 0;
m_alwaysReportUpdates = alwaysReportUpdates;
if (range != null)
{
m_range = range.High - range.Low;
}
if (queueSize > 1)
{
m_queue = new MonitoredItemQueue(id);
m_queue.SetQueueSize(queueSize, discardOldest, diagnosticsMasks);
m_queue.SetSamplingInterval(samplingInterval);
}
}
/// <summary>
/// Modifies the monitored item parameters,
/// </summary>
public ServiceResult Modify(
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
uint clientHandle,
double samplingInterval)
{
return(base.ModifyAttributes(diagnosticsMasks,
timestampsToReturn,
clientHandle,
null,
null,
null,
samplingInterval,
0,
false));
}
/// <summary>
/// Constructs a new instance.
/// </summary>
public DataChangeMonitoredItem(
MonitoredNode source,
uint id,
uint attributeId,
NumericRange indexRange,
QualifiedName dataEncoding,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval,
uint queueSize,
bool discardOldest,
DataChangeFilter filter,
Range range,
bool alwaysReportUpdates)
{
m_source = source;
m_id = id;
m_attributeId = attributeId;
m_indexRange = indexRange;
m_dataEncoding = dataEncoding;
m_timestampsToReturn = timestampsToReturn;
m_diagnosticsMasks = diagnosticsMasks;
m_monitoringMode = monitoringMode;
m_clientHandle = clientHandle;
m_samplingInterval = samplingInterval;
m_nextSampleTime = DateTime.UtcNow.Ticks;
m_readyToPublish = false;
m_readyToTrigger = false;
m_queue = null;
m_filter = filter;
m_range = 0;
m_alwaysReportUpdates = alwaysReportUpdates;
if (range != null)
{
m_range = range.High - range.Low;
}
if (queueSize > 1)
{
m_queue = new MonitoredItemQueue();
m_queue.SetQueueSize(queueSize, discardOldest, diagnosticsMasks);
m_queue.SetSamplingInterval(samplingInterval);
}
}
/// <summary>
/// Creates a new data change monitored item.
/// </summary>
/// <param name="context">The system context.</param>
/// <param name="monitoredItemId">The unique identifier for the monitiored item.</param>
/// <param name="attributeId">The attribute to monitor.</param>
/// <param name="indexRange">The index range to use for array values.</param>
/// <param name="dataEncoding">The data encoding to return for structured values.</param>
/// <param name="diagnosticsMasks">The diagnostics masks to use.</param>
/// <param name="timestampsToReturn">The timestamps to return.</param>
/// <param name="monitoringMode">The initial monitoring mode.</param>
/// <param name="clientHandle">The handle assigned by the client.</param>
/// <param name="samplingInterval">The sampling interval.</param>
/// <param name="queueSize">The queue size.</param>
/// <param name="discardOldest">Whether to discard the oldest values when the queue overflows.</param>
/// <param name="filter">The data change filter to use.</param>
/// <param name="range">The range to use when evaluating a percentage deadband filter.</param>
/// <param name="alwaysReportUpdates">Whether the monitored item should skip the check for a change in value.</param>
/// <returns>The new monitored item.</returns>
public DataChangeMonitoredItem CreateDataChangeItem(
ISystemContext context,
uint monitoredItemId,
uint attributeId,
NumericRange indexRange,
QualifiedName dataEncoding,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval,
uint queueSize,
bool discardOldest,
DataChangeFilter filter,
Range range,
bool alwaysReportUpdates)
{
System.Diagnostics.Contracts.Contract.Assume(context != null);
var monitoredItem = new DataChangeMonitoredItem(
this,
monitoredItemId,
attributeId,
indexRange,
dataEncoding,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
samplingInterval,
queueSize,
discardOldest,
filter,
range,
alwaysReportUpdates);
if (_monitoredItems == null)
{
_monitoredItems = new List <DataChangeMonitoredItem>();
Node.OnStateChanged = OnNodeChange;
}
_monitoredItems.Add(monitoredItem);
return(monitoredItem);
}
private void OkBTN_Click(object sender, EventArgs e)
{
try
{
#region Task #D3 - Change Locale and User Identity
UserIdentity identity = null;
// use the anonymous identity of the user name is not provided.
if (String.IsNullOrEmpty(UserNameTB.Text))
{
identity = new UserIdentity();
}
// could add check for domain name in user name and use a kerberos token instead.
else
{
identity = new UserIdentity(UserNameTB.Text, PasswordTB.Text);
}
// can specify multiple locales but just use one here to keep the UI simple.
StringCollection preferredLocales = new StringCollection();
preferredLocales.Add(LocaleCB.SelectedItem as string);
// override the default diagnostics to get error messages.
DiagnosticsMasks returnDiagnostics = m_session.ReturnDiagnostics;
try
{
// update the session.
m_session.ReturnDiagnostics = DiagnosticsMasks.ServiceSymbolicIdAndText;
m_session.UpdateSession(identity, preferredLocales);
}
finally
{
m_session.ReturnDiagnostics = returnDiagnostics;
}
#endregion
DialogResult = DialogResult.OK;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Initializes the context with a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
public OperationContext(Session session, DiagnosticsMasks diagnosticsMasks)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
m_channelContext = null;
m_session = session;
m_identity = session.EffectiveIdentity;
m_preferredLocales = session.PreferredLocales;
m_diagnosticsMask = diagnosticsMasks;
m_stringTable = new StringTable();
m_auditLogEntryId = null;
m_requestId = 0;
m_requestType = RequestType.Unknown;
m_clientHandle = 0;
m_operationDeadline = DateTime.MaxValue;
}
/// <summary>
/// Initializes the object with its node type.
/// </summary>
public MemoryBufferMonitoredItem(
IServerInternal server,
INodeManager nodeManager,
object mangerHandle,
uint offset,
uint subscriptionId,
uint id,
Session session,
ReadValueId itemToMonitor,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
MonitoringFilter originalFilter,
MonitoringFilter filterToUse,
Range range,
double samplingInterval,
uint queueSize,
bool discardOldest,
double minimumSamplingInterval)
:
base(
server,
nodeManager,
mangerHandle,
subscriptionId,
id,
session,
itemToMonitor,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
originalFilter,
filterToUse,
range,
samplingInterval,
queueSize,
discardOldest,
minimumSamplingInterval)
{
m_offset = offset;
}
/// <summary>
/// Gets the item value.
/// </summary>
/// <param name="daValue">The da value.</param>
/// <param name="uaValue">The ua value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public static ServiceResult GetItemValue(DaValue daValue, DataValue uaValue, DiagnosticsMasks diagnosticsMasks)
{
ServiceResult result = null;
uaValue.Value = null;
if (daValue == null)
{
result = uaValue.StatusCode = StatusCodes.BadOutOfService;
return(result);
}
if (daValue.Timestamp.Kind == DateTimeKind.Unspecified)
{
uaValue.SourceTimestamp = DateTime.SpecifyKind(daValue.Timestamp, DateTimeKind.Utc);
}
else
{
throw new System.Exception(string.Format("The type of data from OPC server is not known: {0}", daValue.Timestamp.Kind.ToString()));
}
if (daValue.Error < 0)
{
result = MapReadErrorToServiceResult(daValue.Error, diagnosticsMasks);
uaValue.StatusCode = result.StatusCode;
return(result);
}
if (daValue.Quality != OpcRcw.Da.Qualities.OPC_QUALITY_GOOD)
{
uaValue.StatusCode = ComUtils.GetQualityCode(daValue.Quality);
}
if (StatusCode.IsBad(uaValue.StatusCode))
{
result = uaValue.StatusCode;
return(result);
}
uaValue.Value = daValue.Value;
return(result);
}
/// <summary>
/// Initializes the object with its node type.
/// </summary>
public MemoryBufferMonitoredItem(
IServerInternal server,
INodeManager nodeManager,
object mangerHandle,
uint offset,
uint subscriptionId,
uint id,
Session session,
ReadValueId itemToMonitor,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
MonitoringFilter originalFilter,
MonitoringFilter filterToUse,
Range range,
double samplingInterval,
uint queueSize,
bool discardOldest,
double minimumSamplingInterval)
:
base(
server,
nodeManager,
mangerHandle,
subscriptionId,
id,
session,
itemToMonitor,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
originalFilter,
filterToUse,
range,
samplingInterval,
queueSize,
discardOldest,
minimumSamplingInterval)
{
m_offset = offset;
}
ToContextFilterResult(DiagnosticsMasks diagnosticsMasks, StringTable stringTable)
{
ContentFilterResult result = new ContentFilterResult();
if (m_elementResults == null || m_elementResults.Count == 0)
{
return(result);
}
bool error = false;
foreach (ElementResult elementResult in m_elementResults)
{
ContentFilterElementResult elementResult2 = null;
if (elementResult == null || ServiceResult.IsGood(elementResult.Status))
{
elementResult2 = new ContentFilterElementResult();
elementResult2.StatusCode = StatusCodes.Good;
result.ElementResults.Add(elementResult2);
result.ElementDiagnosticInfos.Add(null);
continue;
}
error = true;
elementResult2 = elementResult.ToContentFilterElementResult(diagnosticsMasks, stringTable);
result.ElementResults.Add(elementResult2);
result.ElementDiagnosticInfos.Add(new DiagnosticInfo(elementResult.Status, diagnosticsMasks, false,
stringTable));
}
if (!error)
{
result.ElementResults.Clear();
result.ElementDiagnosticInfos.Clear();
}
return(result);
}
/// <summary>
/// Gets the result for the read operation.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="property">The property.</param>
/// <param name="nodeToRead">The node to read.</param>
/// <param name="value">The value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public ServiceResult GetResult(
ISystemContext context,
DaPropertyState property,
ReadValueId nodeToRead,
DataValue value,
DiagnosticsMasks diagnosticsMasks)
{
ServiceResult result = null;
switch (nodeToRead.AttributeId)
{
case Attributes.Value:
{
if (!String.IsNullOrEmpty(property.Property.ItemId))
{
result = GetItemValue(m_value, value, diagnosticsMasks);
}
else
{
this.GetPropertyValue <object>(property.PropertyId, value, true);
result = value.StatusCode;
}
// check if the property value is missing.
if (value.StatusCode == StatusCodes.BadNotFound)
{
return(StatusCodes.BadAttributeIdInvalid);
}
if (ServiceResult.IsBad(result))
{
return(result);
}
return(ApplyIndexRangeAndDataEncoding(context, nodeToRead, value));
}
}
return(StatusCodes.BadAttributeIdInvalid);
}
/// <summary>
/// Gets the result.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="source">The source.</param>
/// <param name="nodeToRead">The node to read.</param>
/// <param name="value">The value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public ServiceResult GetResult(
ISystemContext context,
NodeState source,
ReadValueId nodeToRead,
DataValue value,
DiagnosticsMasks diagnosticsMasks)
{
ReadRequest request = nodeToRead.Handle as ReadRequest;
if (request == null)
{
return(StatusCodes.Good);
}
// read item value.
DaItemState item = source as DaItemState;
if (item != null)
{
return(request.GetResult(context, item, nodeToRead, value, diagnosticsMasks));
}
// read vendor defined property value.
DaPropertyState daProperty = source as DaPropertyState;
if (daProperty != null)
{
return(request.GetResult(context, daProperty, nodeToRead, value, diagnosticsMasks));
}
// read UA defined property value.
PropertyState uaProperty = source as PropertyState;
if (uaProperty != null)
{
return(request.GetResult(context, uaProperty, nodeToRead, value, diagnosticsMasks));
}
return(StatusCodes.Good);
}
/// <summary>
/// Creates a new monitored item.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="nodeManager">The node manager.</param>
/// <param name="managerHandle">The manager handle.</param>
/// <param name="subscriptionId">The subscription id.</param>
/// <param name="id">The id.</param>
/// <param name="session">The session.</param>
/// <param name="itemToMonitor">The item to monitor.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <param name="timestampsToReturn">The timestamps to return.</param>
/// <param name="monitoringMode">The monitoring mode.</param>
/// <param name="clientHandle">The client handle.</param>
/// <param name="originalFilter">The original filter.</param>
/// <param name="filterToUse">The filter to use.</param>
/// <param name="range">The range.</param>
/// <param name="samplingInterval">The sampling interval.</param>
/// <param name="queueSize">Size of the queue.</param>
/// <param name="discardOldest">if set to <c>true</c> [discard oldest].</param>
/// <param name="minimumSamplingInterval">The minimum sampling interval.</param>
/// <returns>The monitored item.</returns>
protected virtual MonitoredItem CreateMonitoredItem(
IServerInternal server,
INodeManager nodeManager,
object managerHandle,
uint subscriptionId,
uint id,
Session session,
ReadValueId itemToMonitor,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
MonitoringFilter originalFilter,
MonitoringFilter filterToUse,
Range range,
double samplingInterval,
uint queueSize,
bool discardOldest,
double minimumSamplingInterval)
{
return(new MonitoredItem(
server,
nodeManager,
managerHandle,
subscriptionId,
id,
session,
itemToMonitor,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
originalFilter,
filterToUse,
range,
samplingInterval,
queueSize,
discardOldest,
minimumSamplingInterval));
}
/// <summary>
/// Gets the item value.
/// </summary>
/// <param name="daValue">The da value.</param>
/// <param name="uaValue">The ua value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public static ServiceResult GetItemValue(DaValue daValue, DataValue uaValue, DiagnosticsMasks diagnosticsMasks)
{
ServiceResult result = null;
uaValue.Value = null;
if (daValue == null)
{
result = uaValue.StatusCode = StatusCodes.BadOutOfService;
return(result);
}
uaValue.SourceTimestamp = daValue.Timestamp;
if (daValue.Error < 0)
{
result = MapReadErrorToServiceResult(daValue.Error, diagnosticsMasks);
uaValue.StatusCode = result.StatusCode;
return(result);
}
if (daValue.Quality != OpcRcw.Da.Qualities.OPC_QUALITY_GOOD)
{
uaValue.StatusCode = ComUtils.GetQualityCode(daValue.Quality);
}
if (StatusCode.IsBad(uaValue.StatusCode))
{
result = uaValue.StatusCode;
return(result);
}
uaValue.Value = daValue.Value;
return(result);
}
/// <summary>
/// Gets the result for the read operation.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="attribute">The attribute.</param>
/// <param name="nodeToRead">The node to read.</param>
/// <param name="value">The value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public ServiceResult GetResult(
ISystemContext context,
HdaAttributeState attribute,
ReadValueId nodeToRead,
DataValue value,
DiagnosticsMasks diagnosticsMasks)
{
if (nodeToRead.AttributeId != Attributes.Value)
{
// check if reading access level.
if (nodeToRead.AttributeId == Attributes.AccessLevel || nodeToRead.AttributeId == Attributes.UserAccessLevel)
{
HdaAttributeValue result = GetAttributeValue(attribute.Attribute.Id);
if (result == null || result.Error < 0 || result.Error == ResultIds.S_NODATA)
{
value.StatusCode = StatusCodes.BadNotFound;
return(value.StatusCode);
}
value.Value = AccessLevels.CurrentRead;
if (result.Error != ResultIds.S_CURRENTVALUE)
{
value.Value = (byte)(AccessLevels.CurrentRead | AccessLevels.HistoryRead);
}
return(value.StatusCode);
}
return(StatusCodes.BadAttributeIdInvalid);
}
// convert values when required.
switch (attribute.Attribute.Id)
{
case Constants.OPCHDA_NORMAL_MAXIMUM:
{
double high = this.GetAttributeValue <double>(Constants.OPCHDA_NORMAL_MAXIMUM, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
double low = this.GetAttributeValue <double>(Constants.OPCHDA_NORMAL_MINIMUM, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = new Range(high, low);
break;
}
case Constants.OPCHDA_HIGH_ENTRY_LIMIT:
{
double high = this.GetAttributeValue <double>(Constants.OPCHDA_HIGH_ENTRY_LIMIT, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
double low = this.GetAttributeValue <double>(Constants.OPCHDA_LOW_ENTRY_LIMIT, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = new Range(high, low);
break;
}
case Constants.OPCHDA_ENG_UNITS:
{
string units = this.GetAttributeValue <string>(Constants.OPCHDA_ENG_UNITS, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = new EUInformation(units, Namespaces.ComInterop);
break;
}
case Constants.OPCHDA_MAX_TIME_INT:
case Constants.OPCHDA_MIN_TIME_INT:
{
string number = this.GetAttributeValue <string>(attribute.Attribute.Id, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
try
{
value.Value = Convert.ToDouble(number);
}
catch (Exception)
{
value.StatusCode = StatusCodes.BadTypeMismatch;
return(value.StatusCode);
}
break;
}
case Constants.OPCHDA_EXCEPTION_DEV_TYPE:
{
short number = this.GetAttributeValue <short>(attribute.Attribute.Id, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = (int)number;
break;
}
default:
{
object result = this.GetAttributeValue <object>(attribute.Attribute.Id, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = result;
break;
}
}
// check if the attribute value is missing.
if (value.StatusCode == StatusCodes.BadNotFound)
{
return(StatusCodes.BadNodeIdUnknown);
}
return(ApplyIndexRangeAndDataEncoding(context, nodeToRead, value));
}
/// <summary>
/// Converts the object to an EventFilterResult.
/// </summary>
public EventFilterResult ToEventFilterResult(DiagnosticsMasks diagnosticsMasks, StringTable stringTable)
{
EventFilterResult result = new EventFilterResult();
if (m_selectClauseResults != null && m_selectClauseResults.Count > 0)
{
foreach (ServiceResult clauseResult in m_selectClauseResults)
{
if (ServiceResult.IsBad(clauseResult))
{
result.SelectClauseResults.Add(clauseResult.StatusCode);
result.SelectClauseDiagnosticInfos.Add(new DiagnosticInfo(clauseResult, diagnosticsMasks, false, stringTable));
}
else
{
result.SelectClauseResults.Add(StatusCodes.Good);
result.SelectClauseDiagnosticInfos.Add(null);
}
}
}
if (m_whereClauseResults != null)
{
result.WhereClauseResult = m_whereClauseResults.ToContextFilterResult(diagnosticsMasks, stringTable);
}
return result;
}
/// <summary>
/// Converts the object to an ContentFilterResult.
/// </summary>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <param name="stringTable">The string table.</param>
/// <returns></returns>
public ContentFilterResult ToContextFilterResult(DiagnosticsMasks diagnosticsMasks, StringTable stringTable)
{
ContentFilterResult result = new ContentFilterResult();
if (m_elementResults == null || m_elementResults.Count == 0)
{
return result;
}
bool error = false;
foreach (ElementResult elementResult in m_elementResults)
{
ContentFilterElementResult elementResult2 = null;
if (elementResult == null || ServiceResult.IsGood(elementResult.Status))
{
elementResult2 = new ContentFilterElementResult();
elementResult2.StatusCode = StatusCodes.Good;
result.ElementResults.Add(elementResult2);
result.ElementDiagnosticInfos.Add(null);
continue;
}
error = true;
elementResult2 = elementResult.ToContentFilterElementResult(diagnosticsMasks, stringTable);
result.ElementResults.Add(elementResult2);
result.ElementDiagnosticInfos.Add(new DiagnosticInfo(elementResult.Status, diagnosticsMasks, false, stringTable));
}
if (!error)
{
result.ElementResults.Clear();
result.ElementDiagnosticInfos.Clear();
}
return result;
}
/// <summary>
/// Creates a new set of monitored items for a set of variables.
/// </summary>
/// <remarks>
/// This method only handles data change subscriptions. Event subscriptions are created by the SDK.
/// </remarks>
protected virtual ServiceResult CreateMonitoredItem(
ISystemContext context,
NodeState source,
uint subscriptionId,
double publishingInterval,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoredItemCreateRequest itemToCreate,
ref long globalIdCounter,
out MonitoringFilterResult filterError,
out IMonitoredItem monitoredItem)
{
filterError = null;
monitoredItem = null;
ServiceResult error = null;
// read initial value.
DataValue initialValue = new DataValue();
initialValue.Value = null;
initialValue.ServerTimestamp = DateTime.UtcNow;
initialValue.SourceTimestamp = DateTime.MinValue;
initialValue.StatusCode = StatusCodes.Good;
error = source.ReadAttribute(
context,
itemToCreate.ItemToMonitor.AttributeId,
itemToCreate.ItemToMonitor.ParsedIndexRange,
itemToCreate.ItemToMonitor.DataEncoding,
initialValue);
if (ServiceResult.IsBad(error))
{
return error;
}
// validate parameters.
MonitoringParameters parameters = itemToCreate.RequestedParameters;
// validate the data change filter.
DataChangeFilter filter = null;
Range range = null;
if (!ExtensionObject.IsNull(parameters.Filter))
{
error = ValidateDataChangeFilter(
context,
source,
itemToCreate.ItemToMonitor.AttributeId,
parameters.Filter,
out filter,
out range);
if (ServiceResult.IsBad(error))
{
return error;
}
}
// create monitored node.
MonitoredNode monitoredNode = source.Handle as MonitoredNode;
if (monitoredNode == null)
{
source.Handle = monitoredNode = new MonitoredNode(m_server, this, source);
}
// create a globally unique identifier.
uint monitoredItemId = Utils.IncrementIdentifier(ref globalIdCounter);
// determine the sampling interval.
double samplingInterval = itemToCreate.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = publishingInterval;
}
// check if the variable needs to be sampled.
bool samplingRequired = false;
if (itemToCreate.ItemToMonitor.AttributeId == Attributes.Value)
{
BaseVariableState variable = source as BaseVariableState;
if (variable.MinimumSamplingInterval > 0)
{
samplingInterval = CalculateSamplingInterval(variable, samplingInterval);
samplingRequired = true;
}
}
// create the item.
DataChangeMonitoredItem datachangeItem = monitoredNode.CreateDataChangeItem(
context,
monitoredItemId,
itemToCreate.ItemToMonitor.AttributeId,
itemToCreate.ItemToMonitor.ParsedIndexRange,
itemToCreate.ItemToMonitor.DataEncoding,
diagnosticsMasks,
timestampsToReturn,
itemToCreate.MonitoringMode,
itemToCreate.RequestedParameters.ClientHandle,
samplingInterval,
itemToCreate.RequestedParameters.QueueSize,
itemToCreate.RequestedParameters.DiscardOldest,
filter,
range,
false);
if (samplingRequired)
{
CreateSampledItem(samplingInterval, datachangeItem);
}
// report the initial value.
datachangeItem.QueueValue(initialValue, null);
// do any post processing.
OnCreateMonitoredItem(context, itemToCreate, monitoredNode, datachangeItem);
// update monitored item list.
monitoredItem = datachangeItem;
return ServiceResult.Good;
}
/// <summary>
/// Modifies the monitored item parameters,
/// </summary>
public ServiceResult Modify(
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
uint clientHandle,
double samplingInterval,
uint queueSize,
bool discardOldest,
DataChangeFilter filter,
Range range)
{
lock (m_lock)
{
m_diagnosticsMasks = diagnosticsMasks;
m_timestampsToReturn = timestampsToReturn;
m_clientHandle = clientHandle;
// subtract the previous sampling interval.
long oldSamplingInterval = (long)(m_samplingInterval * TimeSpan.TicksPerMillisecond);
if (oldSamplingInterval < m_nextSampleTime)
{
m_nextSampleTime -= oldSamplingInterval;
}
m_samplingInterval = samplingInterval;
// calculate the next sampling interval.
long newSamplingInterval = (long)(m_samplingInterval * TimeSpan.TicksPerMillisecond);
if (m_samplingInterval > 0)
{
m_nextSampleTime += newSamplingInterval;
}
else
{
m_nextSampleTime = 0;
}
// update the filter and the range.
m_filter = filter;
m_range = 0;
if (range != null)
{
m_range = range.High - range.Low;
}
// update the queue size.
if (queueSize > 1)
{
if (m_queue == null)
{
m_queue = new MonitoredItemQueue();
}
m_queue.SetQueueSize(queueSize, discardOldest, diagnosticsMasks);
m_queue.SetSamplingInterval(samplingInterval);
}
else
{
m_queue = null;
}
return(ServiceResult.Good);
}
}
/// <summary>
/// Creates a new set of monitored items for a set of variables.
/// </summary>
/// <remarks>
/// This method only handles data change subscriptions. Event subscriptions are created by the SDK.
/// </remarks>
protected override ServiceResult CreateMonitoredItem(
ISystemContext context,
NodeState source,
uint subscriptionId,
double publishingInterval,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoredItemCreateRequest itemToCreate,
ref long globalIdCounter,
out MonitoringFilterResult filterError,
out IMonitoredItem monitoredItem)
{
filterError = null;
monitoredItem = null;
// use default behavoir for non-tag sources.
if (!(source is MemoryTagState tag))
{
return(base.CreateMonitoredItem(
context,
source,
subscriptionId,
publishingInterval,
diagnosticsMasks,
timestampsToReturn,
itemToCreate,
ref globalIdCounter,
out filterError,
out monitoredItem));
}
// validate parameters.
var parameters = itemToCreate.RequestedParameters;
// no filters supported at this time.
var filter = (MonitoringFilter)ExtensionObject.ToEncodeable(parameters.Filter);
if (filter != null)
{
return(StatusCodes.BadFilterNotAllowed);
}
// index range not supported.
if (itemToCreate.ItemToMonitor.ParsedIndexRange != NumericRange.Empty)
{
return(StatusCodes.BadIndexRangeInvalid);
}
// data encoding not supported.
if (!QualifiedName.IsNull(itemToCreate.ItemToMonitor.DataEncoding))
{
return(StatusCodes.BadDataEncodingInvalid);
}
// read initial value.
var initialValue = new DataValue {
Value = null,
ServerTimestamp = DateTime.UtcNow,
SourceTimestamp = DateTime.MinValue,
StatusCode = StatusCodes.Good
};
var error = source.ReadAttribute(
context,
itemToCreate.ItemToMonitor.AttributeId,
itemToCreate.ItemToMonitor.ParsedIndexRange,
itemToCreate.ItemToMonitor.DataEncoding,
initialValue);
if (ServiceResult.IsBad(error))
{
return(error);
}
// get the monitored node for the containing buffer.
if (!(tag.Parent is MemoryBufferState buffer))
{
return(StatusCodes.BadInternalError);
}
// create a globally unique identifier.
var monitoredItemId = Utils.IncrementIdentifier(ref globalIdCounter);
// determine the sampling interval.
var samplingInterval = itemToCreate.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = publishingInterval;
}
// create the item.
var datachangeItem = buffer.CreateDataChangeItem(
context as ServerSystemContext,
tag,
monitoredItemId,
itemToCreate.ItemToMonitor,
diagnosticsMasks,
timestampsToReturn,
itemToCreate.MonitoringMode,
itemToCreate.RequestedParameters.ClientHandle,
samplingInterval);
/*
* // create the item.
* MemoryBufferMonitoredItem datachangeItem = buffer.CreateDataChangeItem(
* context,
* tag,
* monitoredItemId,
* itemToCreate.ItemToMonitor.AttributeId,
* diagnosticsMasks,
* timestampsToReturn,
* itemToCreate.MonitoringMode,
* itemToCreate.RequestedParameters.ClientHandle,
* samplingInterval);
*/
// report the initial value.
datachangeItem.QueueValue(initialValue, null);
// update monitored item list.
monitoredItem = datachangeItem;
return(ServiceResult.Good);
}
/// <summary>
/// Translates an exception.
/// </summary>
/// <param name="diagnosticsMasks">The fields to return.</param>
/// <param name="preferredLocales">The preferred locales.</param>
/// <param name="e">The ServiceResultException e.</param>
/// <returns>Returns an exception thrown when a UA defined error occurs, the return type is <seealso cref="ServiceResultException"/>.</returns>
protected virtual ServiceResultException TranslateException(DiagnosticsMasks diagnosticsMasks, IList<string> preferredLocales, ServiceResultException e)
{
if (e == null)
{
return null;
}
// check if inner result required.
ServiceResult innerResult = null;
if ((diagnosticsMasks & (DiagnosticsMasks.ServiceInnerDiagnostics | DiagnosticsMasks.ServiceInnerStatusCode)) != 0)
{
innerResult = e.InnerResult;
}
// check if translated text required.
LocalizedText translatedText = null;
if ((diagnosticsMasks & DiagnosticsMasks.ServiceLocalizedText) != 0)
{
translatedText = e.LocalizedText;
}
// create new result object.
ServiceResult result = new ServiceResult(
e.StatusCode,
e.SymbolicId,
e.NamespaceUri,
translatedText,
e.AdditionalInfo,
innerResult);
// translate result.
result = m_serverInternal.ResourceManager.Translate(preferredLocales, result);
return new ServiceResultException(result);
}
/// <summary>
/// Sets the queue size.
/// </summary>
/// <param name="queueSize">The new queue size.</param>
/// <param name="discardOldest">Whether to discard the oldest values if the queue overflows.</param>
/// <param name="diagnosticsMasks">Specifies which diagnostics which should be kept in the queue.</param>
public void SetQueueSize(uint queueSize, bool discardOldest, DiagnosticsMasks diagnosticsMasks)
{
int length = (int)queueSize;
if (length < 1)
{
length = 1;
}
int start = m_start;
int end = m_end;
// create new queue.
DataValue[] values = new DataValue[length];
ServiceResult[] errors = null;
if ((diagnosticsMasks & DiagnosticsMasks.OperationAll) != 0)
{
errors = new ServiceResult[length];
}
// copy existing values.
List<DataValue> existingValues = null;
List<ServiceResult> existingErrors = null;
if (m_start >= 0)
{
existingValues = new List<DataValue>();
existingErrors = new List<ServiceResult>();
DataValue value = null;
ServiceResult error = null;
while (Dequeue(out value, out error))
{
existingValues.Add(value);
existingErrors.Add(error);
}
}
// update internals.
m_values = values;
m_errors = errors;
m_start = -1;
m_end = 0;
m_overflow = -1;
m_discardOldest = discardOldest;
// requeue the data.
if (existingValues != null)
{
for (int ii = 0; ii < existingValues.Count; ii++)
{
Enqueue(existingValues[ii], existingErrors[ii]);
}
}
}
/// <summary>
/// Creates a new set of monitored items for a set of variables.
/// </summary>
/// <remarks>
/// This method only handles data change subscriptions. Event subscriptions are created by the SDK.
/// </remarks>
protected override ServiceResult CreateMonitoredItem(
ISystemContext context,
NodeState source,
uint subscriptionId,
double publishingInterval,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoredItemCreateRequest itemToCreate,
ref long globalIdCounter,
out MonitoringFilterResult filterError,
out IMonitoredItem monitoredItem)
{
filterError = null;
monitoredItem = null;
MemoryTagState tag = source as MemoryTagState;
// use default behavoir for non-tag sources.
if (tag == null)
{
return base.CreateMonitoredItem(
context,
source,
subscriptionId,
publishingInterval,
diagnosticsMasks,
timestampsToReturn,
itemToCreate,
ref globalIdCounter,
out filterError,
out monitoredItem);
}
// validate parameters.
MonitoringParameters parameters = itemToCreate.RequestedParameters;
// no filters supported at this time.
MonitoringFilter filter = (MonitoringFilter)ExtensionObject.ToEncodeable(parameters.Filter);
if (filter != null)
{
return StatusCodes.BadFilterNotAllowed;
}
// index range not supported.
if (itemToCreate.ItemToMonitor.ParsedIndexRange != NumericRange.Empty)
{
return StatusCodes.BadIndexRangeInvalid;
}
// data encoding not supported.
if (!QualifiedName.IsNull(itemToCreate.ItemToMonitor.DataEncoding))
{
return StatusCodes.BadDataEncodingInvalid;
}
// read initial value.
DataValue initialValue = new DataValue();
initialValue.Value = null;
initialValue.ServerTimestamp = DateTime.UtcNow;
initialValue.SourceTimestamp = DateTime.MinValue;
initialValue.StatusCode = StatusCodes.Good;
ServiceResult error = source.ReadAttribute(
context,
itemToCreate.ItemToMonitor.AttributeId,
itemToCreate.ItemToMonitor.ParsedIndexRange,
itemToCreate.ItemToMonitor.DataEncoding,
initialValue);
if (ServiceResult.IsBad(error))
{
return error;
}
// get the monitored node for the containing buffer.
MemoryBufferState buffer = tag.Parent as MemoryBufferState;
if (buffer == null)
{
return StatusCodes.BadInternalError;
}
// create a globally unique identifier.
uint monitoredItemId = Utils.IncrementIdentifier(ref globalIdCounter);
// determine the sampling interval.
double samplingInterval = itemToCreate.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = publishingInterval;
}
// create the item.
MemoryBufferMonitoredItem datachangeItem = buffer.CreateDataChangeItem(
context as ServerSystemContext,
tag,
subscriptionId,
monitoredItemId,
itemToCreate.ItemToMonitor,
diagnosticsMasks,
timestampsToReturn,
itemToCreate.MonitoringMode,
itemToCreate.RequestedParameters.ClientHandle,
samplingInterval);
/*
// create the item.
MemoryBufferMonitoredItem datachangeItem = buffer.CreateDataChangeItem(
context,
tag,
monitoredItemId,
itemToCreate.ItemToMonitor.AttributeId,
diagnosticsMasks,
timestampsToReturn,
itemToCreate.MonitoringMode,
itemToCreate.RequestedParameters.ClientHandle,
samplingInterval);
*/
// report the initial value.
datachangeItem.QueueValue(initialValue, null);
// update monitored item list.
monitoredItem = datachangeItem;
return ServiceResult.Good;
}
/// <summary>
/// Modifies the parameters for a monitored item.
/// </summary>
protected override ServiceResult ModifyMonitoredItem(
ISystemContext context,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
IMonitoredItem monitoredItem,
MonitoredItemModifyRequest itemToModify,
out MonitoringFilterResult filterError)
{
filterError = null;
// check for valid handle.
MemoryBufferState buffer = monitoredItem.ManagerHandle as MemoryBufferState;
if (buffer == null)
{
return base.ModifyMonitoredItem(
context,
diagnosticsMasks,
timestampsToReturn,
monitoredItem,
itemToModify,
out filterError);
}
// owned by this node manager.
itemToModify.Processed = true;
// get the monitored item.
MemoryBufferMonitoredItem datachangeItem = monitoredItem as MemoryBufferMonitoredItem;
if (datachangeItem == null)
{
return StatusCodes.BadMonitoredItemIdInvalid;
}
// validate parameters.
MonitoringParameters parameters = itemToModify.RequestedParameters;
// no filters supported at this time.
MonitoringFilter filter = (MonitoringFilter)ExtensionObject.ToEncodeable(parameters.Filter);
if (filter != null)
{
return StatusCodes.BadFilterNotAllowed;
}
// modify the monitored item parameters.
ServiceResult error = datachangeItem.Modify(
diagnosticsMasks,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
itemToModify.RequestedParameters.SamplingInterval);
return ServiceResult.Good;
}
/// <summary>
/// Creates a new data change monitored item.
/// </summary>
public MemoryBufferMonitoredItem CreateDataChangeItem(
ServerSystemContext context,
MemoryTagState tag,
uint monitoredItemId,
ReadValueId itemToMonitor,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval)
{
lock (_dataLock) {
var monitoredItem = new MemoryBufferMonitoredItem(
Server,
NodeManager,
this,
tag.Offset,
0,
monitoredItemId,
context.OperationContext.Session,
itemToMonitor,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
null,
null,
null,
samplingInterval,
0,
false,
0);
if (itemToMonitor.AttributeId != Attributes.Value)
{
_nonValueMonitoredItems.Add(monitoredItem.Id, monitoredItem);
return(monitoredItem);
}
var elementCount = (int)(SizeInBytes.Value / ElementSize);
if (_monitoringTable == null)
{
_monitoringTable = new MemoryBufferMonitoredItem[elementCount][];
_scanTimer = new Timer(DoScan, null, 100, 100);
}
var elementOffet = (int)(tag.Offset / ElementSize);
var monitoredItems = _monitoringTable[elementOffet];
if (monitoredItems == null)
{
monitoredItems = new MemoryBufferMonitoredItem[1];
}
else
{
monitoredItems = new MemoryBufferMonitoredItem[monitoredItems.Length + 1];
_monitoringTable[elementOffet].CopyTo(monitoredItems, 0);
}
monitoredItems[monitoredItems.Length - 1] = monitoredItem;
_monitoringTable[elementOffet] = monitoredItems;
_itemCount++;
return(monitoredItem);
}
}
/// <summary>
/// Modifies the monitored item parameters,
/// </summary>
public ServiceResult Modify(
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
uint clientHandle,
double samplingInterval,
uint queueSize,
bool discardOldest,
DataChangeFilter filter,
Range range)
{
lock (m_lock)
{
m_diagnosticsMasks = diagnosticsMasks;
m_timestampsToReturn = timestampsToReturn;
m_clientHandle = clientHandle;
// subtract the previous sampling interval.
long oldSamplingInterval = (long)(m_samplingInterval*TimeSpan.TicksPerMillisecond);
if (oldSamplingInterval < m_nextSampleTime)
{
m_nextSampleTime -= oldSamplingInterval;
}
m_samplingInterval = samplingInterval;
// calculate the next sampling interval.
long newSamplingInterval = (long)(m_samplingInterval*TimeSpan.TicksPerMillisecond);
if (m_samplingInterval > 0)
{
m_nextSampleTime += newSamplingInterval;
}
else
{
m_nextSampleTime = 0;
}
// update the filter and the range.
m_filter = filter;
m_range = 0;
if (range != null)
{
m_range = range.High - range.Low;
}
// update the queue size.
if (queueSize > 1)
{
if (m_queue == null)
{
m_queue = new MonitoredItemQueue();
}
m_queue.SetQueueSize(queueSize, discardOldest, diagnosticsMasks);
m_queue.SetSamplingInterval(samplingInterval);
}
else
{
m_queue = null;
}
return ServiceResult.Good;
}
}
/// <summary>
/// Creates a new set of monitored items for a set of variables.
/// </summary>
/// <remarks>
/// This method only handles data change subscriptions. Event subscriptions are created by the SDK.
/// </remarks>
protected override ServiceResult CreateMonitoredItem(ServerSystemContext context, NodeHandle handle, uint subscriptionId, double publishingInterval, DiagnosticsMasks diagnosticsMasks, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequest itemToCreate, ref long globalIdCounter, out MonitoringFilterResult filterResult, out IMonitoredItem monitoredItem)
{
filterResult = null;
monitoredItem = null;
// validate parameters.
MonitoringParameters parameters = itemToCreate.RequestedParameters;
// validate attribute.
if (!Attributes.IsValid(handle.Node.NodeClass, itemToCreate.ItemToMonitor.AttributeId))
{
return(StatusCodes.BadAttributeIdInvalid);
}
NodeState cachedNode = AddNodeToComponentCache(context, handle, handle.Node);
// check if the node is already being monitored.
MonitoredNode2 monitoredNode = null;
if (!MonitoredNodes.TryGetValue(handle.Node.NodeId, out monitoredNode))
{
MonitoredNodes[handle.Node.NodeId] = monitoredNode = new MonitoredNode2(this, cachedNode);
}
handle.Node = monitoredNode.Node;
handle.MonitoredNode = monitoredNode;
// create a globally unique identifier.
uint monitoredItemId = Utils.IncrementIdentifier(ref globalIdCounter);
// determine the sampling interval.
double samplingInterval = itemToCreate.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = publishingInterval;
}
// ensure minimum sampling interval is not exceeded.
if (itemToCreate.ItemToMonitor.AttributeId == Attributes.Value)
{
BaseVariableState variable = handle.Node as BaseVariableState;
if (variable != null && samplingInterval < variable.MinimumSamplingInterval)
{
samplingInterval = variable.MinimumSamplingInterval;
}
}
// put a large upper limit on sampling.
if (samplingInterval == Double.MaxValue)
{
samplingInterval = 365 * 24 * 3600 * 1000.0;
}
// put an upper limit on queue size.
uint queueSize = itemToCreate.RequestedParameters.QueueSize;
if (queueSize > MaxQueueSize)
{
queueSize = MaxQueueSize;
}
// validate the monitoring filter.
Range euRange = null;
MonitoringFilter filterToUse = null;
ServiceResult error = ValidateMonitoringFilter(
context,
handle,
itemToCreate.ItemToMonitor.AttributeId,
samplingInterval,
queueSize,
parameters.Filter,
out filterToUse,
out euRange,
out filterResult);
if (ServiceResult.IsBad(error))
{
return(error);
}
// create the item.
MonitoredItem datachangeItem = new ComMonitoredItem(
Server,
this,
handle,
subscriptionId,
monitoredItemId,
context.OperationContext.Session,
itemToCreate.ItemToMonitor,
diagnosticsMasks,
timestampsToReturn,
itemToCreate.MonitoringMode,
itemToCreate.RequestedParameters.ClientHandle,
filterToUse,
filterToUse,
euRange,
samplingInterval,
queueSize,
itemToCreate.RequestedParameters.DiscardOldest,
0);
// report the initial value.
ReadInitialValue(context, handle, datachangeItem);
// update monitored item list.
monitoredItem = datachangeItem;
// save the monitored item.
MonitoredItems.Add(monitoredItemId, datachangeItem);
monitoredNode.Add(datachangeItem);
// report change.
OnMonitoredItemCreated(context, handle, datachangeItem);
return(error);
}
/// <summary>
/// Creates a new data change monitored item.
/// </summary>
/// <param name="context">The system context.</param>
/// <param name="monitoredItemId">The unique identifier for the monitiored item.</param>
/// <param name="attributeId">The attribute to monitor.</param>
/// <param name="indexRange">The index range to use for array values.</param>
/// <param name="dataEncoding">The data encoding to return for structured values.</param>
/// <param name="diagnosticsMasks">The diagnostics masks to use.</param>
/// <param name="timestampsToReturn">The timestamps to return.</param>
/// <param name="monitoringMode">The initial monitoring mode.</param>
/// <param name="clientHandle">The handle assigned by the client.</param>
/// <param name="samplingInterval">The sampling interval.</param>
/// <param name="queueSize">The queue size.</param>
/// <param name="discardOldest">Whether to discard the oldest values when the queue overflows.</param>
/// <param name="filter">The data change filter to use.</param>
/// <param name="range">The range to use when evaluating a percentage deadband filter.</param>
/// <param name="alwaysReportUpdates">Whether the monitored item should skip the check for a change in value.</param>
/// <returns>The new monitored item.</returns>
public DataChangeMonitoredItem CreateDataChangeItem(
ISystemContext context,
uint monitoredItemId,
uint attributeId,
NumericRange indexRange,
QualifiedName dataEncoding,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval,
uint queueSize,
bool discardOldest,
DataChangeFilter filter,
Range range,
bool alwaysReportUpdates)
{
DataChangeMonitoredItem monitoredItem = new DataChangeMonitoredItem(
this,
monitoredItemId,
attributeId,
indexRange,
dataEncoding,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
samplingInterval,
queueSize,
discardOldest,
filter,
range,
alwaysReportUpdates);
if (m_monitoredItems == null)
{
m_monitoredItems = new List<DataChangeMonitoredItem>();
m_node.OnStateChanged = OnNodeChange;
}
m_monitoredItems.Add(monitoredItem);
return monitoredItem;
}
/// <summary>
/// Creates a new data change monitored item.
/// </summary>
/// <param name="context">The system context.</param>
/// <param name="monitoredItemId">The unique identifier for the monitiored item.</param>
/// <param name="attributeId">The attribute to monitor.</param>
/// <param name="indexRange">The index range to use for array values.</param>
/// <param name="dataEncoding">The data encoding to return for structured values.</param>
/// <param name="diagnosticsMasks">The diagnostics masks to use.</param>
/// <param name="timestampsToReturn">The timestamps to return.</param>
/// <param name="monitoringMode">The initial monitoring mode.</param>
/// <param name="clientHandle">The handle assigned by the client.</param>
/// <param name="samplingInterval">The sampling interval.</param>
/// <param name="alwaysReportUpdates">Whether the monitored item should skip the check for a change in value.</param>
/// <returns>The new monitored item.</returns>
public DataChangeMonitoredItem CreateDataChangeItem(
ISystemContext context,
uint monitoredItemId,
uint attributeId,
NumericRange indexRange,
QualifiedName dataEncoding,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval,
bool alwaysReportUpdates)
{
return CreateDataChangeItem(
context,
monitoredItemId,
attributeId,
indexRange,
dataEncoding,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
samplingInterval,
0,
false,
null,
null,
alwaysReportUpdates);
}
/// <summary>
/// Creates a new set of monitored items for a set of variables.
/// </summary>
/// <remarks>
/// This method only handles data change subscriptions. Event subscriptions are created by the SDK.
/// </remarks>
protected virtual ServiceResult CreateMonitoredItem(
ServerSystemContext context,
NodeHandle handle,
uint subscriptionId,
double publishingInterval,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoredItemCreateRequest itemToCreate,
ref long globalIdCounter,
out MonitoringFilterResult filterResult,
out IMonitoredItem monitoredItem)
{
filterResult = null;
monitoredItem = null;
// validate parameters.
MonitoringParameters parameters = itemToCreate.RequestedParameters;
// validate attribute.
if (!Attributes.IsValid(handle.Node.NodeClass, itemToCreate.ItemToMonitor.AttributeId))
{
return StatusCodes.BadAttributeIdInvalid;
}
// check if the node is already being monitored.
MonitoredNode monitoredNode = null;
if (!m_monitoredNodes.TryGetValue(handle.Node.NodeId, out monitoredNode))
{
NodeState cachedNode = AddNodeToComponentCache(context, handle, handle.Node);
m_monitoredNodes[handle.Node.NodeId] = monitoredNode = new MonitoredNode(this, cachedNode);
}
handle.Node = monitoredNode.Node;
handle.MonitoredNode = monitoredNode;
// create a globally unique identifier.
uint monitoredItemId = Utils.IncrementIdentifier(ref globalIdCounter);
// determine the sampling interval.
double samplingInterval = itemToCreate.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = publishingInterval;
}
// ensure minimum sampling interval is not exceeded.
if (itemToCreate.ItemToMonitor.AttributeId == Attributes.Value)
{
BaseVariableState variable = handle.Node as BaseVariableState;
if (variable != null && samplingInterval < variable.MinimumSamplingInterval)
{
samplingInterval = variable.MinimumSamplingInterval;
}
}
// put a large upper limit on sampling.
if (samplingInterval == Double.MaxValue)
{
samplingInterval = 365 * 24 * 3600 * 1000.0;
}
// put an upper limit on queue size.
uint queueSize = itemToCreate.RequestedParameters.QueueSize;
if (queueSize > m_maxQueueSize)
{
queueSize = m_maxQueueSize;
}
// validate the monitoring filter.
Range euRange = null;
MonitoringFilter filterToUse = null;
ServiceResult error = ValidateMonitoringFilter(
context,
handle,
itemToCreate.ItemToMonitor.AttributeId,
samplingInterval,
queueSize,
parameters.Filter,
out filterToUse,
out euRange,
out filterResult);
if (ServiceResult.IsBad(error))
{
return error;
}
// create the item.
MonitoredItem datachangeItem = new MonitoredItem(
Server,
this,
handle,
subscriptionId,
monitoredItemId,
context.OperationContext.Session,
itemToCreate.ItemToMonitor,
diagnosticsMasks,
timestampsToReturn,
itemToCreate.MonitoringMode,
itemToCreate.RequestedParameters.ClientHandle,
filterToUse,
filterToUse,
euRange,
samplingInterval,
queueSize,
itemToCreate.RequestedParameters.DiscardOldest,
0);
// report the initial value.
ReadInitialValue(context, handle, datachangeItem);
// update monitored item list.
monitoredItem = datachangeItem;
// save the monitored item.
m_monitoredItems.Add(monitoredItemId, datachangeItem);
monitoredNode.Add(datachangeItem);
// report change.
OnMonitoredItemCreated(context, handle, datachangeItem);
return error;
}
/// <summary>
/// Translates a service result.
/// </summary>
/// <param name="diagnosticsMasks">The fields to return.</param>
/// <param name="preferredLocales">The preferred locales.</param>
/// <param name="result">The result.</param>
/// <returns>Returns a class that combines the status code and diagnostic info structures.</returns>
protected virtual ServiceResult TranslateResult(DiagnosticsMasks diagnosticsMasks, IList<string> preferredLocales, ServiceResult result)
{
if (result == null)
{
return null;
}
return m_serverInternal.ResourceManager.Translate(preferredLocales, result);
}
/// <summary>
/// Modifies the parameters for a monitored item.
/// </summary>
protected virtual ServiceResult ModifyMonitoredItem(
ServerSystemContext context,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
IMonitoredItem monitoredItem,
MonitoredItemModifyRequest itemToModify,
NodeHandle handle,
out MonitoringFilterResult filterResult)
{
filterResult = null;
// check for valid monitored item.
MonitoredItem datachangeItem = monitoredItem as MonitoredItem;
// validate parameters.
MonitoringParameters parameters = itemToModify.RequestedParameters;
double previousSamplingInterval = datachangeItem.SamplingInterval;
// check if the variable needs to be sampled.
double samplingInterval = itemToModify.RequestedParameters.SamplingInterval;
if (samplingInterval < 0)
{
samplingInterval = previousSamplingInterval;
}
// ensure minimum sampling interval is not exceeded.
if (datachangeItem.AttributeId == Attributes.Value)
{
BaseVariableState variable = handle.Node as BaseVariableState;
if (variable != null && samplingInterval < variable.MinimumSamplingInterval)
{
samplingInterval = variable.MinimumSamplingInterval;
}
}
// put a large upper limit on sampling.
if (samplingInterval == Double.MaxValue)
{
samplingInterval = 365 * 24 * 3600 * 1000.0;
}
// put an upper limit on queue size.
uint queueSize = itemToModify.RequestedParameters.QueueSize;
if (queueSize > m_maxQueueSize)
{
queueSize = m_maxQueueSize;
}
// validate the monitoring filter.
Range euRange = null;
MonitoringFilter filterToUse = null;
ServiceResult error = ValidateMonitoringFilter(
context,
handle,
datachangeItem.AttributeId,
samplingInterval,
queueSize,
parameters.Filter,
out filterToUse,
out euRange,
out filterResult);
if (ServiceResult.IsBad(error))
{
return error;
}
// modify the monitored item parameters.
error = datachangeItem.ModifyAttributes(
diagnosticsMasks,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
filterToUse,
filterToUse,
euRange,
samplingInterval,
queueSize,
itemToModify.RequestedParameters.DiscardOldest);
// report change.
if (ServiceResult.IsGood(error))
{
OnMonitoredItemModified(context, handle, datachangeItem);
}
return error;
}
/// <summary>
/// Creates a new data change monitored item.
/// </summary>
public MemoryBufferMonitoredItem CreateDataChangeItem(
ServerSystemContext context,
MemoryTagState tag,
uint subscriptionId,
uint monitoredItemId,
ReadValueId itemToMonitor,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval)
/*
ISystemContext context,
MemoryTagState tag,
uint monitoredItemId,
uint attributeId,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval)*/
{
lock (m_dataLock)
{
MemoryBufferMonitoredItem monitoredItem = new MemoryBufferMonitoredItem(
m_server,
m_nodeManager,
this,
tag.Offset,
0,
monitoredItemId,
context.OperationContext.Session,
itemToMonitor,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
null,
null,
null,
samplingInterval,
0,
false,
0);
/*
MemoryBufferMonitoredItem monitoredItem = new MemoryBufferMonitoredItem(
this,
monitoredItemId,
tag.Offset,
attributeId,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
samplingInterval);
*/
if (itemToMonitor.AttributeId != Attributes.Value)
{
m_nonValueMonitoredItems.Add(monitoredItem.Id, monitoredItem);
return monitoredItem;
}
int elementCount = (int)(SizeInBytes.Value / ElementSize);
if (m_monitoringTable == null)
{
m_monitoringTable = new MemoryBufferMonitoredItem[elementCount][];
m_scanTimer = new Timer(DoScan, null, 100, 100);
}
int elementOffet = (int)(tag.Offset / ElementSize);
MemoryBufferMonitoredItem[] monitoredItems = m_monitoringTable[elementOffet];
if (monitoredItems == null)
{
monitoredItems = new MemoryBufferMonitoredItem[1];
}
else
{
monitoredItems = new MemoryBufferMonitoredItem[monitoredItems.Length + 1];
m_monitoringTable[elementOffet].CopyTo(monitoredItems, 0);
}
monitoredItems[monitoredItems.Length - 1] = monitoredItem;
m_monitoringTable[elementOffet] = monitoredItems;
m_itemCount++;
return monitoredItem;
}
}
/// <summary>
/// Gets the result for the read operayoin.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="item">The item.</param>
/// <param name="nodeToRead">The node to read.</param>
/// <param name="value">The value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public ServiceResult GetResult(
ISystemContext context,
DaItemState item,
ReadValueId nodeToRead,
DataValue value,
DiagnosticsMasks diagnosticsMasks)
{
if (nodeToRead.AttributeId == Attributes.Value)
{
ServiceResult result = GetItemValue(m_value, value, diagnosticsMasks);
if (ServiceResult.IsBad(result))
{
return(result);
}
return(ApplyIndexRangeAndDataEncoding(context, nodeToRead, value));
}
switch (nodeToRead.AttributeId)
{
case Attributes.Description:
{
string description = this.GetPropertyValue <string>(Opc.Ua.Com.PropertyIds.Description, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = new LocalizedText(description);
}
break;
}
case Attributes.DataType:
{
short datatype = this.GetPropertyValue <short>(Opc.Ua.Com.PropertyIds.DataType, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = ComUtils.GetDataTypeId(datatype);
}
break;
}
case Attributes.ValueRank:
{
short datatype = this.GetPropertyValue <short>(Opc.Ua.Com.PropertyIds.DataType, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = ComUtils.GetValueRank(datatype);
}
break;
}
case Attributes.AccessLevel:
case Attributes.UserAccessLevel:
{
int accessRights = this.GetPropertyValue <int>(Opc.Ua.Com.PropertyIds.AccessRights, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = (byte)accessRights;
}
break;
}
case Attributes.MinimumSamplingInterval:
{
float scanRate = this.GetPropertyValue <float>(Opc.Ua.Com.PropertyIds.ScanRate, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = (double)scanRate;
}
break;
}
default:
{
return(StatusCodes.BadAttributeIdInvalid);
}
}
// check if the property value is missing.
if (value.StatusCode == StatusCodes.BadNotFound)
{
return(StatusCodes.BadAttributeIdInvalid);
}
return(ApplyIndexRangeAndDataEncoding(context, nodeToRead, value));
}
/// <summary>
/// Initializes the context with a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
public OperationContext(Session session, DiagnosticsMasks diagnosticsMasks)
{
if (session == null) throw new ArgumentNullException("session");
m_channelContext = null;
m_session = session;
m_identity = session.EffectiveIdentity;
m_preferredLocales = session.PreferredLocales;
m_diagnosticsMask = diagnosticsMasks;
m_stringTable = new StringTable();
m_auditLogEntryId = null;
m_requestId = 0;
m_requestType = RequestType.Unknown;
m_clientHandle = 0;
m_operationDeadline = DateTime.MaxValue;
}
/// <summary>
/// Initializes the object with a service result.
/// </summary>
/// <remarks>
/// Initializes the object with a service result.
/// </remarks>
/// <param name="diagnosticsMask">The bitmask describing the type of diagnostic data</param>
/// <param name="result">The transaction result</param>
/// <param name="stringTable">An array of strings that may be used to provide additional diagnostic details</param>
private void Initialize(
ServiceResult result,
DiagnosticsMasks diagnosticsMask,
StringTable stringTable)
{
if (stringTable == null)
{
throw new ArgumentNullException(nameof(stringTable));
}
m_symbolicId = -1;
m_namespaceUri = -1;
m_locale = -1;
m_localizedText = -1;
m_additionalInfo = null;
m_innerStatusCode = StatusCodes.Good;
m_innerDiagnosticInfo = null;
if ((DiagnosticsMasks.ServiceSymbolicId & diagnosticsMask) != 0)
{
string symbolicId = result.SymbolicId;
string namespaceUri = result.NamespaceUri;
if (!String.IsNullOrEmpty(symbolicId))
{
m_symbolicId = stringTable.GetIndex(result.SymbolicId);
if (m_symbolicId == -1)
{
m_symbolicId = stringTable.Count;
stringTable.Append(symbolicId);
}
if (!String.IsNullOrEmpty(namespaceUri))
{
m_namespaceUri = stringTable.GetIndex(namespaceUri);
if (m_namespaceUri == -1)
{
m_namespaceUri = stringTable.Count;
stringTable.Append(namespaceUri);
}
}
}
}
if ((DiagnosticsMasks.ServiceLocalizedText & diagnosticsMask) != 0)
{
if (!Opc.Ua.LocalizedText.IsNullOrEmpty(result.LocalizedText))
{
if (!String.IsNullOrEmpty(result.LocalizedText.Locale))
{
m_locale = stringTable.GetIndex(result.LocalizedText.Locale);
if (m_locale == -1)
{
m_locale = stringTable.Count;
stringTable.Append(result.LocalizedText.Locale);
}
}
m_localizedText = stringTable.GetIndex(result.LocalizedText.Text);
if (m_localizedText == -1)
{
m_localizedText = stringTable.Count;
stringTable.Append(result.LocalizedText.Text);
}
}
}
if ((DiagnosticsMasks.ServiceAdditionalInfo & diagnosticsMask) != 0)
{
m_additionalInfo = result.AdditionalInfo;
}
if (result.InnerResult != null)
{
if ((DiagnosticsMasks.ServiceInnerStatusCode & diagnosticsMask) != 0)
{
m_innerStatusCode = result.InnerResult.StatusCode;
}
// recursively append the inner diagnostics.
if ((DiagnosticsMasks.ServiceInnerDiagnostics & diagnosticsMask) != 0)
{
m_innerDiagnosticInfo = new DiagnosticInfo(
result.InnerResult,
diagnosticsMask,
true,
stringTable);
}
}
}
/// <summary>
/// Modifies the parameters for a monitored item.
/// </summary>
protected virtual ServiceResult ModifyMonitoredItem(
ISystemContext context,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
IMonitoredItem monitoredItem,
MonitoredItemModifyRequest itemToModify,
out MonitoringFilterResult filterError)
{
filterError = null;
ServiceResult error = null;
// check for valid handle.
MonitoredNode monitoredNode = monitoredItem.ManagerHandle as MonitoredNode;
if (monitoredNode == null)
{
return ServiceResult.Good;
}
if (IsHandleInNamespace(monitoredNode.Node) == null)
{
return ServiceResult.Good;
}
// owned by this node manager.
itemToModify.Processed = true;
// check for valid monitored item.
DataChangeMonitoredItem datachangeItem = monitoredItem as DataChangeMonitoredItem;
// validate parameters.
MonitoringParameters parameters = itemToModify.RequestedParameters;
// validate the data change filter.
DataChangeFilter filter = null;
Range range = null;
if (!ExtensionObject.IsNull(parameters.Filter))
{
error = ValidateDataChangeFilter(
context,
monitoredNode.Node,
datachangeItem.AttributeId,
parameters.Filter,
out filter,
out range);
if (ServiceResult.IsBad(error))
{
return error;
}
}
double previousSamplingInterval = datachangeItem.SamplingInterval;
// check if the variable needs to be sampled.
double samplingInterval = itemToModify.RequestedParameters.SamplingInterval;
if (datachangeItem.AttributeId == Attributes.Value)
{
BaseVariableState variable = monitoredNode.Node as BaseVariableState;
if (variable.MinimumSamplingInterval > 0)
{
samplingInterval = CalculateSamplingInterval(variable, samplingInterval);
}
}
// modify the monitored item parameters.
error = datachangeItem.Modify(
diagnosticsMasks,
timestampsToReturn,
itemToModify.RequestedParameters.ClientHandle,
samplingInterval,
itemToModify.RequestedParameters.QueueSize,
itemToModify.RequestedParameters.DiscardOldest,
filter,
range);
// do any post processing.
OnModifyMonitoredItem(
context,
itemToModify,
monitoredNode,
datachangeItem,
previousSamplingInterval);
return ServiceResult.Good;
}
/// <summary>
/// Modifies the attributes for monitored item.
/// </summary>
public ServiceResult ModifyAttributes(
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
uint clientHandle,
MonitoringFilter originalFilter,
MonitoringFilter filterToUse,
Range range,
double samplingInterval,
uint queueSize,
bool discardOldest)
{
lock (m_lock)
{
m_diagnosticsMasks = diagnosticsMasks;
m_timestampsToReturn = timestampsToReturn;
m_clientHandle = clientHandle;
m_discardOldest = discardOldest;
m_originalFilter = originalFilter;
m_filterToUse = filterToUse;
if (range != null)
{
m_range = range.High - range.Low;
}
SetSamplingInterval(samplingInterval);
m_queueSize = queueSize;
// check if aggregate filter has been updated.
ServerAggregateFilter aggregateFilter = filterToUse as ServerAggregateFilter;
if (filterToUse is ServerAggregateFilter)
{
ServerAggregateFilter existingFilter = filterToUse as ServerAggregateFilter;
bool match = existingFilter != null;
if (match) if (existingFilter.AggregateType != aggregateFilter.AggregateType) match = false;
if (match) if (existingFilter.ProcessingInterval != aggregateFilter.ProcessingInterval) match = false;
if (match) if (existingFilter.StartTime != aggregateFilter.StartTime) match = false;
if (match) if (!existingFilter.AggregateConfiguration.IsEqual(aggregateFilter.AggregateConfiguration)) match = false;
if (!match)
{
m_calculator = m_server.AggregateManager.CreateCalculator(
aggregateFilter.AggregateType,
aggregateFilter.StartTime,
DateTime.MaxValue,
aggregateFilter.ProcessingInterval,
aggregateFilter.Stepped,
aggregateFilter.AggregateConfiguration);
}
}
// report change to item state.
ServerUtils.ReportModifyMonitoredItem(
m_nodeId,
m_id,
m_samplingInterval,
m_queueSize,
m_discardOldest,
m_filterToUse,
m_monitoringMode);
InitializeQueue();
return null;
}
}
/// <summary>
/// Converts the object to an ContentFilterElementResult.
/// </summary>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <param name="stringTable">The string table.</param>
/// <returns></returns>
public ContentFilterElementResult ToContentFilterElementResult(DiagnosticsMasks diagnosticsMasks, StringTable stringTable)
{
ContentFilterElementResult result = new ContentFilterElementResult();
if (ServiceResult.IsGood(m_status))
{
result.StatusCode = StatusCodes.Good;
return result;
}
result.StatusCode = m_status.StatusCode;
if (m_operandResults.Count == 0)
{
return result;
}
foreach (ServiceResult operandResult in m_operandResults)
{
if (ServiceResult.IsGood(operandResult))
{
result.OperandStatusCodes.Add(StatusCodes.Good);
result.OperandDiagnosticInfos.Add(null);
}
else
{
result.OperandStatusCodes.Add(operandResult.StatusCode);
result.OperandDiagnosticInfos.Add(new DiagnosticInfo(operandResult, diagnosticsMasks, false, stringTable));
}
}
return result;
}
/// <summary>
/// Creates a new data change monitored item.
/// </summary>
public MemoryBufferMonitoredItem CreateDataChangeItem(
ServerSystemContext context,
MemoryTagState tag,
uint subscriptionId,
uint monitoredItemId,
ReadValueId itemToMonitor,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
double samplingInterval)
/*
* ISystemContext context,
* MemoryTagState tag,
* uint monitoredItemId,
* uint attributeId,
* DiagnosticsMasks diagnosticsMasks,
* TimestampsToReturn timestampsToReturn,
* MonitoringMode monitoringMode,
* uint clientHandle,
* double samplingInterval)*/
{
lock (m_dataLock)
{
MemoryBufferMonitoredItem monitoredItem = new MemoryBufferMonitoredItem(
m_server,
m_nodeManager,
this,
tag.Offset,
0,
monitoredItemId,
context.OperationContext.Session,
itemToMonitor,
diagnosticsMasks,
timestampsToReturn,
monitoringMode,
clientHandle,
null,
null,
null,
samplingInterval,
0,
false,
0);
/*
* MemoryBufferMonitoredItem monitoredItem = new MemoryBufferMonitoredItem(
* this,
* monitoredItemId,
* tag.Offset,
* attributeId,
* diagnosticsMasks,
* timestampsToReturn,
* monitoringMode,
* clientHandle,
* samplingInterval);
*/
if (itemToMonitor.AttributeId != Attributes.Value)
{
m_nonValueMonitoredItems.Add(monitoredItem.Id, monitoredItem);
return(monitoredItem);
}
int elementCount = (int)(SizeInBytes.Value / ElementSize);
if (m_monitoringTable == null)
{
m_monitoringTable = new MemoryBufferMonitoredItem[elementCount][];
m_scanTimer = new Timer(DoScan, null, 100, 100);
}
int elementOffet = (int)(tag.Offset / ElementSize);
MemoryBufferMonitoredItem[] monitoredItems = m_monitoringTable[elementOffet];
if (monitoredItems == null)
{
monitoredItems = new MemoryBufferMonitoredItem[1];
}
else
{
monitoredItems = new MemoryBufferMonitoredItem[monitoredItems.Length + 1];
m_monitoringTable[elementOffet].CopyTo(monitoredItems, 0);
}
monitoredItems[monitoredItems.Length - 1] = monitoredItem;
m_monitoringTable[elementOffet] = monitoredItems;
m_itemCount++;
return(monitoredItem);
}
}
/// <summary>
/// Initializes the object with its node type.
/// </summary>
public MonitoredItem(
IServerInternal server,
INodeManager nodeManager,
object mangerHandle,
uint subscriptionId,
uint id,
Session session,
ReadValueId itemToMonitor,
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
MonitoringMode monitoringMode,
uint clientHandle,
MonitoringFilter originalFilter,
MonitoringFilter filterToUse,
Range range,
double samplingInterval,
uint queueSize,
bool discardOldest,
double sourceSamplingInterval)
{
if (itemToMonitor == null) throw new ArgumentNullException("itemToMonitor");
Initialize();
m_server = server;
m_nodeManager = nodeManager;
m_managerHandle = mangerHandle;
m_subscriptionId = subscriptionId;
m_id = id;
m_session = session;
m_nodeId = itemToMonitor.NodeId;
m_attributeId = itemToMonitor.AttributeId;
m_indexRange = itemToMonitor.IndexRange;
m_parsedIndexRange = itemToMonitor.ParsedIndexRange;
m_encoding = itemToMonitor.DataEncoding;
m_diagnosticsMasks = diagnosticsMasks;
m_timestampsToReturn = timestampsToReturn;
m_monitoringMode = monitoringMode;
m_clientHandle = clientHandle;
m_originalFilter = originalFilter;
m_filterToUse = filterToUse;
m_range = 0;
m_samplingInterval = samplingInterval;
m_queueSize = queueSize;
m_discardOldest = discardOldest;
m_sourceSamplingInterval = (int)sourceSamplingInterval;
m_calculator = null;
m_nextSamplingTime = DateTime.UtcNow.Ticks;
m_alwaysReportUpdates = false;
m_typeMask = MonitoredItemTypeMask.DataChange;
if (originalFilter is EventFilter)
{
m_typeMask = MonitoredItemTypeMask.Events;
if (itemToMonitor.NodeId == Objects.Server)
{
m_typeMask |= MonitoredItemTypeMask.AllEvents;
}
}
// create aggregate calculator.
ServerAggregateFilter aggregateFilter = filterToUse as ServerAggregateFilter;
if (filterToUse is ServerAggregateFilter)
{
m_calculator = m_server.AggregateManager.CreateCalculator(
aggregateFilter.AggregateType,
aggregateFilter.StartTime,
DateTime.MaxValue,
aggregateFilter.ProcessingInterval,
aggregateFilter.Stepped,
aggregateFilter.AggregateConfiguration);
}
if (range != null)
{
m_range = range.High - range.Low;
}
// report change to item state.
ServerUtils.ReportCreateMonitoredItem(
m_nodeId,
m_id,
m_samplingInterval,
m_queueSize,
m_discardOldest,
m_filterToUse,
m_monitoringMode);
InitializeQueue();
}
/// <summary>
/// Gets the result for the read operation.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="property">The property.</param>
/// <param name="nodeToRead">The node to read.</param>
/// <param name="value">The value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public ServiceResult GetResult(
ISystemContext context,
PropertyState property,
ReadValueId nodeToRead,
DataValue value,
DiagnosticsMasks diagnosticsMasks)
{
DaItemState item = property.Parent as DaItemState;
if (item == null)
{
return(StatusCodes.BadNodeIdUnknown);
}
if (nodeToRead.AttributeId != Attributes.Value)
{
return(StatusCodes.BadAttributeIdInvalid);
}
switch (property.SymbolicName)
{
case Opc.Ua.BrowseNames.EURange:
{
double high = this.GetPropertyValue <double>(Opc.Ua.Com.PropertyIds.HighEU, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
double low = this.GetPropertyValue <double>(Opc.Ua.Com.PropertyIds.LowEU, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = new Range(high, low);
break;
}
case Opc.Ua.BrowseNames.InstrumentRange:
{
double high = this.GetPropertyValue <double>(Opc.Ua.Com.PropertyIds.HighIR, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
double low = this.GetPropertyValue <double>(Opc.Ua.Com.PropertyIds.LowIR, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = new Range(high, low);
break;
}
case Opc.Ua.BrowseNames.EngineeringUnits:
{
string units = this.GetPropertyValue <string>(Opc.Ua.Com.PropertyIds.EngineeringUnits, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = new EUInformation(units, Namespaces.ComInterop);
break;
}
case Opc.Ua.BrowseNames.EnumStrings:
{
string[] strings = this.GetPropertyValue <string[]>(Opc.Ua.Com.PropertyIds.EuInfo, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
if (strings != null)
{
LocalizedText[] texts = new LocalizedText[strings.Length];
for (int ii = 0; ii < texts.Length; ii++)
{
texts[ii] = new LocalizedText(strings[ii]);
}
value.Value = texts;
}
break;
}
case Opc.Ua.BrowseNames.LocalTime:
{
int timebias = this.GetPropertyValue <int>(Opc.Ua.Com.PropertyIds.TimeZone, value, true);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
TimeZoneDataType timeZone = new TimeZoneDataType();
timeZone.Offset = (short)timebias;
timeZone.DaylightSavingInOffset = false;
value.Value = timeZone;
break;
}
case Opc.Ua.BrowseNames.TrueState:
{
string description = this.GetPropertyValue <string>(Opc.Ua.Com.PropertyIds.CloseLabel, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = new LocalizedText(description);
}
break;
}
case Opc.Ua.BrowseNames.FalseState:
{
string description = this.GetPropertyValue <string>(Opc.Ua.Com.PropertyIds.OpenLabel, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = new LocalizedText(description);
}
break;
}
default:
{
return(StatusCodes.BadAttributeIdInvalid);
}
}
// check if the property value is missing.
if (value.StatusCode == StatusCodes.BadNotFound)
{
return(StatusCodes.BadNodeIdUnknown);
}
return(ApplyIndexRangeAndDataEncoding(context, nodeToRead, value));
}
/// <summary>
/// Modifies the monitored item parameters,
/// </summary>
public ServiceResult Modify(
DiagnosticsMasks diagnosticsMasks,
TimestampsToReturn timestampsToReturn,
uint clientHandle,
double samplingInterval)
{
return base.ModifyAttributes(diagnosticsMasks,
timestampsToReturn,
clientHandle,
null,
null,
null,
samplingInterval,
0,
false);
}
/// <summary>
/// Gets the result for the read operayoin.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="item">The item.</param>
/// <param name="nodeToRead">The node to read.</param>
/// <param name="value">The value.</param>
/// <param name="diagnosticsMasks">The diagnostics masks.</param>
/// <returns></returns>
public ServiceResult GetResult(
ISystemContext context,
HdaItemState item,
ReadValueId nodeToRead,
DataValue value,
DiagnosticsMasks diagnosticsMasks)
{
switch (nodeToRead.AttributeId)
{
case Attributes.Description:
{
string description = this.GetAttributeValue <string>(Constants.OPCHDA_DESCRIPTION, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = new LocalizedText(description);
}
break;
}
case Attributes.DataType:
{
short datatype = this.GetAttributeValue <short>(Constants.OPCHDA_DATA_TYPE, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = ComUtils.GetDataTypeId(datatype);
}
else
{
value.Value = DataTypeIds.BaseDataType;
value.StatusCode = StatusCodes.GoodLocalOverride;
}
break;
}
case Attributes.ValueRank:
{
short datatype = this.GetAttributeValue <short>(Constants.OPCHDA_DATA_TYPE, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = ComUtils.GetValueRank(datatype);
}
else
{
value.Value = ValueRanks.Any;
value.StatusCode = StatusCodes.GoodLocalOverride;
}
break;
}
case Attributes.Historizing:
{
bool archiving = this.GetAttributeValue <bool>(Constants.OPCHDA_ARCHIVING, value, false);
if (StatusCode.IsGood(value.StatusCode))
{
value.Value = archiving;
}
else
{
value.Value = false;
value.StatusCode = StatusCodes.GoodLocalOverride;
}
break;
}
default:
{
return(StatusCodes.BadAttributeIdInvalid);
}
}
// check if the attribute value is missing.
if (value.StatusCode == StatusCodes.BadNotFound)
{
return(StatusCodes.BadAttributeIdInvalid);
}
return(ApplyIndexRangeAndDataEncoding(context, nodeToRead, value));
}
