SamplingInterval Property (IUADataSubscription)

The rate at which the monitored item should be accessed and evaluated (in milliseconds).

Syntax

Visual Basic
C#
C++/CLI

'Declaration
 
<UnitAttribute("ms")>
ReadOnly Property SamplingInterval As Integer

'Usage
 
Dim instance As IUADataSubscription
Dim value As Integer
 
value = instance.SamplingInterval

[Unit("ms")]
int SamplingInterval {get;}

[Unit("ms")]
property int SamplingInterval {
   int get();
}

Property Value

Unit of measurement is ms.

Remarks

This method or property does not throw any exceptions, aside from execution exceptions such as System.Threading.ThreadAbortException or System.OutOfMemoryException.

Example

CSharp
VB.NET

// This example shows how to implement own handling of data subscriptions.
// You can use any OPC UA client, including our Connectivity Explorer and OpcCmd utility, to connect to the server. 
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client, server and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-OPCStudio-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.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.NodeSpace;
using Timer = System.Timers.Timer;

namespace UAServerDocExamples._UAServerNode
{
    class DataSubscriptionChanged
    {
        public static void Main1()
        {
            // Instantiate the server object.
            // By default, the server will run on endpoint URL "opc.tcp://localhost:48040/".
            var server = new EasyUAServer();

            // Create a read-only data variable.
            var random = new Random();
            var dataVariable = UADataVariable.CreateIn(server.Objects, "SubscribeToThisVariable")
                .ValueType<int>()
                .Writable(false);

            dataVariable.UseDataPolling = false;    // Recommended, but not strictly necessary.
            dataVariable.DataSubscriptionChanged += (sender, args) =>
            {
                switch (args.Action)
                {
                    case UADataSubscriptionChangedAction.Add:
                    {
                        // Obtain the sampling interval from the data subscription.
                        int samplingInterval = args.DataSubscription.SamplingInterval;
                        Console.WriteLine($"Data subscription added, sampling interval: {samplingInterval}");

                        // Create a timer that will provide the data variable with a new data. In a real server the activity
                        // may also come from other sources.
                        var timer = new Timer { AutoReset = true, Interval = samplingInterval };
                        args.DataSubscription.State = timer;

                        // Set the read attribute data of the data variable to a random value whenever the timer interval elapses.
                        timer.Elapsed += (s, e) => args.DataSubscription.OnNext(random.Next());

                        // Start the subscription timer.
                        timer.Start();
                        break;
                    }

                    case UADataSubscriptionChangedAction.Remove:
                    {
                        Console.WriteLine("Data subscription removed");

                        // Dispose of the subscription timer (stopping it too).
                        var timer = (Timer)args.DataSubscription.State;
                        timer.Dispose();
                        break;
                    }

                    case UADataSubscriptionChangedAction.Modify:
                    {
                        int samplingInterval = args.DataSubscription.SamplingInterval;
                        Console.WriteLine($"Data subscription modified, sampling interval: {samplingInterval}");

                        // Change the interval of the subscription timer.
                        var timer = (Timer)args.DataSubscription.State;
                        timer.Interval = samplingInterval;
                        break;
                    }
                }
                args.Handled = true;    // Do not forget to indicate that your code has handled the event.
            };

            // The read behavior of the data variable needs to be defined as well, separately from the data subscriptions.
            dataVariable.ReadValueFunction(() => random.Next());
            
            // Start the server.
            Console.WriteLine("The server is starting...");
            server.Start();

            Console.WriteLine("The server is started.");
            Console.WriteLine();

            // Let the user decide when to stop.
            Console.WriteLine("Press Enter to stop the server...");
            Console.ReadLine();

            // Stop the server.
            Console.WriteLine("The server is stopping...");
            server.Stop();

            Console.WriteLine("The server is stopped.");
        }
    }
}

' This example shows how to implement own handling of data subscriptions.
' You can use any OPC UA client, including our Connectivity Explorer and OpcCmd utility, to connect to the server. 
'
' 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.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.NodeSpace
Imports Timer = System.Timers.Timer

Namespace _UAServerNode
    Partial Friend Class DataSubscriptionChanged
        Shared Sub Main1()
            ' Instantiate the server object.
            ' By default, the server will run on endpoint URL "opc.tcp://localhost:48040/".
            Dim server = New EasyUAServer()

            ' Create a read-only data variable.
            Dim random = New Random()
            Dim dataVariable = UADataVariable.CreateIn(server.Objects, "SubscribeToThisVariable") _
                .ValueType(Of Integer)() _
                .Writable(False)

            dataVariable.UseDataPolling = False ' Recommended, but not strictly necessary.
            AddHandler dataVariable.DataSubscriptionChanged, Sub(sender, args)
                                                                 Select Case args.Action
                                                                     Case UADataSubscriptionChangedAction.Add
                                                                         ' Obtain the sampling interval from the data subscription.
                                                                         Dim samplingInterval As Integer = args.DataSubscription.SamplingInterval
                                                                         Console.WriteLine($"Data subscription added, sampling interval: {samplingInterval}")

                                                                         ' Create a timer that will provide the data variable with a new data. In a real server the activity
                                                                         ' may also come from other sources.
                                                                         Dim timer = New Timer With {.AutoReset = True, .Interval = samplingInterval}
                                                                         args.DataSubscription.State = timer

                                                                         ' Set the read attribute data of the data variable to a random value whenever the timer interval elapses.
                                                                         AddHandler timer.Elapsed, Sub(s, e) args.DataSubscription.OnNext(random.Next())

                                                                         ' Start the subscription timer.
                                                                         timer.Start()

                                                                     Case UADataSubscriptionChangedAction.Remove
                                                                         Console.WriteLine("Data subscription removed")

                                                                         ' Dispose of the subscription timer (stopping it too).
                                                                         Dim timer As Timer = CType(args.DataSubscription.State, Timer)
                                                                         timer.Dispose()

                                                                     Case UADataSubscriptionChangedAction.Modify
                                                                         Dim samplingInterval As Integer = args.DataSubscription.SamplingInterval
                                                                         Console.WriteLine($"Data subscription modified, sampling interval: {samplingInterval}")

                                                                         ' Change the interval of the subscription timer.
                                                                         Dim timer As Timer = CType(args.DataSubscription.State, Timer)
                                                                         timer.Interval = samplingInterval
                                                                 End Select
                                                             End Sub

            ' The read behavior of the data variable needs to be defined as well, separately from the data subscriptions.
            dataVariable.ReadValueFunction(Function() random.Next())

            ' Start the server.
            Console.WriteLine("The server is starting...")
            server.Start()

            Console.WriteLine("The server is started.")
            Console.WriteLine()

            ' Let the user decide when to stop.
            Console.WriteLine("Press Enter to stop the server...")
            Console.ReadLine()

            ' Stop the server.
            Console.WriteLine("The server is stopping...")
            server.Stop()

            Console.WriteLine("The server is stopped.")
        End Sub
    End Class
End Namespace

Requirements

Target Platforms: .NET Framework: Windows 10 (selected versions), Windows 11 (selected versions), Windows Server 2016, Windows Server 2022; .NET: Linux, macOS, Microsoft Windows

Reference

IUADataSubscription Interface
IUADataSubscription Members

Documentation Home, Send Feedback. Resources: Knowledge Base, Product Downloads. Technical support: Online Forums, FAQ.

Missing some example? Ask us for it on our Online Forums! You do not have to own a commercial license in order to use Online Forums, and we reply to every post.