public DataValue WriteValue(NodeId ndoeId, BuiltInType datayType, object newValue)
{
var wrapedValue = new Variant(Convert.ChangeType(newValue, TypeInfo.GetSystemType(datayType, -1)));
var data = new DataValue(wrapedValue);
var valueToWrite = new WriteValue()
{
Value = data,
NodeId = ndoeId,
AttributeId = Attributes.Value,
};
try
{
_session.Write(null, new WriteValueCollection()
{
valueToWrite
}, out var statusCodes, out var diagnosticInfo);
if (statusCodes.FirstOrDefault().Code == StatusCodes.Good)
{
Utils.Trace(Utils.TraceMasks.Information, "Value successfully written to server!");
data.SourceTimestamp = DateTime.Now;
return(data);
}
Utils.Trace(Utils.TraceMasks.Error, "Value was not written to server!");
}
catch (Exception e)
{
Utils.Trace(Utils.TraceMasks.Error, $"{e.Message}");
}
return(null);
}
/// <summary>write a note to server(you should use try catch)</summary>
/// <typeparam name="T"></typeparam>
/// <param name="tag"></param>
/// <param name="value"></param>
/// <returns>if success True,otherwise False</returns>
public bool WriteNode <T>(string tag, T value)
{
WriteValue writeValue1 = new WriteValue()
{
NodeId = new NodeId(tag),
AttributeId = 13
};
writeValue1.Value.Value = (object)value;
writeValue1.Value.StatusCode = (StatusCode)0U;
writeValue1.Value.ServerTimestamp = DateTime.MinValue;
writeValue1.Value.SourceTimestamp = DateTime.MinValue;
WriteValueCollection writeValueCollection = new WriteValueCollection();
WriteValue writeValue2 = writeValue1;
writeValueCollection.Add(writeValue2);
WriteValueCollection nodesToWrite = writeValueCollection;
StatusCodeCollection results;
DiagnosticInfoCollection diagnosticInfos;
this.m_session.Write((RequestHeader)null, nodesToWrite, out results, out diagnosticInfos);
ClientBase.ValidateResponse((IList)results, (IList)nodesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, (IList)nodesToWrite);
return(!StatusCode.IsBad(results[0]));
}
/// <summary>
/// Prompts the user to specify the browse options.
/// </summary>
public bool ShowDialog(Session session, WriteValue value)
{
if (session == null) throw new ArgumentNullException("session");
if (value == null) throw new ArgumentNullException("value");
NodeIdCTRL.Browser = new Browser(session);
INode node = session.NodeCache.Find(value.NodeId);
if (node != null)
{
DisplayNameTB.Text = node.ToString();
}
NodeIdCTRL.Identifier = value.NodeId;
AttributeIdCB.SelectedItem = Attributes.GetBrowseName(value.AttributeId);
IndexRangeTB.Text = value.IndexRange;
if (ShowDialog() != DialogResult.OK)
{
return false;
}
value.NodeId = NodeIdCTRL.Identifier;
value.AttributeId = Attributes.GetIdentifier((string)AttributeIdCB.SelectedItem);
value.IndexRange = IndexRangeTB.Text;
return true;
}
public static async Task <object> WriteVar(int node, KeyValuePair <string, object>[] ValuesToSet)
{
try
{
WriteValue[] valuesToWrite = new WriteValue[ValuesToSet.Length];
for (int i = 0; i < ValuesToSet.Length; i++)
{
valuesToWrite[i] = new WriteValue
{
// you can parse the nodeId from a string.
NodeId = NodeId.Parse("ns=" + node.ToString() + ";s=" + ValuesToSet[i].Key),
// variable class nodes have a Value attribute.
AttributeId = AttributeIds.Value,
Value = new DataValue(ValuesToSet[i].Value)
};
}
var writeRequest = new WriteRequest
{
NodesToWrite = valuesToWrite
};
// send the ReadRequest to the server.
var writeResult = await channel.WriteAsync(writeRequest);
return(writeResult);
}
catch (Exception ex)
{
//await channel.AbortAsync();
return(null);
}
}
private void WriteMI_Click(object sender, EventArgs e)
{
try {
if (NodesTV.SelectedNode == null)
{
return;
}
ReferenceDescription reference = NodesTV.SelectedNode.Tag as ReferenceDescription;
if (reference == null || (reference.NodeClass & (NodeClass.Variable | NodeClass.VariableType)) == 0)
{
return;
}
Session session = m_browser.Session;
// build list of nodes to read.
WriteValueCollection values = new WriteValueCollection();
WriteValue value = new WriteValue();
value.NodeId = (NodeId)reference.NodeId;
value.AttributeId = Attributes.Value;
value.IndexRange = null;
value.Value = null;
values.Add(value);
// show form.
new WriteDlg().Show(session, values);
} catch (Exception exception) {
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
/// <summary>
/// write a note to server(you should use try catch)
/// </summary>
/// <typeparam name="T">The type of tag to write on</typeparam>
/// <param name="tag">节点名称</param>
/// <param name="value">值</param>
/// <returns>if success True,otherwise False</returns>
public bool WriteNode <T>(string tag, T value)
{
var valueToWrite = new WriteValue()
{
NodeId = new NodeId(tag),
AttributeId = Attributes.Value
};
valueToWrite.Value.Value = value;
valueToWrite.Value.StatusCode = StatusCodes.Good;
valueToWrite.Value.ServerTimestamp = DateTime.MinValue;
valueToWrite.Value.SourceTimestamp = DateTime.MinValue;
var valuesToWrite = new WriteValueCollection {
valueToWrite
};
// 写入当前的值
Session.Write(
null,
valuesToWrite,
out var results,
out var diagnosticInfos);
ClientBase.ValidateResponse(results, valuesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToWrite);
if (StatusCode.IsBad(results[0]))
{
throw new ServiceResultException(results[0]);
}
return(!StatusCode.IsBad(results[0]));
}
/// <summary>
/// Adds random values to write.
/// </summary>
private void AddWriteValues(
TestVariable variable,
WriteValueCollection nodesToWrite)
{
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
value.Value = m_generator.GetRandom(
variable.Variable.DataType,
variable.Variable.ValueRank,
variable.Variable.ArrayDimensions,
Session.TypeTree);
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
variable.Values.Add(value);
nodeToWrite.Value = value;
nodeToWrite.Handle = variable;
nodesToWrite.Add(nodeToWrite);
}
public static void write()
{
WriteValue value = new WriteValue();
value.NodeId = Data.tags["DigitConst"].NodeId;
value.AttributeId = Attributes.Value;
value.Value.Value = 10;
WriteValueCollection valuesToWrite = new WriteValueCollection();
valuesToWrite.Add(value);
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = session.Write(
null,
valuesToWrite,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, valuesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToWrite);
if (StatusCode.IsBad(results[0]))
{
throw ServiceResultException.Create(results[0], 0, diagnosticInfos, responseHeader.StringTable);
}
}
private void UpdateBTN_Click(object sender, EventArgs e)
{
try {
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = m_variableId;
nodeToWrite.AttributeId = Attributes.Value;
nodeToWrite.Value = new DataValue();
nodeToWrite.Value.WrappedValue = GetValue();
WriteValueCollection nodesToWrite = new WriteValueCollection();
nodesToWrite.Add(nodeToWrite);
// read the attributes.
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);
// check for error.
if (StatusCode.IsBad(results[0]))
{
throw ServiceResultException.Create(results[0], 0, diagnosticInfos, responseHeader.StringTable);
}
} catch (Exception exception) {
ClientUtils.HandleException(this.Text, exception);
}
}
private void NewMI_Click(object sender, EventArgs e)
{
try {
WriteValue nodeToWrite = null;
// choose the first selected row as a template.
foreach (DataGridViewRow row in ResultsDV.SelectedRows)
{
DataRowView source = row.DataBoundItem as DataRowView;
WriteValue value = (WriteValue)source.Row[0];
nodeToWrite = (WriteValue)value.Clone();
break;
}
if (nodeToWrite == null)
{
nodeToWrite = new WriteValue()
{
AttributeId = Attributes.Value
};
}
// prompt use to edit new value.
WriteValue result = new EditWriteValueDlg().ShowDialog(m_session, nodeToWrite);
if (result != null)
{
DataRow row = m_dataset.Tables[0].NewRow();
UpdateRow(row, result);
m_dataset.Tables[0].Rows.Add(row);
}
} catch (Exception exception) {
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// write a note to server(you should use try catch)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tag"></param>
/// <param name="value"></param>
/// <returns>if success True,otherwise False</returns>
public bool WriteNode <T>(string tag, T value)
{
WriteValue valueToWrite = new WriteValue()
{
NodeId = new NodeId(tag),
AttributeId = Attributes.Value
};
valueToWrite.Value.Value = value;
valueToWrite.Value.StatusCode = StatusCodes.Good;
valueToWrite.Value.ServerTimestamp = DateTime.MinValue;
valueToWrite.Value.SourceTimestamp = DateTime.MinValue;
WriteValueCollection valuesToWrite = new WriteValueCollection
{
valueToWrite
};
// 写入当前的值
m_session.Write(
null,
valuesToWrite,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos);
ClientBase.ValidateResponse(results, valuesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToWrite);
return(!StatusCode.IsBad(results[0]));
}
public DelegatesDependendClass(
WriteValue writeValue,
AppendValue appendValue)
{
_writeValue = writeValue;
_appendValue = appendValue;
}
public async Task <bool> WriteNodeValueAsync(string serverUrl, VariableNode variableNode, VariableState state)
{
Session session = await GetSessionAsync(serverUrl);
var typeManager = new DataTypeManager(session);
WriteValueCollection writeValues = new WriteValueCollection();
WriteValue writeValue = new WriteValue
{
NodeId = variableNode.NodeId,
AttributeId = Attributes.Value,
Value = typeManager.GetDataValueFromVariableState(state, variableNode)
};
writeValues.Add(writeValue);
session.Write(null, writeValues, out var results, out _);
if (!StatusCode.IsGood(results[0]))
{
if (results[0] == StatusCodes.BadTypeMismatch)
{
throw new ValueToWriteTypeException("Wrong Type Error: data sent are not of the type expected. Check your data and try again");
}
throw new ValueToWriteTypeException(results[0].ToString());
}
return(true);
}
private void WriteValue(Session session, NodeId variableId, DataValue value)
{
WriteValue nodeToWrite = new WriteValue {
NodeId = variableId,
AttributeId = Attributes.Value,
Value = new DataValue {
WrappedValue = value.WrappedValue
}
};
WriteValueCollection nodesToWrite = new WriteValueCollection {
nodeToWrite
};
// read the attributes.
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = session.Write(
null,
nodesToWrite,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToWrite);
// check for error.
if (StatusCode.IsBad(results[0]))
{
throw ServiceResultException.Create(results[0], 0, diagnosticInfos, responseHeader.StringTable);
}
}
/// <summary>
/// Adds a value to the control.
/// </summary>
public void AddValue(ReferenceDescription reference)
{
Node node = m_session.NodeCache.Find(reference.NodeId) as Node;
if (node == null)
{
return;
}
WriteValue value = new WriteValue();
value.NodeId = node.NodeId;
value.AttributeId = Attributes.Value;
value.IndexRange = null;
// read the display name for non-variables.
if ((node.NodeClass & (NodeClass.Variable | NodeClass.VariableType)) == 0)
{
value.AttributeId = Attributes.DisplayName;
}
value.Value = GetDefaultValue(value.NodeId, value.AttributeId);
AddItem(value);
AdjustColumns();
}
private void EditMI_Click(object sender, EventArgs e)
{
try
{
// choose the first selected row.
foreach (DataGridViewRow row in ResultsDV.SelectedRows)
{
DataRowView source = row.DataBoundItem as DataRowView;
WriteValue value = (WriteValue)source.Row[0];
WriteValue result = new EditWriteValueDlg().ShowDialog(m_session, value);
if (result != null)
{
UpdateRow(source.Row, result);
}
break;
}
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public string VariableWrite(string node, int value)
{
try
{
StatusCodeCollection values = null;
DiagnosticInfoCollection diagnosticInfos = null;
//WriteValueIdCollection nodesToRead = new WriteValueIdCollection();
WriteValueCollection nodesToWrite = new WriteValueCollection();
WriteValue valueId = new WriteValue();
valueId.NodeId = new NodeId(node);
valueId.AttributeId = Attributes.Value;
valueId.IndexRange = null;
valueId.Value = new DataValue(value);
nodesToWrite.Add(valueId);
ResponseHeader response = session.Write(null, nodesToWrite, out values, out diagnosticInfos);
/*string value = "";
* if (values[0].Value != null)
* {
* var rawValue = values[0].WrappedValue.ToString();
* value = rawValue.Replace("|", "\r\n").Replace("{", "").Replace("}", "");
* }*/
return(null);
}
catch
{
return(null);
}
}
public static void WriteData(this XiDataList dataList,
WriteValue dataObjectToWrite)
{
dataList.WriteData(new List <WriteValue> {
dataObjectToWrite
});
}
/// <summary>
/// Adds a write request for a DA item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="nodeToWrite">The node to write.</param>
/// <param name="index">The index associated with the value.</param>
/// <returns>StatusCode.Good if the write is allowed. An error code otherwise.</returns>
private StatusCode Add(DaItemState item, WriteValue nodeToWrite, int index)
{
if (nodeToWrite.AttributeId != Attributes.Value)
{
return(StatusCodes.BadNotWritable);
}
if (nodeToWrite.ParsedIndexRange != NumericRange.Empty)
{
return(StatusCodes.BadIndexRangeInvalid);
}
if (nodeToWrite.Value.ServerTimestamp != DateTime.MinValue)
{
return(StatusCodes.BadWriteNotSupported);
}
if (item.Element.DataType != 0)
{
if (!CheckDataType(item.Element.DataType, nodeToWrite.Value.WrappedValue))
{
return(StatusCodes.BadTypeMismatch);
}
}
WriteRequest request = new WriteRequest(item.ItemId, nodeToWrite.Value, index);
Add(request);
return(StatusCodes.Good);
}
public void ArraySubRangeIndexRangeValidationTest()
{
// Test with String array
WriteValue writeValue = new WriteValue()
{
AttributeId = Attributes.Value,
NodeId = new NodeId(4000, 8),
Value = new DataValue(new Variant(new string[] { "ha" })),
IndexRange = "0,1:2"
};
Assert.AreEqual(BuiltInType.String, writeValue.Value.WrappedValue.TypeInfo.BuiltInType);
Assert.True(ServiceResult.IsGood(WriteValue.Validate(writeValue)), "WriteValue.Validate result was not Good");
// Test with ByteString array
writeValue.Value = new DataValue(new Variant(new byte[][] { new byte[] { 0x22, 0x21 } }));
Assert.AreEqual(BuiltInType.ByteString, writeValue.Value.WrappedValue.TypeInfo.BuiltInType);
Assert.True(ServiceResult.IsGood(WriteValue.Validate(writeValue)), "WriteValue.Validate result was not Good");
// Negative test with Int32 array
writeValue.Value = new DataValue(new Variant(new int[] { 1, 2 }));
Assert.AreEqual(BuiltInType.Int32, writeValue.Value.WrappedValue.TypeInfo.BuiltInType);
ServiceResult validateResult = WriteValue.Validate(writeValue);
Assert.True(ServiceResult.IsBad(validateResult), "WriteValue.Validate result was not Good");
Assert.AreEqual(new StatusCode(StatusCodes.BadTypeMismatch), validateResult.StatusCode);
}
public List <String> WriteVariable(string identifier, ushort namespaceIndex, Object value, uint attribute)
{
NodeId node = null;
List <String> statusCodeWrite = new List <String>();
node = new NodeId(identifier, namespaceIndex);
DataValue valueToWrite = new DataValue()
{
Value = (new Variant(value))
};
DiagnosticInfoCollection diagnosticInfos = null;
WriteValueCollection nodesTowrite = new WriteValueCollection();
WriteValue nodeToWrite = new WriteValue()
{
NodeId = node,
AttributeId = attribute,
Value = valueToWrite,
IndexRange = null
};
nodesTowrite.Add(nodeToWrite);
StatusCodeCollection writeResults;
session.Write(null, nodesTowrite, out writeResults, out diagnosticInfos);
for (int i = 0; i < writeResults.Count; i++)
{
statusCodeWrite.Add(writeResults[i].ToString());
}
return(statusCodeWrite);
}
/// <summary>
/// Validates the nodes and writes the value to the underlying system.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="nodesToWrite">The nodes to write.</param>
/// <param name="errors">The errors.</param>
/// <param name="nodesToValidate">The nodes to validate.</param>
/// <param name="cache">The cache.</param>
protected override void Write(
ServerSystemContext context,
IList <WriteValue> nodesToWrite,
IList <ServiceResult> errors,
List <NodeHandle> nodesToValidate,
IDictionary <NodeId, NodeState> cache)
{
ComDaClientManager system = (ComDaClientManager)this.SystemContext.SystemHandle;
ComDaClient client = system.SelectClient((ServerSystemContext)SystemContext, false);
WriteRequestCollection requests = new WriteRequestCollection();
// validates the nodes and queues an write requests.
for (int ii = 0; ii < nodesToValidate.Count; ii++)
{
NodeHandle handle = nodesToValidate[ii];
lock (Lock)
{
// validate node.
NodeState source = ValidateNode(context, handle, cache);
if (source == null)
{
continue;
}
// determine if request can be sent to the server.
bool queued = false;
WriteValue nodeToWrite = nodesToWrite[handle.Index];
errors[handle.Index] = requests.Add(source, nodeToWrite, handle.Index, out queued);
if (queued)
{
continue;
}
// write the attribute value.
errors[handle.Index] = source.WriteAttribute(
context,
nodeToWrite.AttributeId,
nodeToWrite.ParsedIndexRange,
nodeToWrite.Value);
// updates to source finished - report changes to monitored items.
source.ClearChangeMasks(context, false);
}
}
// write to the server.
client.Write(requests);
// get the results from the requests sent to the server.
for (int ii = 0; ii < requests.Count; ii++)
{
WriteRequest request = requests[ii];
errors[request.Index] = request.GetResult();
}
}
public static void WriteData(this XiDataList dataList,
WriteValue dataObjectToWrite,
OnWriteDataComplete onComplete,
object asyncState)
{
dataList.WriteData(new List <WriteValue> {
dataObjectToWrite
}, onComplete, asyncState);
}
/// <summary>
/// Display current attribute values.
/// </summary>
/// <param name="nodeToRead"></param>
/// <param name="attrIds"></param>
/// <param name="results"></param>
/// /// <param name="response"></param>
private void updateAttributes(
NodeId nodeToRead,
UInt32Collection attrIds,
DataValueCollection results,
ResponseHeader response)
{
if (attrIds.Count != results.Count)
{
// Error case.
return;
}
try
{
for (int i = 0; i < attrIds.Count; i++)
{
string attributeName = (string)attrIds[i].ToString();
string attributeValue = results[i].ToString();
string attributeStatus;
// Add the attribute name / value to the list view.
ListViewItem item = new ListViewItem(attributeName);
// Add the value
item.SubItems.Add(attributeValue);
if (attrIds[i] == Attributes.Value)
{
m_CurrentWriteValue = new WriteValue();
m_CurrentWriteValue.AttributeId = Attributes.Value;
m_CurrentWriteValue.NodeId = nodeToRead;
m_CurrentWriteNodeName = nodeToRead.ToString();
m_CurrentValue = results[i].Value;
}
// Add status.
attributeStatus = results[i].StatusCode.ToString();
if (StatusCode.IsBad(results[i].StatusCode))
{
item.SubItems[0].Text = (String)attributeStatus;
item.SubItems[0].ForeColor = Color.Red;
}
// Add item to listview.
this.lvAttributes.Items.Add(item);
// Fit the width of the nodeid column to the size of the header.
this.lvAttributes.Columns[0].Width = -2;
}
}
catch (Exception e)
{
// Update status label.
OnUpdateStatusLabel("Error while processing read results: " + e.Message, false);
}
}
public static WriteValue ToWriteValue(this WriteData writeData)
{
var xiWriteData = new WriteValue
{
DataValue = writeData.ToDataValue(),
ServerAlias = writeData.Registration.ServerAlias,
};
return(xiWriteData);
}
/// <summary>
/// Updates the row with the node to write.
/// </summary>
public void UpdateRow(DataRow row, WriteValue nodeToWrite)
{
row[0] = nodeToWrite;
row[1] = ImageList.Images[ClientUtils.GetImageIndex(nodeToWrite.AttributeId, null)];
row[2] = (m_session != null) ? m_session.NodeCache.GetDisplayText(nodeToWrite.NodeId) : Utils.ToString(nodeToWrite.NodeId);
row[3] = Attributes.GetBrowseName(nodeToWrite.AttributeId);
row[4] = nodeToWrite.IndexRange;
UpdateRow(row, nodeToWrite.Value);
}
public bool WriteValues(List <string> opcNodes, List <object> values, out List <bool> status)
{
bool ret = false;
try
{
if (opcNodes.Count != values.Count)
{
throw new Exception("opcNodes.Count != values.Count");
}
int count = opcNodes.Count;
status = new List <bool>(count);
List <Type> types = new List <Type>(count);
List <NodeId> nodeIds = new List <NodeId>(count);
DiagnosticInfoCollection diags;
StatusCodeCollection statusCodes;
WriteValueCollection writeValues = new WriteValueCollection(count);
for (int i = 0; i < count; i++)
{
Variant variant = new Variant(values[i]);
DataValue dataVal = new DataValue(variant);
WriteValue writeVal = new WriteValue();
writeVal.Value = dataVal;
writeVal.NodeId = new NodeId(opcNodes[i]);
writeVal.AttributeId = Attributes.Value;
writeValues.Add(writeVal);
}
ResponseHeader rh = session.Write(null, writeValues, out statusCodes, out diags);
ret = StatusCode.IsGood(rh.ServiceResult.Code);
for (int i = 0; i < count; i++)
{
//status[i] = StatusCode.IsGood(statusCodes[i]);
status.Add(StatusCode.IsGood(statusCodes[i]));
ret = ret & status[i];
}
}
catch (Exception ex)
{
ret = false;
status = null;
System.Diagnostics.Debug.WriteLine("Exception OpcUaClient::WriteValues " + ex.Message);
}
return(ret);
}
private async Task WriteValueInternal(byte[] value)
{
await Task.Delay(333);
Debug.WriteLine($">>> {value.Dump()}");
try
{
WriteValue.Invoke(value);
}
catch { }
}
/// <summary>
/// Update the attribute listview.
/// </summary>
/// <param name="nodesToRead"></param>
/// <param name="results"></param>
/// <returns></returns>
private void updateAttributeList(ReadValueIdCollection nodesToRead, DataValueCollection results)
{
if (nodesToRead.Count != results.Count)
{
// Error case.
return;
}
try
{
for (int i = 0; i < nodesToRead.Count - 1; i++)
{
string attributeName = (string)nodesToRead[i].Handle;
string attributeValue;
string attributeStatus;
// Add the attribute name / value to the list view.
ListViewItem item = new ListViewItem(attributeName);
// Add value.
attributeValue = m_Server.attributeValueToString(nodesToRead[i], results[i]);
item.SubItems.Add(attributeValue);
if (nodesToRead[i].AttributeId == Attributes.Value)
{
m_CurrentWriteValue = new WriteValue();
m_CurrentWriteValue.AttributeId = Attributes.Value;
m_CurrentWriteValue.NodeId = nodesToRead[i].NodeId;
m_CurrentWriteNodeName = nodesToRead[i].NodeId.ToString();
m_CurrentValue = results[i].Value;
}
// Add status.
attributeStatus = StatusCode.LookupSymbolicId(results[i].StatusCode.Code);
if (StatusCode.IsBad(results[i].StatusCode))
{
item.SubItems[1].Text = (String)attributeStatus;
item.SubItems[1].ForeColor = Color.Red;
}
// Add item to the listview.
this.lvAttributes.Items.Add(item);
// Set column width.
this.lvAttributes.Columns[0].Width = 150;
this.lvAttributes.Columns[1].Width = 250;
}
}
catch (Exception e)
{
// Update status label.
OnUpdateStatusLabel("Error while processing read results: " + e.Message, false);
}
}
public IActionResult writevalue([FromBody] WriteValue rawdata)
{
string IpAddress = rawdata.IpAddress;
int Port = rawdata.Port;
string VarAddress = rawdata.VarAddress;
string FC = rawdata.FC;
dynamic NewValue = rawdata.NewValue;
Read_Write readwrite = new Read_Write(_subSvc);
ResultValueModel data = readwrite.WriteValue(IpAddress, Port, VarAddress, FC, NewValue);
return(Json(data));
}
/// <summary>
/// Adds random values to write.
/// </summary>
private void AddWriteBadValues(
TestVariable variable,
WriteValueCollection nodesToWrite)
{
for (BuiltInType ii = BuiltInType.Null; ii < BuiltInType.DataValue; ii++)
{
if (variable.DataType != ii || variable.Variable.ValueRank >= 0)
{
// add random scalar.
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
value.Value = m_generator.GetRandom(ii);
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
variable.Values.Add(value);
nodeToWrite.Value = value;
nodeToWrite.Handle = variable;
nodesToWrite.Add(nodeToWrite);
}
if (variable.DataType != ii || variable.Variable.ValueRank == ValueRanks.Scalar)
{
// add random array.
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
value.Value = m_generator.GetRandomArray(ii, true, 100, false);
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
variable.Values.Add(value);
nodeToWrite.Value = value;
nodeToWrite.Handle = variable;
nodesToWrite.Add(nodeToWrite);
}
}
}
/// <summary>
/// Adds a value to the control.
/// </summary>
public void AddValue(ReferenceDescription reference)
{
Node node = m_session.NodeCache.Find(reference.NodeId) as Node;
if (node == null)
{
return;
}
WriteValue value = new WriteValue();
value.NodeId = node.NodeId;
value.AttributeId = Attributes.Value;
value.IndexRange = null;
// read the display name for non-variables.
if ((node.NodeClass & (NodeClass.Variable | NodeClass.VariableType)) == 0)
{
value.AttributeId = Attributes.DisplayName;
}
value.Value = GetDefaultValue(value.NodeId, value.AttributeId);
AddItem(value);
AdjustColumns();
}
/// <summary>
/// Writes the values for the specified item ids.
/// </summary>
/// <param name="itemIds">The item ids.</param>
/// <param name="values">The values.</param>
/// <returns>The results.</returns>
public int[] Write(string[] itemIds, DaValue[] values)
{
int[] results = new int[itemIds.Length];
WriteValueCollection valuesToWrite = new WriteValueCollection();
ComDaReadPropertiesRequest[] requests = new ComDaReadPropertiesRequest[values.Length];
// prepare request.
for (int ii = 0; ii < itemIds.Length; ii++)
{
ComDaReadPropertiesRequest request = requests[ii] = new ComDaReadPropertiesRequest();
request.ItemId = itemIds[ii];
}
// need to get the data type of the remote node.
m_browseManager.GetPropertyValues(Session, requests, PropertyIds.UaBuiltInType, PropertyIds.UaValueRank);
// validate items.
for (int ii = 0; ii < requests.Length; ii++)
{
ComDaReadPropertiesRequest request = requests[ii];
if (request.Error < 0)
{
results[ii] = request.Error;
continue;
}
int? builtInType = request.Values[0].Value as int?;
int? valueRank = request.Values[1].Value as int?;
if (builtInType == null || valueRank == null)
{
results[ii] = ResultIds.E_UNKNOWNITEMID;
continue;
}
// convert value to UA data type.
WriteValue valueToWrite = new WriteValue();
valueToWrite.NodeId = m_mapper.GetRemoteNodeId(itemIds[ii]);
valueToWrite.AttributeId = Attributes.Value;
valueToWrite.Handle = ii;
// convert value to UA data type.
try
{
TypeInfo remoteType = new TypeInfo((BuiltInType)builtInType.Value, valueRank.Value);
valueToWrite.Value = m_mapper.GetRemoteDataValue(values[ii], remoteType);
}
catch (Exception e)
{
results[ii] = ComUtils.GetErrorCode(e, ResultIds.E_BADTYPE);
continue;
}
valuesToWrite.Add(valueToWrite);
}
// check if nothing to do.
if (valuesToWrite.Count == 0)
{
return results;
}
// write the values to the server.
int[] remoteResults = m_groupManager.Write(valuesToWrite);
// copy results.
for (int ii = 0; ii < valuesToWrite.Count; ii++)
{
results[(int)valuesToWrite[ii].Handle] = remoteResults[ii];
}
return results;
}
/// <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);
}
}
}
/// <summary>
/// IOPCSyncIO2::WriteVQT - Writes one or more values, qualities and timestamps for the items specified.
/// </summary>
public void WriteVQT(
int dwCount,
int[] phServer,
OPCITEMVQT[] pItemVQT,
out System.IntPtr ppErrors)
{
// validate arguments.
if (dwCount == 0 || phServer == null || pItemVQT == null || dwCount != phServer.Length || dwCount != pItemVQT.Length)
{
throw ComUtils.CreateComException(ResultIds.E_INVALIDARG);
}
try
{
int[] errors = new int[dwCount];
// build list of values to write.
WriteValueCollection valuesToWrite = new WriteValueCollection();
lock (m_lock)
{
if (m_subscription == null) throw ComUtils.CreateComException(ResultIds.E_FAIL);
for (int ii = 0; ii < dwCount; ii++)
{
Item itemToWrite = null;
if (!m_items.TryGetValue(phServer[ii], out itemToWrite))
{
errors[ii] = ResultIds.E_INVALIDHANDLE;
continue;
}
WriteValue valueToWrite = new WriteValue();
valueToWrite.NodeId = itemToWrite.Variable.NodeId;
valueToWrite.IndexRange = null;
valueToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
int error = 0;
value.Value = m_server.VariantValueToValue(itemToWrite.Variable, pItemVQT[ii].vDataValue, out error);
if (error != ResultIds.S_OK)
{
errors[ii] = error;
continue;
}
if (pItemVQT[ii].bQualitySpecified != 0)
{
value.StatusCode = ComUtils.GetQualityCode(pItemVQT[ii].wQuality);
}
if (pItemVQT[ii].bTimeStampSpecified != 0)
{
value.SourceTimestamp = ComUtils.GetDateTime(pItemVQT[ii].ftTimeStamp);
}
valueToWrite.Value = value;
// needed to correlate results to input.
valueToWrite.Handle = ii;
valuesToWrite.Add(valueToWrite);
}
}
// write values from server.
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
if (valuesToWrite.Count > 0)
{
m_session.Write(
null,
valuesToWrite,
out results,
out diagnosticInfos);
// validate response from the UA server.
ClientBase.ValidateResponse(results, valuesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToWrite);
}
for (int ii = 0; ii < valuesToWrite.Count; ii++)
{
// get index in original array.
int index = (int)valuesToWrite[ii].Handle;
// map UA code to DA code.
errors[index] = Server.MapWriteStatusToErrorCode(results[ii]);
}
// marshal error codes.
ppErrors = ComUtils.GetInt32s(errors);
}
catch (Exception e)
{
throw ComUtils.CreateComException(e);
}
}
/// <summary>
/// Performs n synchronous write operation.
/// </summary>
/// <param name="serverHandles">The server handles.</param>
/// <param name="values">The values.</param>
/// <returns>Any errors.</returns>
public int[] SyncWrite(int[] serverHandles, DaValue[] values)
{
TraceState("SyncWrite", serverHandles.Length);
ThrowIfDisposed();
int[] results = new int[serverHandles.Length];
WriteValueCollection valuesToWrite = new WriteValueCollection();
lock (m_lock)
{
// validate items.
DaValue convertedValue = new DaValue();
for (int ii = 0; ii < serverHandles.Length; ii++)
{
ComDaGroupItem item = null;
if (!m_itemsByHandle.TryGetValue(serverHandles[ii], out item))
{
results[ii] = ResultIds.E_INVALIDHANDLE;
continue;
}
// apply the COM type conversion.
DaValue requestedValue = values[ii];
if (requestedValue.Value == null)
{
results[ii] = ResultIds.E_BADTYPE;
continue;
}
if (item.CanonicalDataType != (short)VarEnum.VT_EMPTY)
{
object value = null;
int error = ComUtils.ChangeTypeForCOM(requestedValue.Value, (VarEnum)item.CanonicalDataType, out value);
if (error < 0)
{
results[ii] = error;
continue;
}
// could happen if there is a problem reading the datatype from the server.
if (requestedValue.Value == null)
{
results[ii] = ResultIds.E_BADTYPE;
continue;
}
// copy all of the attributes into the converted value.
convertedValue.Value = value;
convertedValue.Quality = requestedValue.Quality;
convertedValue.Timestamp = requestedValue.Timestamp;
convertedValue.Error = requestedValue.Error;
requestedValue = convertedValue;
}
WriteValue valueToWrite = new WriteValue();
valueToWrite.NodeId = item.NodeId;
valueToWrite.AttributeId = Attributes.Value;
valueToWrite.Handle = ii;
// convert value to UA data type.
try
{
valueToWrite.Value = m_manager.Mapper.GetRemoteDataValue(requestedValue, item.RemoteDataType);
}
catch (Exception e)
{
results[ii] = ComUtils.GetErrorCode(e, ResultIds.E_BADTYPE);
continue;
}
valuesToWrite.Add(valueToWrite);
}
}
// check if nothing to do.
if (valuesToWrite.Count == 0)
{
return results;
}
// write the values to the server.
int[] remoteResults = m_manager.Write(valuesToWrite);
// copy results.
for (int ii = 0; ii < valuesToWrite.Count; ii++)
{
results[(int)valuesToWrite[ii].Handle] = remoteResults[ii];
}
return results;
}
/// <summary>
/// IOPCSyncIO::Write - Writes values to one or more items in a group.
/// </summary>
public void Write(
int dwCount,
int[] phServer,
object[] pItemValues,
out System.IntPtr ppErrors)
{
// validate arguments.
if (dwCount == 0 || phServer == null || pItemValues == null || dwCount != phServer.Length || dwCount != pItemValues.Length)
{
throw ComUtils.CreateComException(ResultIds.E_INVALIDARG);
}
try
{
int[] errors = new int[dwCount];
// build list of values to write.
WriteValueCollection valuesToWrite = new WriteValueCollection();
lock (m_lock)
{
if (m_subscription == null) throw ComUtils.CreateComException(ResultIds.E_FAIL);
for (int ii = 0; ii < dwCount; ii++)
{
Item itemToWrite = null;
if (!m_items.TryGetValue(phServer[ii], out itemToWrite))
{
errors[ii] = ResultIds.E_INVALIDHANDLE;
continue;
}
VariableNode variable = itemToWrite.Variable;
WriteValue valueToWrite = new WriteValue();
valueToWrite.NodeId = variable.NodeId;
valueToWrite.IndexRange = null;
valueToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
int error = 0;
value.Value = m_server.VariantValueToValue(variable, pItemValues[ii], out error);
if (error != ResultIds.S_OK)
{
errors[ii] = error;
continue;
}
valueToWrite.Value = value;
// needed to correlate results to input.
valueToWrite.Handle = ii;
valuesToWrite.Add(valueToWrite);
}
}
// write values from server.
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
if (valuesToWrite.Count > 0)
{
m_session.Write(
null,
valuesToWrite,
out results,
out diagnosticInfos);
// validate response from the UA server.
ClientBase.ValidateResponse(results, valuesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToWrite);
//Utils.Trace(
// "SyncWrite: GroupHandle={0}, ServerHandle={1}, Value={2}",
// m_clientHandle,
// phServer[0],
// valuesToWrite[0].Value.WrappedValue);
}
for (int ii = 0; ii < valuesToWrite.Count; ii++)
{
// get index in original array.
int index = (int)valuesToWrite[ii].Handle;
// map UA code to DA code.
errors[index] = Server.MapWriteStatusToErrorCode(results[ii]);
}
// marshal error codes.
ppErrors = ComUtils.GetInt32s(errors);
}
catch (Exception e)
{
Utils.Trace(e, "Error writing items.");
throw ComUtils.CreateComException(e);
}
}
/// <summary>
/// IOPCAsyncIO3::WriteVQT - Writes one or more values, qualities and timestamps for the items specified.
/// The results are returned via the client�s IOPCDataCallback connection established
/// through the server�s IConnectionPointContainer.
/// </summary>
public void WriteVQT(
int dwCount,
int[] phServer,
OPCITEMVQT[] pItemVQT,
int dwTransactionID,
out int pdwCancelID,
out System.IntPtr ppErrors)
{
pdwCancelID = 0;
// validate arguments.
if (dwCount == 0 || phServer == null || pItemVQT == null || dwCount != phServer.Length || dwCount != pItemVQT.Length)
{
throw ComUtils.CreateComException(ResultIds.E_INVALIDARG);
}
// get callback object - nothing more to do if missing.
IOPCDataCallback callback = (IOPCDataCallback)GetCallback(typeof(IOPCDataCallback).GUID);
if (callback == null)
{
throw ComUtils.CreateComException(ResultIds.CONNECT_E_NOCONNECTION);
}
try
{
int[] errors = new int[dwCount];
// build list of values to write.
WriteValueCollection valuesToWrite = new WriteValueCollection();
lock (m_lock)
{
if (m_subscription == null) throw ComUtils.CreateComException(ResultIds.E_FAIL);
CallbackValue[] conversionErrors = null;
for (int ii = 0; ii < dwCount; ii++)
{
Item itemToWrite = null;
if (!m_items.TryGetValue(phServer[ii], out itemToWrite))
{
errors[ii] = ResultIds.E_INVALIDHANDLE;
continue;
}
VariableNode variable = itemToWrite.Variable;
WriteValue valueToWrite = new WriteValue();
valueToWrite.NodeId = variable.NodeId;
valueToWrite.IndexRange = null;
valueToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
int error = 0;
value.Value = m_server.VariantValueToValue(variable, pItemVQT[ii].vDataValue, out error);
if (error != ResultIds.S_OK)
{
// only allocate this array when it is needed.
if (conversionErrors == null)
{
conversionErrors = new CallbackValue[dwCount];
}
// create the callback item.
CallbackValue conversionError = new CallbackValue();
conversionError.ClientHandle = itemToWrite.ClientHandle;
conversionError.Error = error;
conversionErrors[ii] = conversionError;
errors[ii] = error;
continue;
}
valueToWrite.Value = value;
if (pItemVQT[ii].bQualitySpecified != 0)
{
value.StatusCode = ComUtils.GetQualityCode(pItemVQT[ii].wQuality);
}
if (pItemVQT[ii].bTimeStampSpecified != 0)
{
value.SourceTimestamp = ComUtils.GetDateTime(pItemVQT[ii].ftTimeStamp);
}
// needed to correlate results to input.
valueToWrite.Handle = itemToWrite;
valuesToWrite.Add(valueToWrite);
}
// create transaction.
if (valuesToWrite.Count > 0 || conversionErrors != null)
{
pdwCancelID = Utils.IncrementIdentifier(ref m_nextHandle);
m_transactions[pdwCancelID] = new AsyncWriteTransaction(dwTransactionID, valuesToWrite);
}
// send conversion errors in the callback if no valid items available (CTT bug workaround).
if (valuesToWrite.Count == 0 && conversionErrors != null)
{
// must return S_OK from this function if sending the errors in the callback.
List<CallbackValue> errorsToSend = new List<CallbackValue>();
for (int ii = 0; ii < conversionErrors.Length; ii++)
{
if (conversionErrors[ii] != null)
{
errors[ii] = ResultIds.S_OK;
errorsToSend.Add(conversionErrors[ii]);
}
}
// queue the request.
CallbackRequest request = new CallbackRequest();
request.CallbackType = CallbackType.Write;
request.Callback = callback;
request.TransactionId = dwTransactionID;
request.GroupHandle = m_clientHandle;
request.ServerHandle = m_serverHandle;
request.Values = errorsToSend;
QueueCallbackRequest(request);
}
}
// write values from server.
if (valuesToWrite.Count > 0)
{
m_session.BeginWrite(
null,
valuesToWrite,
new AsyncCallback(OnWriteComplete),
pdwCancelID);
}
// marshal error codes.
ppErrors = ComUtils.GetInt32s(errors);
}
catch (Exception e)
{
Utils.Trace(e, "Error writing items.");
throw ComUtils.CreateComException(e);
}
}
/// <summary>
/// Adds random values to write.
/// </summary>
private void AddWriteValues(
TestVariable variable,
WriteValueCollection nodesToWrite)
{
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
value.Value = m_generator.GetRandom(
variable.Variable.DataType,
variable.Variable.ValueRank,
variable.Variable.ArrayDimensions,
Session.TypeTree);
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
variable.Values.Add(value);
nodeToWrite.Value = value;
nodeToWrite.Handle = variable;
nodesToWrite.Add(nodeToWrite);
}
internal HistogramCounter(DataSet<InternalHistogram> dataSet)
: base(dataSet)
{
this.histogram = dataSet; // this avoids repeated casting.
this.writeValue = this.WriteUnroundedValue;
}
/// <summary>
/// Adds random values to write.
/// </summary>
private void AddWriteBadValues(
TestVariable variable,
WriteValueCollection nodesToWrite)
{
for (BuiltInType ii = BuiltInType.Null; ii < BuiltInType.DataValue; ii++)
{
if (variable.DataType != ii || variable.Variable.ValueRank >= 0)
{
// add random scalar.
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
value.Value = m_generator.GetRandom(ii);
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
variable.Values.Add(value);
nodeToWrite.Value = value;
nodeToWrite.Handle = variable;
nodesToWrite.Add(nodeToWrite);
}
if (variable.DataType != ii || variable.Variable.ValueRank == ValueRanks.Scalar)
{
// add random array.
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
value.Value = m_generator.GetRandomArray(ii, true, 100, false);
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
variable.Values.Add(value);
nodeToWrite.Value = value;
nodeToWrite.Handle = variable;
nodesToWrite.Add(nodeToWrite);
}
}
}
private void NewMI_Click(object sender, EventArgs e)
{
try
{
WriteValue value = new WriteValue();
if (new WriteValueEditDlg().ShowDialog(m_session, value))
{
AddItem(value);
}
AdjustColumns();
}
catch (Exception exception)
{
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
private void WriteMI_Click(object sender, EventArgs e)
{
try
{
if (NodesTV.SelectedNode == null)
{
return;
}
ReferenceDescription reference = NodesTV.SelectedNode.Tag as ReferenceDescription;
if (reference == null || (reference.NodeClass & (NodeClass.Variable | NodeClass.VariableType)) == 0)
{
return;
}
Session session = m_browser.Session;
// build list of nodes to read.
WriteValueCollection values = new WriteValueCollection();
WriteValue value = new WriteValue();
value.NodeId = (NodeId)reference.NodeId;
value.AttributeId = Attributes.Value;
value.IndexRange = null;
value.Value = null;
values.Add(value);
// show form.
new WriteDlg().Show(session, values);
}
catch (Exception exception)
{
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
/// <summary>
/// Removes nodes that are not actually writeable.
/// </summary>
private void InitialWrite()
{
WriteValueCollection nodesToWrite = new WriteValueCollection();
lock (m_variables)
{
for (int ii = 0; ii < m_variables.Count; ii++)
{
TestVariable variable = m_variables[ii];
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
if (!m_useDeadbandValues)
{
bool different = false;
do
{
value.Value = m_generator.GetRandom(
variable.Variable.DataType,
variable.Variable.ValueRank,
variable.Variable.ArrayDimensions,
Session.TypeTree);
if (variable.EURange != null)
{
value.Value = EnsureInRange(value.Value, variable.Variable, variable.EURange);
}
different = true;
for (int jj = variable.Values.Count - 1; jj >= 0; jj--)
{
if (m_comparer.CompareVariant(value.WrappedValue, variable.Values[jj].WrappedValue))
{
different = false;
break;
}
if (variable.DataType == BuiltInType.Boolean)
{
break;
}
}
}
while (!different);
}
else
{
value.Value = IncrementValue(variable, m_deadbandCounter);
}
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
nodeToWrite.Value = value;
nodeToWrite.Handle = variable.Values.Count;
nodesToWrite.Add(nodeToWrite);
variable.Values.Add(value);
variable.Timestamps.Add(DateTime.MinValue);
}
}
StatusCodeCollection results;
DiagnosticInfoCollection diagnosticInfos;
DateTime now = DateTime.UtcNow;
RequestHeader requestHeader = new RequestHeader();
requestHeader.ReturnDiagnostics = 0;
// need to check if the test completes and the next one starts while the write is in progress.
ResponseHeader responseHeader = Session.Write(
requestHeader,
nodesToWrite,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToWrite);
// check diagnostics.
if (diagnosticInfos != null && diagnosticInfos.Count > 0)
{
Log("Returned non-empty DiagnosticInfos array during Write.");
return;
}
// check results.
lock (m_variables)
{
List<TestVariable> writeableVariables = new List<TestVariable>();
for (int ii = 0; ii < nodesToWrite.Count; ii++)
{
if (StatusCode.IsGood(results[ii]))
{
m_variables[ii].WriteError = false;
writeableVariables.Add(m_variables[ii]);
}
}
m_variables.Clear();
m_variables.AddRange(writeableVariables);
}
}
/// <summary>
/// Reads the attributes, verifies the results and updates the nodes.
/// </summary>
private bool Write(int counter)
{
bool success = true;
m_deadbandCounter++;
WriteValueCollection nodesToWrite = new WriteValueCollection();
lock (m_variables)
{
if (m_stopped != 0 || counter != m_writeTimerCounter)
{
return true;
}
for (int ii = 0; ii < m_variables.Count; ii++)
{
TestVariable variable = m_variables[ii];
WriteValue nodeToWrite = new WriteValue();
nodeToWrite.NodeId = variable.Variable.NodeId;
nodeToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
if (!m_useDeadbandValues)
{
bool different = false;
do
{
value.Value = m_generator.GetRandom(
variable.Variable.DataType,
variable.Variable.ValueRank,
variable.Variable.ArrayDimensions,
Session.TypeTree);
if (variable.EURange != null)
{
value.Value = EnsureInRange(value.Value, variable.Variable, variable.EURange);
}
different = true;
for (int jj = variable.Values.Count-1; jj >= 0; jj--)
{
if (m_comparer.CompareVariant(value.WrappedValue, variable.Values[jj].WrappedValue))
{
different = false;
break;
}
if (variable.DataType == BuiltInType.Boolean)
{
break;
}
}
}
while (!different);
}
else
{
value.Value = IncrementValue(variable, m_deadbandCounter);
}
value.StatusCode = StatusCodes.Good;
value.ServerTimestamp = DateTime.MinValue;
value.SourceTimestamp = DateTime.MinValue;
nodeToWrite.Value = value;
nodeToWrite.Handle = variable.Values.Count;
nodesToWrite.Add(nodeToWrite);
variable.Values.Add(value);
variable.Timestamps.Add(DateTime.MinValue);
}
m_lastWriteTime = DateTime.UtcNow;
}
StatusCodeCollection results;
DiagnosticInfoCollection diagnosticInfos;
DateTime now = DateTime.UtcNow;
RequestHeader requestHeader = new RequestHeader();
requestHeader.ReturnDiagnostics = 0;
// need to check if the test completes and the next one starts while the write is in progress.
ResponseHeader responseHeader = Session.Write(
requestHeader,
nodesToWrite,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToWrite);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToWrite);
// check diagnostics.
if (diagnosticInfos != null && diagnosticInfos.Count > 0)
{
Log("Returned non-empty DiagnosticInfos array during Write.");
return false;
}
// check results.
lock (m_variables)
{
if (m_lastWriteTime > DateTime.MinValue && (DateTime.UtcNow - m_lastWriteTime).TotalMilliseconds > 300)
{
m_writeDelayed = true;
Log("WARNING: A Write operation took {0}s. Test results may not be meaningful.", (DateTime.UtcNow - m_lastWriteTime).TotalSeconds);
}
m_lastWriteTime = DateTime.UtcNow;
if (m_stopped != 0 || counter != m_writeTimerCounter)
{
return true;
}
for (int ii = 0; ii < nodesToWrite.Count; ii++)
{
TestVariable variable = m_variables[ii];
if (StatusCode.IsBad(results[ii]))
{
if (results[ii] == StatusCodes.BadTypeMismatch || results[ii] == StatusCodes.BadOutOfRange)
{
variable.WriteError = true;
continue;
}
Log("Unexpected error during Write.");
return false;
}
WriteValue request = nodesToWrite[ii];
variable.Timestamps[(int)request.Handle] = responseHeader.Timestamp;
}
m_writeCount++;
}
return success;
}
