// Shows how to write into multiple OPC items using a single method call, and read multiple item values back.
//
// 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 System.Diagnostics;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.DataAccess;
using OpcLabs.EasyOpc.DataAccess.OperationModel;
namespace DocExamples.DataAccess._EasyDAClient
{
partial class WriteMultipleItemValues
{
public static void Main1()
{
// Instantiate the client object.
var client = new EasyDAClient();
Console.WriteLine("Writing multiple item values...");
OperationResult[] resultArray = client.WriteMultipleItemValues(
new[] {
new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345),
new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_BOOL", true),
new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56)
});
for (int i = 0; i < resultArray.Length; i++)
{
Debug.Assert(resultArray[i] != null);
if (resultArray[i].Succeeded)
Console.WriteLine($"Results[{i}]: success");
else
{
Debug.Assert(!(resultArray[i].Exception is null));
Console.WriteLine($"Results[{i}] *** Failure: {resultArray[i].ErrorMessageBrief}");
}
}
Console.WriteLine();
Console.WriteLine("Reading multiple item values...");
ValueResult[] valueResultArray = client.ReadMultipleItemValues("OPCLabs.KitServer.2",
new DAItemDescriptor[] {
"Simulation.Register_I4",
"Simulation.Register_BOOL",
"Simulation.Register_R4" });
for (int i = 0; i < valueResultArray.Length; i++)
{
Debug.Assert(valueResultArray[i] != null);
Console.WriteLine($"valueResultArray[{i}]: {valueResultArray[i]}");
}
// Example output:
//
//Writing multiple item values...
//Results[0]: success
//Results[1]: success
//Results[2]: success
//
//Reading multiple item values...
//valueResultArray[0]: Success; 12345 {System.Int32}
//valueResultArray[1]: Success; True {System.Boolean}
//valueResultArray[2]: Success; 234.56 {System.Single}
}
}
}
# Shows how to write into multiple OPC items using a single method call, and read multiple item values back.
#
# 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.DataAccess
using namespace OpcLabs.EasyOpc.DataAccess.OperationModel
# The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows .
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicCore.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassic.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicComponents.dll"
# Instantiate the client object.
$client = New-Object EasyDAClient
Write-Host "Writing multiple item values..."
$resultArray = $client.WriteMultipleItemValues(@(
(New-Object DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345)),
(New-Object DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_BOOL", $true)),
(New-Object DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56))
))
for ($i = 0; $i -lt $resultArray.Length; $i++) {
$result = $resultArray[$i]
if ($result.Succeeded) {
Write-Host "Result $($i): success"
}
else {
Write-Host "Result $($i) *** Failure: $($result.ErrorMessageBrief)"
}
}
Write-Host
Write-Host "Reading multiple item values..."
$valueResultArray = [IEasyDAClientExtension]::ReadMultipleItemValues($client,
"OPCLabs.KitServer.2", @(
(New-Object DAItemDescriptor("Simulation.Register_I4")),
(New-Object DAItemDescriptor("Simulation.Register_BOOL")),
(New-Object DAItemDescriptor("Simulation.Register_R4"))
))
for ($i = 0; $i -lt $valueResultArray.Length; $i++) {
$valueResult = $valueResultArray[$i]
Write-Host "valueResultArray[$($i)]: $($valueResult)"
}
# Example output:
#
#Writing multiple item values...
#Result 0: success
#Result 1: success
#Result 2: success
#
#Reading multiple item values...
#valueResultArray[0]: Success; 12345 {System.Int32}
#valueResultArray[1]: Success; True {System.Boolean}
#valueResultArray[2]: Success; 234.56 {System.Single}
' This example shows how to write values into multiple items.
'
' 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 OpcLabs.BaseLib.OperationModel
Imports OpcLabs.EasyOpc.DataAccess
Imports OpcLabs.EasyOpc.DataAccess.OperationModel
Namespace DataAccess._EasyDAClient
Partial Friend Class WriteMultipleItemValues
Public Shared Sub Main1()
Dim client = New EasyDAClient()
Dim argumentsArray = New DAItemValueArguments() { _
New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I4", 12345), _
New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_BOOL", True), _
New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56) _
}
Dim resultArray As OperationResult() = client.WriteMultipleItemValues(argumentsArray)
For i = 0 To resultArray.Length - 1
Debug.Assert(resultArray(i) IsNot Nothing)
If resultArray(i).Succeeded Then
Console.WriteLine("Results[{0}]: success", i)
Else
Console.WriteLine("Results[{0}] *** Failure: {1}", i, resultArray(i).ErrorMessageBrief)
End If
Next i
Console.WriteLine("Reading multiple item values...")
Dim valueResultArray() As ValueResult = client.ReadMultipleItemValues("OPCLabs.KitServer.2", _
New DAItemDescriptor() { _
"Simulation.Register_I4",
"Simulation.Register_BOOL",
"Simulation.Register_R4"})
For i = 0 To valueResultArray.Length - 1
Debug.Assert(valueResultArray(i) IsNot Nothing)
Console.WriteLine("valueResultArray[{0}]: {1}", i, valueResultArray(i))
Next i
End Sub
End Class
End Namespace
// This example shows how to write values into 3 items at once.
//
// 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.
$ItemValueArguments1 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments");
$ItemValueArguments1->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2";
$ItemValueArguments1->ItemDescriptor->ItemID = "Simulation.Register_I4";
$ItemValueArguments1->Value = 23456;
$ItemValueArguments2 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments");
$ItemValueArguments2->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2";
$ItemValueArguments2->ItemDescriptor->ItemID = "Simulation.Register_R8";
$ItemValueArguments2->Value = 2.34567890;
$ItemValueArguments3 = new COM("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments");
$ItemValueArguments3->ServerDescriptor->ServerClass = "OPCLabs.KitServer.2";
$ItemValueArguments3->ItemDescriptor->ItemID = "Simulation.Register_BSTR";
$ItemValueArguments3->Value = "ABC";
$arguments[0] = $ItemValueArguments1;
$arguments[1] = $ItemValueArguments2;
$arguments[2] = $ItemValueArguments3;
$Client = new COM("OpcLabs.EasyOpc.DataAccess.EasyDAClient");
$results = $Client->WriteMultipleItemValues($arguments);
for ($i = 0; $i < count($results); $i++)
{
$OperationResult = $results[$i];
if ($OperationResult->Succeeded)
printf("Result %d: success\n", $i);
else
printf("Result s\n", $i, $OperationResult->ErrorMessageBrief);
}
# Shows how to write into multiple OPC items using a single method call, and read multiple item values back.
#
# 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 OpcLabs.EasyOpc import *
from OpcLabs.EasyOpc.DataAccess import *
from OpcLabs.EasyOpc.DataAccess.OperationModel import *
from OpcLabs.EasyOpc.OperationModel import *
# Instantiate the client object.
client = EasyDAClient()
print('Writing multiple item values...')
operationResultArray = client.WriteMultipleItemValues([
DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_I4'),
12345),
DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_BOOL'),
True),
DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_R4'),
234.56),
])
for i, operationResult in enumerate(operationResultArray):
assert operationResult is not None
if operationResult.Succeeded:
print('operationResultArray[', i, ']: success', sep='')
else:
assert operationResult.Exception is not None
print('operationResultArray[', i, '] *** Failure: ', operationResult.ErrorMessageBrief, sep='')
print('Reading multiple item values...')
try:
valueResultArray = IEasyDAClientExtension.ReadMultipleItemValues(client, ServerDescriptor('OPCLabs.KitServer.2'), [
DAItemDescriptor('Simulation.Register_I4'),
DAItemDescriptor('Simulation.Register_BOOL'),
DAItemDescriptor('Simulation.Register_R4'),
])
except OpcException as opcException:
print('*** Failure: ' + opcException.GetBaseException().Message)
exit()
for i, valueResult in enumerate(valueResultArray):
assert valueResult is not None
if valueResult.Succeeded:
print('valueResultArray[', i, '].Value: ', valueResult.Value, sep='')
else:
assert valueResult.Exception is not None
print('valueResultArray[', i, '] *** Failure: ', valueResult.ErrorMessageBrief, sep='')
// Shows how to write into multiple OPC items using a single method call, specifying their requested data types.
//
// 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 System.Diagnostics;
using OpcLabs.BaseLib.ComInterop;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.DataAccess;
using OpcLabs.EasyOpc.DataAccess.OperationModel;
namespace DocExamples.DataAccess._EasyDAClient
{
partial class WriteMultipleItemValues
{
public static void RequestedDataType()
{
// Instantiate the client object.
var client = new EasyDAClient();
Console.WriteLine("Writing multiple item values...");
OperationResult[] resultArray = client.WriteMultipleItemValues(new[] {
new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I2", 12345)
{ ItemDescriptor = { RequestedDataType = VarTypes.I2}}, // <-- the requested data type
new DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56)
{ ItemDescriptor = { RequestedDataType = VarTypes.R4}} // <-- the requested data type
});
for (int i = 0; i < resultArray.Length; i++)
{
Debug.Assert(resultArray[i] != null);
if (resultArray[i].Succeeded)
Console.WriteLine("Result {0}: success", i);
else
{
Debug.Assert(!(resultArray[i].Exception is null));
Console.WriteLine("Result {0} *** Failure: {1}", i, resultArray[i].ErrorMessageBrief);
}
}
Console.WriteLine("Reading multiple item values...");
ValueResult[] valueResultArray = client.ReadMultipleItemValues("OPCLabs.KitServer.2",
new DAItemDescriptor[] { "Simulation.Register_I2", "Simulation.Register_R4" });
for (int i = 0; i < valueResultArray.Length; i++)
{
Debug.Assert(valueResultArray[i] != null);
Console.WriteLine("valueResultArray[{0}]: {1}", i, valueResultArray[i]);
}
}
}
}
' Shows how to write into multiple OPC items using a single method call, specifying their requested data types.
'
' 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 OpcLabs.BaseLib.ComInterop
Imports OpcLabs.EasyOpc.DataAccess
Imports OpcLabs.EasyOpc.DataAccess.OperationModel
Namespace DataAccess._EasyDAClient
Partial Friend Class WriteMultipleItemValues
Public Shared Sub RequestedDataType()
Dim client = New EasyDAClient()
Console.WriteLine("Writing multiple item values...")
Dim resultArray = client.WriteMultipleItemValues(New DAItemValueArguments() { _
New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_I2", 12345) With _
{.ItemDescriptor = New DAItemDescriptor() With {.RequestedDataType = VarTypes.I2}}, _
New DAItemValueArguments("", "OPCLabs.KitServer.2", "Simulation.Register_R4", 234.56) With _
{.ItemDescriptor = New DAItemDescriptor() With {.RequestedDataType = VarTypes.R4}} _
})
For i = 0 To resultArray.Length - 1
Debug.Assert(resultArray(i) IsNot Nothing)
If resultArray(i).Succeeded Then
Console.WriteLine("Result {0}: success", i)
Else
Debug.Assert(resultArray(i).Exception IsNot Nothing)
Console.WriteLine("Result {0} *** Failure: {1}", i, resultArray(i).ErrorMessageBrief)
End If
Next i
Console.WriteLine("Reading multiple item values...")
Dim valueResultArray = client.ReadMultipleItemValues("OPCLabs.KitServer.2",
New DAItemDescriptor() {"Simulation.Register_I2", "Simulation.Register_R4"})
For i = 0 To valueResultArray.Length - 1
Debug.Assert(valueResultArray(i) IsNot Nothing)
Console.WriteLine("valueResultArray[{0}]: {1}", i, valueResultArray(i))
Next i
End Sub
End Class
End Namespace
# Shows how to write into multiple OPC items using a single method call, specifying their requested data types.
#
# 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 OpcLabs.BaseLib.ComInterop import *
from OpcLabs.EasyOpc import *
from OpcLabs.EasyOpc.DataAccess import *
from OpcLabs.EasyOpc.DataAccess.OperationModel import *
from OpcLabs.EasyOpc.OperationModel import *
# Instantiate the client object.
client = EasyDAClient()
print('Writing multiple item values...')
arguments1 = DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'),
DAItemDescriptor('Simulation.Register_I2'),
12345)
arguments1.ItemDescriptor.RequestedDataType = VarType(VarTypes.I2) # <-- the requested data type
arguments2 = DAItemValueArguments(ServerDescriptor('OPCLabs.KitServer.2'),
DAItemDescriptor('Simulation.Register_R4'),
234.56)
arguments2.ItemDescriptor.RequestedDataType = VarType(VarTypes.R4) # <-- the requested data type
operationResultArray = client.WriteMultipleItemValues([arguments1, arguments2])
for i, operationResult in enumerate(operationResultArray):
assert operationResult is not None
if operationResult.Succeeded:
print('operationResultArray[', i, ']: success', sep='')
else:
assert operationResult.Exception is not None
print('operationResultArray[', i, '] *** Failure: ', operationResult.ErrorMessageBrief, sep='')
print('Reading multiple item values...')
try:
valueResultArray = IEasyDAClientExtension.ReadMultipleItemValues(client, ServerDescriptor('OPCLabs.KitServer.2'), [
DAItemDescriptor('Simulation.Register_I2'),
DAItemDescriptor('Simulation.Register_R4'),
])
except OpcException as opcException:
print('*** Failure: ' + opcException.GetBaseException().Message, sep='')
exit()
for i, valueResult in enumerate(valueResultArray):
assert valueResult is not None
if valueResult.Succeeded:
print('valueResultArray[', i, '].Value: ', valueResult.Value, sep='')
else:
assert valueResult.Exception is not None
print('valueResultArray[', i, '] *** Failure: ', valueResult.ErrorMessageBrief, sep='')
print('Finished.')
// This example measures the time needed to write 2000 item values all at once, and in 20 groups by 100 items.
// Note that the writes will currently all fail, as we do not have the appropriate writeable items available.
//
// 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 System.Diagnostics;
using System.Threading;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.DataAccess.OperationModel;
using OpcLabs.EasyOpc.DataAccess;
namespace DocExamples.DataAccess._EasyDAClient
{
partial class WriteMultipleItemValues
{
const int NumberOfGroups = 100;
const int ItemsInGroup = 20;
private const int TotalItems = NumberOfGroups * ItemsInGroup;
// Main method
public static void TimeMeasurements()
{
// Make the measurements 10 times; note that first time the times might be longer.
for (int i = 1; i <= 10; i++)
{
// Pause - we do not want the component to use the values it has in memory
Thread.Sleep(2 * 1000);
// Write all item values at once, and measure the time
var stopwatch1 = new Stopwatch();
stopwatch1.Start();
WriteAllAtOnce();
stopwatch1.Stop();
Console.WriteLine("WriteAllAtOnce has taken (milliseconds): {0}", stopwatch1.ElapsedMilliseconds);
// Pause - we do not want the component to use the values it has in memory
Thread.Sleep(2 * 1000);
// Write item values in groups, and measure the time
var stopwatch2 = new Stopwatch();
stopwatch2.Start();
WriteInGroups();
stopwatch2.Stop();
Console.WriteLine("WriteInGroups has taken (milliseconds): {0}", stopwatch2.ElapsedMilliseconds);
}
}
// Write all item values at once
private static void WriteAllAtOnce()
{
// Instantiate the client object.
var client = new EasyDAClient();
// Create an array of arguments for all items
var arguments = new DAItemValueArguments[TotalItems];
int index = 0;
for (int iLoop = 0; iLoop < NumberOfGroups; iLoop++)
for (int iItem = 0; iItem < ItemsInGroup; iItem++)
arguments[index++] = new DAItemValueArguments(
"OPCLabs.KitServer.2",
String.Format("Simulation.Incrementing.Copy_{0}.Phase_{1}", iLoop + 1, iItem + 1),
0);
// Perform the OPC write
OperationResult[] operationResults = client.WriteMultipleItemValues(arguments);
// Count successful results
int successCount = 0;
for (int iItem = 0; iItem < TotalItems; iItem++)
{
Debug.Assert(operationResults[iItem] != null);
if (operationResults[iItem].Succeeded)
successCount++;
}
if (successCount != TotalItems)
Console.WriteLine("Warning: There were some failures, success count is {0}", successCount);
}
// Write item values in groups
private static void WriteInGroups()
{
var client = new EasyDAClient();
int successCount = 0;
for (int iLoop = 0; iLoop < NumberOfGroups; iLoop++)
{
// Create an array of item arguments for items in one group
var arguments = new DAItemValueArguments[ItemsInGroup];
for (int iItem = 0; iItem < ItemsInGroup; iItem++)
arguments[iItem] = new DAItemValueArguments(
"OPCLabs.KitServer.2",
String.Format("Simulation.Incrementing.Copy_{0}.Phase_{1}", iLoop + 1, iItem + 1),
0);
// Perform the OPC write
OperationResult[] operationResults = client.WriteMultipleItemValues(arguments);
// Count successful results (totalling to previous value)
for (int iItem = 0; iItem < ItemsInGroup; iItem++)
{
Debug.Assert(operationResults[iItem] != null);
if (operationResults[iItem].Succeeded) successCount++;
}
}
if (successCount != TotalItems)
Console.WriteLine("Warning: There were some failures, success count is {0}", successCount);
}
}
}
' This example measures the time needed to write 2000 item values all at once, and in 20 groups by 100 items.
' Note that the writes will currently all fail, as we do not have the appropriate writeable items available.
'
' 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.Threading
Imports OpcLabs.BaseLib.OperationModel
Imports OpcLabs.EasyOpc.DataAccess
Imports OpcLabs.EasyOpc.DataAccess.OperationModel
Namespace DataAccess._EasyDAClient
Partial Friend Class WriteMultipleItemValues
Private Const NumberOfGroups As Integer = 100
Private Const ItemsInGroup As Integer = 20
Private Const TotalItems As Integer = NumberOfGroups * ItemsInGroup
' Main method
Public Shared Sub TimeMeasurements()
' Make the measurements 10 times; note that first time the times might be longer.
For i As Integer = 1 To 10
' Pause - we do not want the component to use the values it has in memory
Thread.Sleep(2 * 1000)
' Write all item values at once, and measure the time
Dim stopwatch1 = New Stopwatch()
stopwatch1.Start()
WriteAllAtOnce()
stopwatch1.Stop()
Console.WriteLine("WriteAllAtOnce has taken (milliseconds): {0}", stopwatch1.ElapsedMilliseconds)
' Pause - we do not want the component to use the values it has in memory
Thread.Sleep(2 * 1000)
' Write item values in groups, and measure the time
Dim stopwatch2 = New Stopwatch()
stopwatch2.Start()
WriteInGroups()
stopwatch2.Stop()
Console.WriteLine("WriteInGroups has taken (milliseconds): {0}", stopwatch2.ElapsedMilliseconds)
Next i
End Sub
' Write all item values at once
Private Shared Sub WriteAllAtOnce()
Dim client = New EasyDAClient()
' Create an array of arguments for all items
Dim arguments = New DAItemValueArguments(TotalItems - 1) {}
Dim index As Integer = 0
For iLoop As Integer = 0 To NumberOfGroups - 1
For iItem As Integer = 0 To ItemsInGroup - 1
arguments(index) = New DAItemValueArguments(
"OPCLabs.KitServer.2",
String.Format("Simulation.Incrementing.Copy_{0}.Phase_{1}", iLoop + 1, iItem + 1),
0)
index += 1
Next iItem
Next iLoop
' Perform the OPC write
Dim operationResults() As OperationResult = client.WriteMultipleItemValues(arguments)
' Count successful results
Dim successCount As Integer = 0
For iItem As Integer = 0 To TotalItems - 1
Debug.Assert(operationResults(iItem) IsNot Nothing)
If operationResults(iItem).Succeeded Then
successCount += 1
End If
Next iItem
If successCount <> TotalItems Then
Console.WriteLine("Warning: There were some failures, success count is {0}", successCount)
End If
End Sub
' Write item values in groups
Private Shared Sub WriteInGroups()
Dim client = New EasyDAClient()
Dim successCount As Integer = 0
For iLoop As Integer = 0 To NumberOfGroups - 1
' Create an array of item arguments for items in one group
Dim arguments = New DAItemValueArguments(ItemsInGroup - 1) {}
For iItem As Integer = 0 To ItemsInGroup - 1
arguments(iItem) = New DAItemValueArguments(
"OPCLabs.KitServer.2",
String.Format("Simulation.Incrementing.Copy_{0}.Phase_{1}", iLoop + 1, iItem + 1),
0)
Next iItem
' Perform the OPC write
Dim operationResults() As OperationResult = client.WriteMultipleItemValues(arguments)
' Count successful results (totalling to previous value)
For iItem As Integer = 0 To ItemsInGroup - 1
Debug.Assert(operationResults(iItem) IsNot Nothing)
If operationResults(iItem).Succeeded Then
successCount += 1
End If
Next iItem
Next iLoop
If successCount <> TotalItems Then
Console.WriteLine("Warning: There were some failures, success count is {0}", successCount)
End If
End Sub
End Class
End Namespace
// Shows how to write into multiple OPC XML-DA items using a single method call, and read multiple item values back.
//
// 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 System.Diagnostics;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.DataAccess;
using OpcLabs.EasyOpc.DataAccess.OperationModel;
namespace DocExamples.DataAccess.Xml
{
partial class WriteMultipleItemValues
{
public static void Main1Xml()
{
// Instantiate the client object.
var client = new EasyDAClient();
Console.WriteLine("Writing multiple item values...");
OperationResult[] resultArray = client.WriteMultipleItemValues(
new[] {
new DAItemValueArguments("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Analog Types/Int", 12345),
new DAItemValueArguments("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Simple Types/Boolean", true),
new DAItemValueArguments("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Analog Types/Double", 234.56)
});
for (int i = 0; i < resultArray.Length; i++)
{
Debug.Assert(resultArray[i] != null);
if (resultArray[i].Succeeded)
Console.WriteLine($"Results[{i}]: success");
else
{
Debug.Assert(!(resultArray[i].Exception is null));
Console.WriteLine($"Results[{i}] *** Failure: {resultArray[i].ErrorMessageBrief}");
}
}
Console.WriteLine();
Console.WriteLine("Reading multiple item values...");
ValueResult[] valueResultArray = client.ReadMultipleItemValues("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx",
new DAItemDescriptor[] {
"Static/Analog Types/Int",
"Static/Simple Types/Boolean",
"Static/Analog Types/Double" });
for (int i = 0; i < valueResultArray.Length; i++)
{
Debug.Assert(valueResultArray[i] != null);
Console.WriteLine($"valueResultArray[{i}]: {valueResultArray[i]}");
}
// Example output:
//
//Writing multiple item values...
//Results[0]: success
//Results[1]: success
//Results[2]: success
//
//Reading multiple item values...
//valueResultArray[0]: Success; 12345 {System.Int32}
//valueResultArray[1]: Success; True {System.Boolean}
//valueResultArray[2]: Success; 234.56 {System.Single}
}
}
}
' Shows how to write into multiple OPC XML-DA items using a single method call, and read multiple item values back.
'
' 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 OpcLabs.BaseLib.OperationModel
Imports OpcLabs.EasyOpc.DataAccess
Imports OpcLabs.EasyOpc.DataAccess.OperationModel
Namespace DataAccess.Xml
Partial Friend Class WriteMultipleItemValues
Public Shared Sub Main1Xml()
' Instantiate the client object.
Dim client = New EasyDAClient()
Console.WriteLine("Writing multiple item values...")
Dim resultArray As OperationResult() = client.WriteMultipleItemValues(New DAItemValueArguments() {
New DAItemValueArguments("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Analog Types/Int", 12345),
New DAItemValueArguments("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Simple Types/Boolean", True),
New DAItemValueArguments("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx", "Static/Analog Types/Double", 234.56)
})
For i = 0 To resultArray.Length - 1
Debug.Assert(resultArray(i) IsNot Nothing)
If resultArray(i).Succeeded Then
Console.WriteLine("Results[{0}]: success", i)
Else
Console.WriteLine("Results[{0}] *** Failure: {1}", i, resultArray(i).ErrorMessageBrief)
End If
Next i
Console.WriteLine()
Console.WriteLine("Reading multiple item values...")
Dim valueResultArray() As ValueResult = client.ReadMultipleItemValues("http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx",
New DAItemDescriptor() {
"Static/Analog Types/Int",
"Static/Simple Types/Boolean",
"Static/Analog Types/Double"})
For i = 0 To valueResultArray.Length - 1
Debug.Assert(valueResultArray(i) IsNot Nothing)
Console.WriteLine("valueResultArray[{0}]: {1}", i, valueResultArray(i))
Next i
' Example output:
'
'Writing multiple item values...
'Results[0]: success
'Results[1]: success
'Results[2]: success
'
'Reading multiple item values...
'valueResultArray[0]: Success; 12345 {System.Int32}
'valueResultArray[1]: Success; True {System.Boolean}
'valueResultArray[2]: Success; 234.56 {System.Single}
End Sub
End Class
End Namespace
# Shows how to write into multiple OPC XML-DA items using a single method call, and read multiple item values back.
#
# 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 import *
from OpcLabs.EasyOpc.DataAccess import *
from OpcLabs.EasyOpc.DataAccess.OperationModel import *
from OpcLabs.EasyOpc.OperationModel import *
# Instantiate the client object.
client = EasyDAClient()
print('Writing multiple item values...')
resultArray = client.WriteMultipleItemValues(
[
DAItemValueArguments(ServerDescriptor('http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx'), DAItemDescriptor('Static/Analog Types/Int'), Int32(12345)),
DAItemValueArguments(ServerDescriptor('http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx'), DAItemDescriptor('Static/Simple Types/Boolean'), True),
DAItemValueArguments(ServerDescriptor('http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx'), DAItemDescriptor('Static/Analog Types/Double'), 234.56)
])
for i, result in enumerate(resultArray):
assert result is not None
if result.Succeeded:
print('resultArray[', i, ']: success', sep='')
else:
assert result.Exception is not None
print('resultArray[', i, '] *** Failure: ', result.ErrorMessageBrief, sep='')
print()
print('Reading multiple item values...')
valueResultArray = IEasyDAClientExtension.ReadMultipleItemValues(client,
ServerDescriptor('http://opcxml.demo-this.com/XmlDaSampleServer/Service.asmx'),
[
DAItemDescriptor('Static/Analog Types/Int'),
DAItemDescriptor('Static/Simple Types/Boolean'),
DAItemDescriptor('Static/Analog Types/Double')
])
for i, valueResult in enumerate(valueResultArray):
assert valueResult is not None
if valueResult.Succeeded:
print('valueResultArray[', i, '].Value: ', valueResult.Value, sep='')
else:
assert valueResult.Exception is not None
print('valueResultArray[', i, '] *** Failure: ', valueResult.ErrorMessageBrief, sep='')
# Example output:
#
#Writing multiple item values...
#resultArray[0]: success
#resultArray[1]: success
#resultArray[2]: success
#
#Reading multiple item values...
#valueResultArray[0]: Success; 12345 {System.Int32}
#valueResultArray[1]: Success; True {System.Boolean}
#valueResultArray[2]: Success; 234.56 {System.Single}