// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
// each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-CSharp .
// Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
// a commercial license in order to use Online Forums, and we reply to every post.
using System;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;
namespace UADocExamples._EasyUAClient
{
partial class WriteMultipleValues
{
public static void ValueTypeCode()
{
UAEndpointDescriptor endpointDescriptor =
"opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
// or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
// or "https://opcua.demo-this.com:51212/UA/SampleServer/"
// Instantiate the client object.
var client = new EasyUAClient();
Console.WriteLine("Modifying values of nodes...");
OperationResult[] operationResultArray = client.WriteMultipleValues(new[]
{
new UAWriteValueArguments(endpointDescriptor,
"nsu=http://test.org/UA/Data/ ;i=10221", 23456)
{ValueTypeCode = TypeCode.Int32}, // here is the type explicitly specified
new UAWriteValueArguments(endpointDescriptor,
"nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double")
{ValueTypeCode = TypeCode.Double}, // here is the type explicitly specified
new UAWriteValueArguments(endpointDescriptor,
"nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC")
{ValueTypeCode = TypeCode.String} // here is the type explicitly specified
});
for (int i = 0; i < operationResultArray.Length; i++)
if (operationResultArray[i].Succeeded)
Console.WriteLine($"Result {i}: success");
else
Console.WriteLine($"Result {i}: {operationResultArray[i].Exception.GetBaseException().Message}");
// Example output:
//
//Modifying values of nodes...
//Result 0: success
//Result 1: Input string was not in a correct format.
//+ Attempting to change an object of type "System.String" to type "System.Double".
//+ The specified original value (string) was "This string cannot be converted to Double".
//+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;i=10226".
//+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
//Result 2: OPC UA service result - {BadNodeIdUnknown}. The node id refers to a node that does not exist in the server address space.
//+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;s=UnknownNode".
//+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
}
}
}
# This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
# each write and displays the exception message in case of failure.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in PowerShell on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PowerShell .
# Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
# a commercial license in order to use Online Forums, and we reply to every post.
#requires -Version 5.1
using namespace OpcLabs.EasyOpc.UA
using namespace OpcLabs.EasyOpc.UA.OperationModel
# The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows .
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUA.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUAComponents.dll"
[UAEndpointDescriptor]$endpointDescriptor =
"opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
# or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
# or "https://opcua.demo-this.com:51212/UA/SampleServer/"
# Instantiate the client object.
$client = New-Object EasyUAClient
Write-Host "Modifying values of nodes..."
$operationResultArray = $client.WriteMultipleValues([UAWriteValueArguments[]]@(
(New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10221", 23456) `
-Property @{ValueTypeCode = [TypeCode]::Int32}), # here is the type explicitly specified
(New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10226",
"This string cannot be converted to Double") `
-Property @{ValueTypeCode = [TypeCode]::Double}), # here is the type explicitly specified
(New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") `
-Property @{ValueTypeCode = [TypeCode]::String}) # here is the type explicitly specified
))
for ($i = 0; $i -lt $operationResultArray.Length; $i++) {
if ($operationResultArray[$i].Succeeded) {
Write-Host "Result $($i): success"
}
else {
Write-Host "Result $($i): $($operationResultArray[$i].Exception.GetBaseException().Message)"
}
}
# Example output:
#
#Modifying values of nodes...
#Result 0: success
#Result 1: Input string was not in a correct format.
#+ Attempting to change an object of type "System.String" to type "System.Double".
#+ The specified original value (string) was "This string cannot be converted to Double".
#+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;i=10226".
#+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
#Result 2: The status of the OPC-UA attribute data is not Good. The actual status is 'BadNodeIdUnknown'.
#+ During writing or method calls, readings may occur when value type is not specified.
#+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;s=UnknownNode".
#+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
' This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
' each write and displays the exception message in case of failure.
'
' Reasons for specifying the type explicitly might be:
' - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
' - The data type that the reports is incorrect.
' - Writing with an explicitly specified type is more efficient.
'
' Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
' OPC client and subscriber examples in VB.NET on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBNET .
' Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
' a commercial license in order to use Online Forums, and we reply to every post.
Imports System
Imports OpcLabs.BaseLib.OperationModel
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel
Namespace _EasyUAClient
Partial Friend Class WriteMultipleValues
Public Shared Sub ValueTypeCode()
' Define which server we will work with.
Dim endpointDescriptor As UAEndpointDescriptor =
"opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
' or "https://opcua.demo-this.com:51212/UA/SampleServer/"
' Instantiate the client object
Dim client = New EasyUAClient()
' Modify value of a node
Dim operationResultArray() As OperationResult = client.WriteMultipleValues(New UAWriteValueArguments() _
{ _
New UAWriteValueArguments(endpointDescriptor, _
"nsu=http://test.org/UA/Data/ ;i=10221", 23456) _
With {.ValueTypeCode = TypeCode.Int32}, _
New UAWriteValueArguments(endpointDescriptor, _
"nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double") _
With {.ValueTypeCode = TypeCode.Double}, _
New UAWriteValueArguments(endpointDescriptor, _
"nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") _
With {.ValueTypeCode = TypeCode.String} _
} _
)
For i As Integer = 0 To operationResultArray.Length - 1
If operationResultArray(i).Succeeded Then
Console.WriteLine("Result {0}: success", i)
Else
Console.WriteLine("Result {0}: {1}", i, operationResultArray(i).Exception.GetBaseException().Message)
End If
Next i
End Sub
End Class
End Namespace
// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
// each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client and subscriber examples in Object Pascal (Delphi) on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-OP .
// Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
// a commercial license in order to use Online Forums, and we reply to every post.
class procedure WriteMultipleValues.ValueTypeCode;
var
Arguments: OleVariant;
Client: OpcLabs_EasyOpcUA_TLB._EasyUAClient;
I: Cardinal;
WriteResult: _UAWriteResult;
WriteValueArguments1, WriteValueArguments2, WriteValueArguments3: _UAWriteValueArguments;
Results: OleVariant;
begin
WriteValueArguments1 := CoUAWriteValueArguments.Create;
WriteValueArguments1.EndpointDescriptor.UrlString :=
//'http://opcua.demo-this.com:51211/UA/SampleServer';
//'https://opcua.demo-this.com:51212/UA/SampleServer/';
'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
WriteValueArguments1.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10221';
WriteValueArguments1.Value := 23456;
WriteValueArguments1.ValueTypeCode := TypeCode_Int32; // here is the type explicitly specified
WriteValueArguments2 := CoUAWriteValueArguments.Create;
WriteValueArguments2.EndpointDescriptor.UrlString :=
//'http://opcua.demo-this.com:51211/UA/SampleServer';
//'https://opcua.demo-this.com:51212/UA/SampleServer/';
'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
WriteValueArguments2.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10226';
WriteValueArguments2.Value := 'This string cannot be converted to Double';
WriteValueArguments2.ValueTypeCode := TypeCode_Double; // here is the type explicitly specified
WriteValueArguments3 := CoUAWriteValueArguments.Create;
WriteValueArguments3.EndpointDescriptor.UrlString :=
//'http://opcua.demo-this.com:51211/UA/SampleServer';
//'https://opcua.demo-this.com:51212/UA/SampleServer/';
'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
WriteValueArguments3.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;s=UnknownNode';
WriteValueArguments3.Value := 'ABC';
WriteValueArguments3.ValueTypeCode := TypeCode_String; // here is the type explicitly specified
Arguments := VarArrayCreate([0, 2], varVariant);
Arguments[0] := WriteValueArguments1;
Arguments[1] := WriteValueArguments2;
Arguments[2] := WriteValueArguments3;
// Instantiate the client object
Client := CoEasyUAClient.Create;
// Modify values of nodes
TVarData(Results).VType := varArray or varVariant;
TVarData(Results).VArray := PVarArray(Client.WriteMultipleValues(Arguments));
// Display results
for I := VarArrayLowBound(Results, 1) to VarArrayHighBound(Results, 1) do
begin
WriteResult := IInterface(Results[I]) as _UAWriteResult;
if WriteResult.Succeeded then
WriteLn('Result ', I, ' success')
else
WriteLn('Result ', I, ': ', WriteResult.Exception.GetBaseException.Message);
end;
VarClear(Results);
VarClear(Arguments);
end;
// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
// each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client and subscriber examples in PHP on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-PHP .
// Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
// a commercial license in order to use Online Forums, and we reply to every post.
const TypeCode_Int32 = 9;
const TypeCode_Double = 14;
const TypeCode_String = 18;
$WriteValueArguments1 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments");
$WriteValueArguments1->EndpointDescriptor->UrlString =
//"http://opcua.demo-this.com:51211/UA/SampleServer";
//"https://opcua.demo-this.com:51212/UA/SampleServer/";
"opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
$WriteValueArguments1->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10221";
$WriteValueArguments1->Value = 23456;
$WriteValueArguments1->ValueTypeCode = TypeCode_Int32; // here is the type explicitly specified
$WriteValueArguments2 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments");
$WriteValueArguments2->EndpointDescriptor->UrlString =
//"http://opcua.demo-this.com:51211/UA/SampleServer";
//"https://opcua.demo-this.com:51212/UA/SampleServer/";
"opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
$WriteValueArguments2->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10226";
$WriteValueArguments2->Value = "This string cannot be converted to Double";
$WriteValueArguments2->ValueTypeCode = TypeCode_Double; // here is the type explicitly specified
$WriteValueArguments3 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments");
$WriteValueArguments3->EndpointDescriptor->UrlString =
//"http://opcua.demo-this.com:51211/UA/SampleServer";
//"https://opcua.demo-this.com:51212/UA/SampleServer/";
"opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
$WriteValueArguments3->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;s=UnknownNode";
$WriteValueArguments3->Value = "ABC";
$WriteValueArguments3->ValueTypeCode = TypeCode_String; // here is the type explicitly specified
$arguments[0] = $WriteValueArguments1;
$arguments[1] = $WriteValueArguments2;
$arguments[2] = $WriteValueArguments3;
// Instantiate the client object
$Client = new COM("OpcLabs.EasyOpc.UA.EasyUAClient");
// Modify values of nodes
$results = $Client->WriteMultipleValues($arguments);
// Display results
for ($i = 0; $i < count($results); $i++)
{
$WriteResult = $results[$i];
if ($WriteResult->Succeeded)
printf("Result %d success\n", $i);
else
printf("Result s \n", $i, $WriteResult->Exception->GetBaseException()->Message);
}
REM This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
REM each write and displays the exception message in case of failure.
REM
REM Reasons for specifying the type explicitly might be:
REM - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
REM - The data type that the reports is incorrect.
REM - Writing with an explicitly specified type is more efficient.
REM
REM Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
REM
REM Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
REM OPC client and subscriber examples in Visual Basic on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VB .
REM Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
REM a commercial license in order to use Online Forums, and we reply to every post.
Public Sub WriteMultipleValues_ValueTypeCode_Command_Click()
OutputText = ""
Const TypeCode_Int32 = 9
Const TypeCode_Double = 14
Const TypeCode_String = 18
' Instantiate the client object
Dim Client As New EasyUAClient
Dim WriteValueArguments1 As New UAWriteValueArguments
WriteValueArguments1.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
WriteValueArguments1.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10221"
WriteValueArguments1.SetValue 23456
WriteValueArguments1.ValueTypeCode = TypeCode_Int32 ' here is the type explicitly specified
Dim WriteValueArguments2 As New UAWriteValueArguments
WriteValueArguments2.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
WriteValueArguments2.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10226"
WriteValueArguments2.SetValue "This string cannot be converted to Double"
WriteValueArguments2.ValueTypeCode = TypeCode_Double ' here is the type explicitly specified
Dim WriteValueArguments3 As New UAWriteValueArguments
WriteValueArguments3.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
WriteValueArguments3.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;s=UnknownNode"
WriteValueArguments3.SetValue "ABC"
WriteValueArguments3.ValueTypeCode = TypeCode_String ' here is the type explicitly specified
Dim arguments(2) As Variant
Set arguments(0) = WriteValueArguments1
Set arguments(1) = WriteValueArguments2
Set arguments(2) = WriteValueArguments3
' Modify values of nodes
Dim results As Variant
results = Client.WriteMultipleValues(arguments)
' Display results
Dim i: For i = LBound(results) To UBound(results)
Dim Result As UAWriteResult: Set Result = results(i)
If Result.Succeeded Then
OutputText = OutputText & "Result " & i & " success" & vbCrLf
Else
OutputText = OutputText & "Result " & i & ": " & Result.Exception.GetBaseException().Message & vbCrLf
End If
Next
End Sub
# This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success
# of each write and displays the exception message in case of failure.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
# a commercial license in order to use Online Forums, and we reply to every post.
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc
# Import .NET namespaces.
from System import *
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *
endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'
# Instantiate the client object
client = EasyUAClient()
print('Modifying values of nodes...')
writeValueArguments1 = UAWriteValueArguments(endpointDescriptor,
UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10221'), 23456)
writeValueArguments1.ValueTypeCode = TypeCode.Int32 # here is the type explicitly specified
writeValueArguments2 = UAWriteValueArguments(endpointDescriptor,
UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10226'),
'This string cannot be converted to Double')
writeValueArguments2.ValueTypeCode = TypeCode.Double # here is the type explicitly specified
writeValueArguments3 = UAWriteValueArguments(endpointDescriptor,
UANodeDescriptor('nsu=http://test.org/UA/Data/ ;s=UnknownNode'),
'ABC')
writeValueArguments3.ValueTypeCode = TypeCode.String # here is the type explicitly specified
writeResultArray = IEasyUAClientExtension.WriteMultipleValues(client,
[writeValueArguments1, writeValueArguments2, writeValueArguments3])
for i, writeResult in enumerate(writeResultArray):
if writeResult.Succeeded:
print('writeResultArray[', i, ']: success', sep='')
else:
print('writeResultArray[', i, '] *** Failure: ', writeResult.Exception.GetBaseException().Message, sep='')
print()
print('Finished.')