/// <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 cref="IFilterTarget.GetAttributeValue" />
public virtual object GetAttributeValue(
FilterContext context,
NodeId typeDefinitionId,
IList<QualifiedName> relativePath,
uint attributeId,
NumericRange indexRange)
{
if (context == null) throw new ArgumentNullException("context");
// read the attribute value.
DataValue dataValue = ReadAttributeValue(
context,
typeDefinitionId,
relativePath,
attributeId,
indexRange);
if (StatusCode.IsBad(dataValue.StatusCode))
{
return dataValue.StatusCode;
}
// return the value.
return dataValue.Value;
}
/// <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)
{
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>
/// Continues a read raw operation.
/// </summary>
/// <param name="context">The context for the operation.</param>
/// <param name="timestampsToReturn">The timestamps to return with the value.</param>
/// <param name="indexRange">The range to return for array values.</param>
/// <param name="dataEncoding">The data encoding to use for structured values.</param>
/// <param name="values">The values to return.</param>
/// <returns>False if the operation halted because the maximum number of values was discovered.</returns>
public bool NextReadRaw(
#pragma warning disable RECS0154 // Parameter is never used
ServerSystemContext context,
#pragma warning restore RECS0154 // Parameter is never used
TimestampsToReturn timestampsToReturn,
NumericRange indexRange,
QualifiedName dataEncoding,
DataValueCollection values)
{
DataValue value = null;
do
{
// check for limit.
if (_request.NumValuesPerNode > 0 && values.Count >= _request.NumValuesPerNode)
{
return(false);
}
value = _source.NextRaw(_lastTime, _isForward, _request.IsReadModified, ref _position);
// no more data.
if (value == null)
{
return(true);
}
// check for bound.
if ((_isForward && value.ServerTimestamp >= _endTime) || (!_isForward && value.ServerTimestamp <= _endTime))
{
if (_request.ReturnBounds)
{
AddValue(timestampsToReturn, indexRange, dataEncoding, values, value);
return(true);
}
}
// add value.
AddValue(timestampsToReturn, indexRange, dataEncoding, values, value);
}while (value != null);
return(true);
}
public ServiceResult OnWrite(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
BaseDataVariableState variable = node as BaseDataVariableState;
// verify data type.
Opc.Ua.TypeInfo typeInfo = Opc.Ua.TypeInfo.IsInstanceOfDataType(
value,
variable.DataType,
variable.ValueRank,
context.NamespaceUris,
context.TypeTable);
if (typeInfo == null || typeInfo == Opc.Ua.TypeInfo.Unknown)
{
return StatusCodes.BadTypeMismatch;
}
// check index range.
if (variable.ValueRank >= 0)
{
if (indexRange != NumericRange.Empty)
{
object target = variable.Value;
ServiceResult result = indexRange.UpdateRange(ref target, value);
if (ServiceResult.IsBad(result))
{
return result;
}
value = target;
}
}
return ServiceResult.Good;
}
private ServiceResult OnWriteValueDiscrete(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
MultiStateValueDiscreteState variable = node as MultiStateValueDiscreteState;
TypeInfo typeInfo = TypeInfo.Construct(value);
if (variable == null ||
typeInfo == null ||
typeInfo == Opc.Ua.TypeInfo.Unknown ||
!TypeInfo.IsNumericType(typeInfo.BuiltInType))
{
return(StatusCodes.BadTypeMismatch);
}
if (indexRange != NumericRange.Empty)
{
return(StatusCodes.BadIndexRangeInvalid);
}
Int32 number = Convert.ToInt32(value);
if (number >= variable.EnumValues.Value.Length || number < 0)
{
return(StatusCodes.BadOutOfRange);
}
if (!node.SetChildValue(context, BrowseNames.ValueAsText, variable.EnumValues.Value[number].DisplayName,
true))
{
return(StatusCodes.BadOutOfRange);
}
node.ClearChangeMasks(context, true);
return(ServiceResult.Good);
}
private void OkBTN_Click(object sender, EventArgs e)
{
try {
NodeId nodeId = NodeIdCTRL.Identifier;
} catch (Exception) {
MessageBox.Show("Please enter a valid node id.", this.Text);
}
try {
if (!String.IsNullOrEmpty(IndexRangeTB.Text))
{
NumericRange indexRange = NumericRange.Parse(IndexRangeTB.Text);
}
} catch (Exception) {
MessageBox.Show("Please enter a valid index range.", this.Text);
}
DialogResult = DialogResult.OK;
}
/// <summary>
/// Gets the last bound if requested.
/// </summary>
private DataValue GetLastBound(
ISystemContext context,
NumericRange indexRange,
QualifiedName dataEncoding)
{
if (m_lastBoundReturned)
{
return(null);
}
m_lastBoundReturned = true;
if (!ReturnBounds)
{
return(null);
}
if (m_mergedSeries == null && m_historyData == null)
{
return(null);
}
if (EndTime == DateTime.MinValue)
{
return(null);
}
m_position = ((m_mergedSeries != null)?m_mergedSeries.Count:m_historyData.Length) - 1;
DataValue lastValue = NextValue(context, indexRange, dataEncoding);
if (lastValue == null)
{
return(null);
}
if (lastValue.SourceTimestamp == EndTime)
{
return(null);
}
return(new DataValue(Variant.Null, StatusCodes.BadBoundNotSupported, EndTime, EndTime));
}
public static NumericRange ResolveIndexRange(this string indexRange)
{
NumericRange resolvedIndexRange = new NumericRange(0, 0);
if (!string.IsNullOrEmpty(indexRange))
{
try
{
resolvedIndexRange = NumericRange.Parse(indexRange);
}
catch (Exception e)
{
string errorMessage = $"The given IndexRange '{indexRange}' in a select clause has not a valid syntax.";
Logger.Error(e, errorMessage);
throw new Exception(errorMessage);
}
}
return(resolvedIndexRange);
}
/// <summary>
/// Writes the valus to the server.
/// </summary>
private void Write()
{
WriteValueCollection nodesToWrite = Utils.Clone(WriteValuesCTRL.GetValues()) as WriteValueCollection;
if (nodesToWrite == null || nodesToWrite.Count == 0)
{
return;
}
foreach (WriteValue nodeToWrite in nodesToWrite)
{
NumericRange indexRange;
ServiceResult result = NumericRange.Validate(nodeToWrite.IndexRange, out indexRange);
if (ServiceResult.IsGood(result) && indexRange != NumericRange.Empty)
{
// apply the index range.
object valueToWrite = nodeToWrite.Value.Value;
result = indexRange.ApplyRange(ref valueToWrite);
if (ServiceResult.IsGood(result))
{
nodeToWrite.Value.Value = valueToWrite;
}
}
}
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = m_session.Write(
null,
nodesToWrite,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToWrite);
WriteResultsCTRL.ShowValue(results, true);
}
/// <summary>
/// Continues a read raw operation.
/// </summary>
/// <param name="context">The context for the operation.</param>
/// <param name="timestampsToReturn">The timestamps to return with the value.</param>
/// <param name="indexRange">The range to return for array values.</param>
/// <param name="dataEncoding">The data encoding to use for structured values.</param>
/// <param name="values">The values to return.</param>
/// <returns>False if the operation halted because the maximum number of values was discovered.</returns>
public bool NextReadRaw(
ServerSystemContext context,
TimestampsToReturn timestampsToReturn,
NumericRange indexRange,
QualifiedName dataEncoding,
DataValueCollection values)
{
DataValue value = null;
do
{
// check for limit.
if (m_request.NumValuesPerNode > 0 && values.Count >= m_request.NumValuesPerNode)
{
return(false);
}
value = m_source.NextRaw(m_lastTime, m_isForward, m_request.IsReadModified, ref m_position);
// no more data.
if (value == null)
{
return(true);
}
// check for bound.
if ((m_isForward && value.ServerTimestamp >= m_endTime) ||
(!m_isForward && value.ServerTimestamp <= m_endTime))
{
if (m_request.ReturnBounds)
{
AddValue(timestampsToReturn, indexRange, dataEncoding, values, value);
return(true);
}
}
// add value.
AddValue(timestampsToReturn, indexRange, dataEncoding, values, value);
} while (value != null);
return(true);
}
/// <summary>
/// Constructs a new <see cref="MonteCarloIntegration">Monte Carlo integration method</see>.
/// </summary>
/// <param name="parameters">The number of parameters expected by the integrand.</param>
public MonteCarloIntegration(int parameters)
{
if (parameters <= 0)
{
throw new ArgumentOutOfRangeException("parameters",
"Number of parameters must be higher than zero.");
}
NumberOfParameters = parameters;
Range = new NumericRange[parameters];
Random = new System.Random(Framework.Mathematics.Random.Generator.Random.Next());
for (var i = 0; i < Range.Length; i++)
{
Range[i].Max = 1;
}
Iterations = 1000;
Reset();
}
// ***START***
#region _ChildName_ Access Methods
/// <summary>
/// Reads the value of the variable child.
/// </summary>
private ServiceResult OnRead__ChildName_(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
lock (Lock)
{
DoBeforeReadProcessing(context, node);
if (m_value != null)
{
value = m_value._ChildPath_;
}
return(Read(context, node, indexRange, dataEncoding, ref value, ref statusCode, ref timestamp));
}
}
/// <summary>
/// Starts reading raw values.
/// </summary>
/// <param name="context">The context for the operation.</param>
/// <param name="request">The request parameters.</param>
/// <param name="timestampsToReturn">The timestamps to return with the value.</param>
/// <param name="indexRange">The range to return for array values.</param>
/// <param name="dataEncoding">The data encoding to use for structured values.</param>
/// <param name="values">The values to return.</param>
public void BeginReadRaw(
#pragma warning disable RECS0154 // Parameter is never used
#pragma warning disable IDE0060 // Remove unused parameter
ServerSystemContext context,
#pragma warning restore IDE0060 // Remove unused parameter
#pragma warning restore RECS0154 // Parameter is never used
ReadRawModifiedDetails request,
TimestampsToReturn timestampsToReturn,
NumericRange indexRange,
QualifiedName dataEncoding,
DataValueCollection values)
{
_request = request;
// initialize start and end.
_startTime = _request.StartTime;
_endTime = _request.EndTime;
if (_endTime == DateTime.MinValue)
{
_endTime = DateTime.MaxValue;
}
// check the direction.
_isForward = _startTime < _endTime;
_position = -1;
DataValue value = null;
// get first bound.
if (_request.ReturnBounds)
{
value = _source.FirstRaw(_startTime, !_isForward, _request.IsReadModified, out _position);
if (value != null)
{
AddValue(timestampsToReturn, indexRange, dataEncoding, values, value);
}
}
}
public StatusCodeCollection Write(WriteValueCollection nodesToWrite)
{
if (nodesToWrite == null || nodesToWrite.Count == 0)
{
return(null);
}
foreach (WriteValue nodeToWrite in nodesToWrite)
{
NumericRange indexRange;
ServiceResult result = NumericRange.Validate(nodeToWrite.IndexRange, out indexRange);
if (ServiceResult.IsGood(result) && indexRange != NumericRange.Empty)
{
// apply the index range.
object valueToWrite = nodeToWrite.Value.Value;
result = indexRange.ApplyRange(ref valueToWrite);
if (ServiceResult.IsGood(result))
{
nodeToWrite.Value.Value = valueToWrite;
}
}
}
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = _uaSession.Write(
null,
nodesToWrite,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToWrite);
return(results);
}
private void OkBTN_Click(object sender, EventArgs e)
{
try
{
IndexRangeTB.Text = IndexRangeTB.Text.Trim();
if (String.IsNullOrEmpty(IndexRangeTB.Text))
{
NumericRange.Parse(IndexRangeTB.Text);
}
StatusCodeTB.Text = StatusCodeTB.Text.Trim();
if (StatusCodeCK.Checked)
{
TypeInfo.Cast(StatusCodeTB.Text, BuiltInType.StatusCode);
}
SourceTimestampTB.Text = SourceTimestampTB.Text.Trim();
if (SourceTimestampCK.Checked)
{
TypeInfo.Cast(SourceTimestampTB.Text, BuiltInType.DateTime);
}
ServerTimestampTB.Text = ServerTimestampTB.Text.Trim();
if (ServerTimestampCK.Checked)
{
TypeInfo.Cast(ServerTimestampTB.Text, BuiltInType.DateTime);
}
DialogResult = DialogResult.OK;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
private ServiceResult OnWriteDiscrete(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
MultiStateDiscreteState variable = node as MultiStateDiscreteState;
// verify data type.
Opc.Ua.TypeInfo typeInfo = Opc.Ua.TypeInfo.IsInstanceOfDataType(
value,
variable.DataType,
variable.ValueRank,
context.NamespaceUris,
context.TypeTable);
if (typeInfo == null || typeInfo == Opc.Ua.TypeInfo.Unknown)
{
return(StatusCodes.BadTypeMismatch);
}
if (indexRange != NumericRange.Empty)
{
return(StatusCodes.BadIndexRangeInvalid);
}
double number = Convert.ToDouble(value);
if (number >= variable.EnumStrings.Value.Length | number < 0)
{
return(StatusCodes.BadOutOfRange);
}
return(ServiceResult.Good);
}
private void Init(NumericRange value, NumericUpDownHint hint)
{
if (_control != null)
{
return;
}
FlowLayoutPanel panel = new FlowLayoutPanel();
panel.FlowDirection = FlowDirection.LeftToRight;
panel.AutoSize = true;
Label lblFrom = new Label();
lblFrom.Text = "From";
panel.Controls.Add(lblFrom);
_numericFrom = new NumericUpDown();
_numericFrom.Minimum = hint.Minimum;
_numericFrom.Maximum = hint.Maximum;
_numericFrom.Increment = hint.Increment;
panel.Controls.Add(_numericFrom);
Label lblTo = new Label();
lblTo.Text = "To";
panel.Controls.Add(lblTo);
_numericTo = new NumericUpDown();
_numericTo.Minimum = hint.Minimum;
_numericTo.Maximum = hint.Maximum;
_numericTo.Increment = hint.Increment;
panel.Controls.Add(_numericTo);
_control = panel;
Value = value;
}
/// <summary>
/// Starts reading raw values.
/// </summary>
/// <param name="context">The context for the operation.</param>
/// <param name="request">The request parameters.</param>
/// <param name="timestampsToReturn">The timestamps to return with the value.</param>
/// <param name="indexRange">The range to return for array values.</param>
/// <param name="dataEncoding">The data encoding to use for structured values.</param>
/// <param name="values">The values to return.</param>
public void BeginReadRaw(
ServerSystemContext context,
ReadRawModifiedDetails request,
TimestampsToReturn timestampsToReturn,
NumericRange indexRange,
QualifiedName dataEncoding,
DataValueCollection values)
{
m_request = request;
// initialize start and end.
m_startTime = m_request.StartTime;
m_endTime = m_request.EndTime;
if (m_endTime == DateTime.MinValue)
{
m_endTime = DateTime.MaxValue;
}
// check the direction.
m_isForward = m_startTime < m_endTime;
m_position = -1;
DataValue value = null;
// get first bound.
if (m_request.ReturnBounds)
{
value = m_source.FirstRaw(m_startTime, !m_isForward, m_request.IsReadModified, out m_position);
if (value != null)
{
AddValue(timestampsToReturn, indexRange, dataEncoding, values, value);
}
}
}
private async Task <EqulivalenceClass> CreateEqulivalenceClass(Dataset dataset, Dictionary <string, object> document)
{
var newClass = new EqulivalenceClass();
foreach (var categoricField in dataset.GetCategoricFields())
{
newClass.CategoricAttributes.Add(categoricField.Name, document[categoricField.Name] as string);
}
foreach (var intervalField in dataset.GetIntervalFields())
{
NumericRange range;
var exactValue = (double)document[intervalField.Name];
var size = intervalField.PreferedSize;
if (size != 0)
{
range = new NumericRange(exactValue - size / 2, exactValue + size / 2);
}
else
{
range = NumericRange.CreateDefault(exactValue);
}
newClass.IntervalAttributes.Add(intervalField.Name, range);
}
var result = await Api.CreateEqulivalenceClass(newClass);
//Check if the equlivalence class was created
await Api.GetMatchingEqulivalenceClasses(document);
return(result);
}
private void EditValueMI_Click(object sender, EventArgs e)
{
try {
WriteValue[] values = GetSelectedItems(typeof(WriteValue)) as WriteValue[];
if (values == null || values.Length != 1)
{
return;
}
NodeId datatypeId = Attributes.GetDataTypeId(values[0].AttributeId);
int valueRank = Attributes.GetValueRank(values[0].AttributeId);
if (values[0].AttributeId == Attributes.Value)
{
VariableNode node = m_session.NodeCache.Find(values[0].NodeId) as VariableNode;
if (node != null)
{
datatypeId = node.DataType;
valueRank = node.ValueRank;
}
}
bool useIndexRange = false;
object value = null;
// check IndexRange for arrays
if (values[0].AttributeId == Attributes.Value && valueRank > 0)
{
NumericRange indexRange;
ServiceResult result = NumericRange.Validate(values[0].IndexRange, out indexRange);
if (ServiceResult.IsGood(result) && indexRange != NumericRange.Empty)
{
useIndexRange = true;
}
}
if (useIndexRange)
{
value = new ComplexValueEditDlg().ShowDialog(values[0]);
WriteValue writeValue = value as WriteValue;
if (writeValue != null)
{
value = writeValue.Value.Value;
}
}
else
{
value = GuiUtils2.EditValue(m_session, values[0].Value.Value, datatypeId, valueRank);
}
if (value != null)
{
values[0].Value.Value = value;
values[0].Value.StatusCode = StatusCodes.Good;
UpdateItem(ItemsLV.SelectedItems[0], values[0]);
AdjustColumns();
}
} catch (Exception exception) {
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
public NumericUpDownPairBinder(NumericRange range, NumericUpDownHint hint)
{
Init(range, ((hint == null) ? new NumericUpDownHint() : hint));
}
/// <summary>
/// Data node in the server which registers ourselves with IoT Hub when this node is written.
/// </summary>
public ServiceResult OnConnectionStringWrite(ISystemContext context, NodeState node, NumericRange indexRange, QualifiedName dataEncoding, ref object value, ref StatusCode statusCode, ref DateTime timestamp)
{
var connectionString = value as string;
if (string.IsNullOrEmpty(connectionString))
{
Trace("ConnectionStringWrite: Invalid Argument!");
return(ServiceResult.Create(StatusCodes.BadArgumentsMissing, "Please provide all arguments as strings!"));
}
statusCode = StatusCodes.Bad;
timestamp = DateTime.Now;
// read current connection string and compare to the one passed in
string currentConnectionString = SecureIoTHubToken.Read(OpcConfiguration.ApplicationName, IotDeviceCertStoreType, IotDeviceCertStorePath);
if (string.Equals(connectionString, currentConnectionString, StringComparison.OrdinalIgnoreCase))
{
Trace("ConnectionStringWrite: Connection string up to date!");
return(ServiceResult.Create(StatusCodes.Bad, "Connection string already up-to-date!"));
}
Trace($"ConnectionStringWrite: Attempting to configure publisher with connection string: {connectionString}");
// configure publisher and write connection string
try
{
IotHubCommunication.ConnectionStringWrite(connectionString);
}
catch (Exception e)
{
statusCode = StatusCodes.Bad;
Trace(e, $"ConnectionStringWrite: Exception while trying to create IoTHub client and store device connection string in cert store");
return(ServiceResult.Create(StatusCodes.Bad, "Publisher registration failed: " + e.Message));
}
statusCode = StatusCodes.Good;
Trace("ConnectionStringWrite: Success!");
return(statusCode);
}
/// <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 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>
/// Handles a write operation for an individual tag.
/// </summary>
public ServiceResult WriteTagValue(
#pragma warning disable RECS0154 // Parameter is never used
#pragma warning disable IDE0060 // Remove unused parameter
ISystemContext context,
#pragma warning restore IDE0060 // Remove unused parameter
#pragma warning restore RECS0154 // Parameter is never used
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
if (!(node is MemoryTagState tag))
{
return(StatusCodes.BadNodeIdUnknown);
}
if (NumericRange.Empty != indexRange)
{
return(StatusCodes.BadIndexRangeInvalid);
}
if (!QualifiedName.IsNull(dataEncoding))
{
return(StatusCodes.BadDataEncodingInvalid);
}
if (statusCode != StatusCodes.Good)
{
return(StatusCodes.BadWriteNotSupported);
}
if (timestamp != DateTime.MinValue)
{
return(StatusCodes.BadWriteNotSupported);
}
var changed = false;
var offset = (int)tag.Offset;
lock (_dataLock) {
if (offset < 0 || offset >= _buffer.Length)
{
return(StatusCodes.BadNodeIdUnknown);
}
if (_buffer == null)
{
return(StatusCodes.BadOutOfService);
}
byte[] bytes = null;
switch (ElementType)
{
case BuiltInType.UInt32: {
var valueToWrite = value as uint?;
if (valueToWrite == null)
{
return(StatusCodes.BadTypeMismatch);
}
bytes = BitConverter.GetBytes(valueToWrite.Value);
break;
}
case BuiltInType.Double: {
var valueToWrite = value as double?;
if (valueToWrite == null)
{
return(StatusCodes.BadTypeMismatch);
}
bytes = BitConverter.GetBytes(valueToWrite.Value);
break;
}
default: {
return(StatusCodes.BadNodeIdUnknown);
}
}
for (var ii = 0; ii < bytes.Length; ii++)
{
if (!changed)
{
if (_buffer[offset + ii] != bytes[ii])
{
changed = true;
}
}
_buffer[offset + ii] = bytes[ii];
}
}
if (changed)
{
OnBufferChanged(offset);
}
return(ServiceResult.Good);
}
/// <summary cref="IFilterTarget.GetAttributeValue" />
public override object GetAttributeValue(
FilterContext context,
NodeId typeDefinitionId,
IList<QualifiedName> relativePath,
uint attributeId,
NumericRange indexRange)
{
if (context == null) throw new ArgumentNullException("context");
// check type definition.
if (!Server.TypeTree.IsTypeOf(this.TypeDefinitionId, typeDefinitionId))
{
return null;
}
// lookup extended properties.
if (relativePath == null || relativePath.Count == 1)
{
object value = null;
if (m_values.TryGetValue(relativePath[0], out value))
{
return value;
}
}
// read the attribute value.
DataValue dataValue = ReadAttributeValue(
context,
typeDefinitionId,
relativePath,
attributeId,
indexRange);
if (StatusCode.IsBad(dataValue.StatusCode))
{
return dataValue.StatusCode;
}
// return the value.
return dataValue.Value;
}
/// <summary>
/// Adds index ranges to the collection.
/// </summary>
private void AddWriteValues(
Node node,
WriteValueCollection nodesToWrite,
params uint[] attributeIds)
{
if (attributeIds != null)
{
for (int ii = 0; ii < attributeIds.Length; ii++)
{
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = node.NodeId;
nodeToWrite.AttributeId = attributeIds[ii];
DataValue value = new DataValue();
ServiceResult result = node.Read(
null,
attributeIds[ii],
value);
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
if (ServiceResult.IsBad(result))
{
value.Value = null;
}
nodeToWrite.Value = value;
nodeToWrite.Handle = node;
nodesToWrite.Add(nodeToWrite);
Array array = value.Value as Array;
if (array != null)
{
NumericRange range = new NumericRange(0, 1);
object subarray = array;
range.ApplyRange(ref subarray);
nodeToWrite = new WriteValue();
nodeToWrite.Value = new DataValue();
nodeToWrite.Value.Value = subarray;
nodeToWrite.Value.StatusCode = StatusCodes.Good;
nodeToWrite.Value.ServerTimestamp = DateTime.MinValue;
nodeToWrite.Value.SourceTimestamp = DateTime.MinValue;
nodeToWrite.NodeId = node.NodeId;
nodeToWrite.AttributeId = attributeIds[ii];
nodeToWrite.IndexRange = "0";
nodeToWrite.Handle = node;
nodesToWrite.Add(nodeToWrite);
}
nodeToWrite = new WriteValue();
nodeToWrite.Value = new DataValue();
nodeToWrite.Value.Value = value.Value;
nodeToWrite.Value.StatusCode = StatusCodes.Uncertain;
nodeToWrite.Value.ServerTimestamp = DateTime.MinValue;
nodeToWrite.Value.SourceTimestamp = DateTime.MinValue;
nodeToWrite.NodeId = node.NodeId;
nodeToWrite.AttributeId = attributeIds[ii];
nodeToWrite.Handle = node;
nodesToWrite.Add(nodeToWrite);
nodeToWrite = new WriteValue();
nodeToWrite.Value = new DataValue();
nodeToWrite.Value.Value = value.Value;
nodeToWrite.Value.StatusCode = StatusCodes.Good;
nodeToWrite.Value.ServerTimestamp = DateTime.UtcNow;
nodeToWrite.Value.SourceTimestamp = DateTime.MinValue;
nodeToWrite.NodeId = node.NodeId;
nodeToWrite.AttributeId = attributeIds[ii];
nodeToWrite.Handle = node;
nodesToWrite.Add(nodeToWrite);
nodeToWrite = new WriteValue();
nodeToWrite.Value = new DataValue();
nodeToWrite.Value.Value = value.Value;
nodeToWrite.Value.StatusCode = StatusCodes.Good;
nodeToWrite.Value.ServerTimestamp = DateTime.MinValue;
nodeToWrite.Value.SourceTimestamp = DateTime.UtcNow;
nodeToWrite.NodeId = node.NodeId;
nodeToWrite.AttributeId = attributeIds[ii];
nodeToWrite.Handle = node;
nodesToWrite.Add(nodeToWrite);
}
}
}
private void Load()
{
foreach (string resourceName in Assembly.GetExecutingAssembly().GetManifestResourceNames())
{
if (resourceName.EndsWith(".SystemConfiguration.xml"))
{
using (Stream istrm = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
{
XmlSerializer serializer = new XmlSerializer(typeof(Configuration));
m_configuration = (Configuration)serializer.Deserialize(istrm);
}
}
}
if (m_configuration.Controllers != null)
{
for (int ii = 0; ii < m_configuration.Controllers.Length; ii++)
{
ControllerConfiguration controller = m_configuration.Controllers[ii];
int blockAddress = m_position;
int offset = m_position - blockAddress;
BlockConfiguration data = new BlockConfiguration()
{
Address = blockAddress,
Name = controller.Name,
Type = controller.Type,
Properties = new List <BlockProperty>()
};
if (controller.Properties != null)
{
for (int jj = 0; jj < controller.Properties.Length; jj++)
{
ControllerProperty property = controller.Properties[jj];
NodeId dataTypeId = NodeId.Parse(property.DataType);
string value = property.Value;
Range range = null;
if (!String.IsNullOrEmpty(property.Range))
{
try
{
NumericRange nr = NumericRange.Parse(property.Range);
range = new Range()
{
High = nr.End, Low = nr.Begin
};
}
catch (Exception)
{
range = null;
}
}
data.Properties.Add(new BlockProperty()
{
Offset = offset,
Name = controller.Properties[jj].Name,
DataType = dataTypeId,
Writeable = controller.Properties[jj].Writeable,
Range = range
});
switch ((uint)dataTypeId.Identifier)
{
case DataTypes.Int32:
{
//Write(blockAddress, offset, (int)TypeUtils.Cast(value, BuiltInType.Int32));
offset += 4;
break;
}
case DataTypes.Double:
{
// Write(blockAddress, offset, (double)TypeUtils.Cast(value, BuiltInType.Double));
offset += 4;
break;
}
}
}
}
m_position += offset;
m_blocks[blockAddress] = data;
}
}
}
/// <summary>
/// Converts values from one scale to another scale.
/// </summary>
public static double[] Scale(this double[] values, NumericRange toRange, double[] result)
{
values.GetRange(out double fromMin, out double fromMax);
return(Scale(values, fromMin, fromMax, toRange.Min, toRange.Max, result));
}
public static catalogDto.NumericRange ToNumericRangeDto(this NumericRange range)
{
return(CatalogConverterInstance.ToNumericRangeDto(range));
}
/// <summary>
/// Gets the attribute value.
/// </summary>
protected ServiceResult GetAttributeValue(
ISystemContext context,
NumericRange indexRange,
QualifiedName dataEncoding,
uint attributeId,
DataValue value,
params HdaAttributeValue[] sources)
{
if (sources == null || sources.Length <= 0)
{
value.StatusCode = StatusCodes.BadNoData;
return(value.StatusCode);
}
switch (attributeId)
{
case Constants.OPCHDA_NORMAL_MAXIMUM:
{
double high = this.GetAttributeValue <double>(value, sources[0]);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
if (sources.Length <= 1)
{
value.StatusCode = StatusCodes.BadNoData;
return(value.StatusCode);
}
double low = this.GetAttributeValue <double>(value, sources[1]);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
// take the latest timestamp.
if (sources[0].Timestamp > sources[1].Timestamp)
{
value.SourceTimestamp = sources[0].Timestamp;
}
value.Value = new Range(high, low);
break;
}
case Constants.OPCHDA_HIGH_ENTRY_LIMIT:
{
double high = this.GetAttributeValue <double>(value, sources[0]);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
if (sources.Length <= 1)
{
value.StatusCode = StatusCodes.BadNoData;
return(value.StatusCode);
}
double low = this.GetAttributeValue <double>(value, sources[1]);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
// take the latest timestamp.
if (sources[0].Timestamp > sources[1].Timestamp)
{
value.SourceTimestamp = sources[0].Timestamp;
}
value.Value = new Range(high, low);
break;
}
case Constants.OPCHDA_ENG_UNITS:
{
string units = this.GetAttributeValue <string>(value, sources[0]);
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>(value, sources[0]);
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>(value, sources[0]);
if (StatusCode.IsBad(value.StatusCode))
{
return(value.StatusCode);
}
value.Value = (int)number;
break;
}
default:
{
value.Value = this.GetAttributeValue <object>(value, sources[0]);
break;
}
}
return(ApplyIndexRangeAndDataEncoding(context, indexRange, dataEncoding, value));
}
private void CopyNumericRange(NumericRange range)
{
if (_AddButton != null)
{
_AddButton.PerformClick();
NumericRangeCollection pc = range.NumericIndicator.Ranges;
NumericRange clone = pc[pc.Count - 1];
range.CopyToItem(clone);
}
}
/// <summary>
/// Reads the value for an attribute of a node.
/// </summary>
public DataValue ReadAttributeValue(
IOperationContext context,
ExpandedNodeId typeDefinitionId,
IList<QualifiedName> relativePath,
uint attributeId,
NumericRange indexRange)
{
lock (DataLock)
{
// check for match on the event type being searched.
if (!Server.TypeTree.IsTypeOf(TypeDefinitionId, typeDefinitionId))
{
return new DataValue(StatusCodes.BadNotSupported);
}
// find the target.
NodeSource target = this;
if (relativePath != null && relativePath.Count > 0)
{
target = Find(relativePath, 0);
if (target == null)
{
return new DataValue(StatusCodes.BadNotSupported);
}
}
// read the attribute value.
DataValue dataValue = new DataValue();
ServiceResult result = target.Read(context, attributeId, dataValue);
if (ServiceResult.IsBad(result))
{
return new DataValue(result.StatusCode);
}
// apply any index range.
object value = dataValue.Value;
result = indexRange.ApplyRange(ref value);
if (ServiceResult.IsBad(result))
{
return new DataValue(result.StatusCode);
}
dataValue.Value = value;
// return the value.
return dataValue;
}
}
private void InitializeNewNumericRange(NumericRange range)
{
range.StartValue = 500;
range.EndValue = 1000;
range.Name = GetNumericRangeName(range.NumericIndicator);
range.DigitColor = Color.Red;
range.DigitDimColor = Color.FromArgb(94, 0, 0);
range.DecimalColor = range.DigitColor;
range.DecimalDimColor = range.DigitDimColor;
}
/// <summary>
/// Converts values from one scale to another scale.
/// </summary>
public static double Scale(this double value, NumericRange fromRange, NumericRange toRange)
{
return(Scale(value, fromRange.Min, fromRange.Max, toRange.Min, toRange.Max));
}
public ServiceResult Property_NodeValueEventHandler(ISystemContext context, NodeState node, NumericRange indexRange, QualifiedName dataEncoding, ref object value, ref StatusCode statusCode, ref DateTime timestamp)
{
ServiceResult result = new ServiceResult(statusCode);
var target = channel.Nodes[node.NodeId.Identifier.ToString()];
target.Value = value;
TerminalClient.Instance.Write(channel.Id, target);
return(result);
}
/// <summary>
/// Prompts the user to edit the read request parameters for the set of nodes provided.
/// </summary>
public ReadValueId[] ShowDialog(Session session, params ReadValueId[] nodesToRead)
{
NodeBTN.Session = session;
NodeBTN.SelectedReference = null;
bool editNode = true;
bool editAttribute = true;
bool editIndexRange = true;
bool editDataEncoding = true;
// populate the controls.
if (nodesToRead != null && nodesToRead.Length > 0)
{
bool nonValueAttribute = false;
for (int ii = 0; ii < nodesToRead.Length; ii++)
{
if (nodesToRead[ii] == null)
{
continue;
}
// only show the node if all have the same node id.
if (editNode)
{
if (NodeBTN.SelectedNode != null && nodesToRead[ii].NodeId != NodeBTN.SelectedNode)
{
NodeTB.Visible = false;
NodeLB.Visible = false;
NodeBTN.Visible = false;
editNode = false;
}
else
{
NodeBTN.SelectedNode = nodesToRead[ii].NodeId;
}
}
// only show the attribute if all have the same attribute id.
if (editAttribute)
{
// check if any non-value attributes are present.
if (nodesToRead[ii].AttributeId != Attributes.Value)
{
nonValueAttribute = true;
}
int index = (int)nodesToRead[ii].AttributeId - 1;
if (AttributeCB.SelectedIndex != -1 && index != AttributeCB.SelectedIndex)
{
AttributeCB.Visible = false;
AttributeLB.Visible = false;
editAttribute = false;
}
else
{
AttributeCB.SelectedIndex = index;
}
}
}
DataEncodingCB.Items.Clear();
editIndexRange = !nonValueAttribute;
IndexRangeLB.Visible = editIndexRange;
IndexRangeTB.Visible = editIndexRange;
if (!nonValueAttribute)
{
// use the index range for the first node as template.
IndexRangeTB.Text = nodesToRead[0].IndexRange;
// fetch the available encodings for the first node in the list from the server.
IVariableBase variable = session.NodeCache.Find(nodesToRead[0].NodeId) as IVariableBase;
if (variable != null)
{
if (session.NodeCache.IsTypeOf(variable.DataType, Opc.Ua.DataTypeIds.Structure))
{
DataEncodingCB.Items.Add(new EncodingInfo());
DataEncodingCB.SelectedIndex = 0;
foreach (INode encoding in session.NodeCache.Find(variable.DataType, Opc.Ua.ReferenceTypeIds.HasEncoding, false, true))
{
DataEncodingCB.Items.Add(new EncodingInfo()
{
EncodingName = encoding.BrowseName
});
if (nodesToRead[0].DataEncoding == encoding.BrowseName)
{
DataEncodingCB.SelectedIndex = DataEncodingCB.Items.Count - 1;
}
}
}
}
}
// hide the data encodings if none to select.
if (DataEncodingCB.Items.Count == 0)
{
DataEncodingCB.Visible = false;
DataEncodingLB.Visible = false;
editDataEncoding = false;
}
}
if (!editNode && !editAttribute && !editIndexRange && !editDataEncoding)
{
throw new ArgumentException("nodesToRead", "It is not possible to edit the current selection as a group.");
}
if (base.ShowDialog() != DialogResult.OK)
{
return(null);
}
// create the list of results.
ReadValueId[] results = null;
if (nodesToRead == null || nodesToRead.Length == 0)
{
results = new ReadValueId[1];
}
else
{
results = new ReadValueId[nodesToRead.Length];
}
// copy the controls into the results.
for (int ii = 0; ii < results.Length; ii++)
{
// preserve the existing settings if they are not being changed.
if (nodesToRead != null && nodesToRead.Length > 0)
{
results[ii] = (ReadValueId)nodesToRead[ii].Clone();
}
else
{
results[ii] = new ReadValueId();
}
// only copy results that were actually being edited.
if (editNode)
{
results[ii].NodeId = NodeBTN.SelectedNode;
}
if (editAttribute)
{
results[ii].AttributeId = (uint)(AttributeCB.SelectedIndex + 1);
}
if (editIndexRange)
{
results[ii].ParsedIndexRange = NumericRange.Parse(IndexRangeTB.Text);
if (NumericRange.Empty != results[ii].ParsedIndexRange)
{
results[ii].IndexRange = results[ii].ParsedIndexRange.ToString();
}
else
{
results[ii].IndexRange = String.Empty;
}
}
if (editDataEncoding)
{
results[ii].DataEncoding = null;
EncodingInfo encoding = DataEncodingCB.SelectedItem as EncodingInfo;
if (encoding != null)
{
results[ii].DataEncoding = encoding.EncodingName;
}
}
}
return(results);
}
/// <summary>
/// Converts values from one scale to another scale.
/// </summary>
public static double[] Scale(this double[] values, NumericRange fromRange, NumericRange toRange, double[] result)
{
return(Scale(values, fromRange.Min, fromRange.Max, toRange.Min, toRange.Max, result));
}
