OPC Studio User's Guide and Reference
UAPubSubCommunicationParameters Class
'Declaration<ComDefaultInterfaceAttribute(OpcLabs.EasyOpc.UA.PubSub.ComTypes._UAPubSubCommunicationParameters)> <ComVisibleAttribute(True)> <GuidAttribute("D6953030-0FD2-42FC-AF26-B88E95B04EC8")> <CLSCompliantAttribute(True)> <TypeConverterAttribute(System.ComponentModel.ExpandableObjectConverter)> <ValueControlAttribute("OpcLabs.BaseLib.Forms.Common.ObjectSerializationControl, OpcLabs.BaseLibForms, Version=5.81.455.1, Culture=neutral, PublicKeyToken=6faddca41dacb409", DefaultReadWrite=False, Export=True, PageId=10001)> <SerializableAttribute()> Public Class UAPubSubCommunicationParameters Inherits OpcLabs.BaseLib.Parameters Implements LINQPad.ICustomMemberProvider, OpcLabs.BaseLib.ComTypes._Info, OpcLabs.BaseLib.ComTypes._Object2, OpcLabs.BaseLib.ComTypes._Parameters, OpcLabs.EasyOpc.UA.PubSub.ComTypes._UAPubSubCommunicationParameters, System.ICloneable, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable
'UsageDim instance As UAPubSubCommunicationParameters
[ComDefaultInterface(OpcLabs.EasyOpc.UA.PubSub.ComTypes._UAPubSubCommunicationParameters)] [ComVisible(true)] [Guid("D6953030-0FD2-42FC-AF26-B88E95B04EC8")] [CLSCompliant(true)] [TypeConverter(System.ComponentModel.ExpandableObjectConverter)] [ValueControl("OpcLabs.BaseLib.Forms.Common.ObjectSerializationControl, OpcLabs.BaseLibForms, Version=5.81.455.1, Culture=neutral, PublicKeyToken=6faddca41dacb409", DefaultReadWrite=false, Export=true, PageId=10001)] [Serializable()] public class UAPubSubCommunicationParameters : OpcLabs.BaseLib.Parameters, LINQPad.ICustomMemberProvider, OpcLabs.BaseLib.ComTypes._Info, OpcLabs.BaseLib.ComTypes._Object2, OpcLabs.BaseLib.ComTypes._Parameters, OpcLabs.EasyOpc.UA.PubSub.ComTypes._UAPubSubCommunicationParameters, System.ICloneable, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable
[ComDefaultInterface(OpcLabs.EasyOpc.UA.PubSub.ComTypes._UAPubSubCommunicationParameters)] [ComVisible(true)] [Guid("D6953030-0FD2-42FC-AF26-B88E95B04EC8")] [CLSCompliant(true)] [TypeConverter(System.ComponentModel.ExpandableObjectConverter)] [ValueControl("OpcLabs.BaseLib.Forms.Common.ObjectSerializationControl, OpcLabs.BaseLibForms, Version=5.81.455.1, Culture=neutral, PublicKeyToken=6faddca41dacb409", DefaultReadWrite=false, Export=true, PageId=10001)] [Serializable()] public ref class UAPubSubCommunicationParameters : public OpcLabs.BaseLib.Parameters, LINQPad.ICustomMemberProvider, OpcLabs.BaseLib.ComTypes._Info, OpcLabs.BaseLib.ComTypes._Object2, OpcLabs.BaseLib.ComTypes._Parameters, OpcLabs.EasyOpc.UA.PubSub.ComTypes._UAPubSubCommunicationParameters, System.ICloneable, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable
If you are on Windows, you can also use the OPC UA PubSub Demo Application to experiment with various settings. This allows you to try out and determine the correct parameters before you put them into the code.
A subscription is initiated by calling the SubscribeDataSet Method on the EasyUASubscriber Class. In its basic form, the method takes a single argument which is an instance of the EasyUASubscribeDataSetArguments Class, and this argument contains all the information necessary to perform the subscription. The object and all the sub-objects it contains are rather complex.
The picture below is meant to give you at least a general overview about what this object contains. There are more "smaller" properties to the individual objects on the picture, but we do not care about them for now.
The main parts of the EasyUASubscribeDataSetArguments is the DataSetSubscriptionDescriptor: it describes the dataset(s) you want to subscribe to.
The ResolverDescriptor in the DataSetSubscriptionDescriptor is for OPC UA PubSub logical resolution, if used.
Inside the dataset subscription descriptor, you always need to specify the PubSub connection, using the ConnectionDescriptor Property. You will typically also need to fill in data in the Filter Property (see Message Filtering (OPC UA PubSub)), and sometimes provide the DataSetMetaData Property (see Dataset Metadata (OPC UA PubSub)). The CommunicationParameters Property is used to specify details about the communication, message receive timeout, and parameters specific to message or transport protocol mapping.
There are many (extension method) overloads of the SubscribeDataSet Method, with various combinations of arguments. These overloads allow you to bypass the construction of the whole EasyUASubscribeDataSetArguments hierarchy, and pass in simply the parts you need.
The example below subscribes to all dataset messages on an OPC-UA PubSub connection with UDP UADP mapping. The connection is specified by its physical parameters, using the scheme name "opc.udp" and the IP address of the multicast group to listen on.
The example specifies just the PubSub connection, and receives all PubSub messages it encounters. In .NET, it illustrates the use of a SubscribeDataSet Method overload that takes just the PubSub connection descriptor as an input.
The information you pass in to the SubscribeDataSet Method may either be used "as is", or it may be subject to OPC UA PubSub logical resolution first. As explained in OPC UA PubSub Descriptors, you can pass in the physical identifiers, the logical identifiers, or both. The OPC UA PubSub logical resolution mechanism will be invoked if the dataset subscription descriptor requires resolution (this term is explained in OPC UA PubSub Descriptors).
We can reformulate it so: If you have specified physical identifiers everywhere, they will be directly used, and no logical resolution will take place - even if there are logical identifies filled in as well. If, however, you have a PubSub object somewhere in the descriptors that is only specified by its logical identifier but no physical identifier, the logical resolution mechanism will be used.
There are two ways your program can be informed about dataset messages that you have subscribed to:
It is also possible to specify a non-null callback parameter, and hook an event handler as well. In this case, the callback method will be invoked in addition to the event handlers.
The event arguments of the DataSetMessage Event are of type EasyUADataSetMessageEventArgs. Because it is indirectly derived from the OperationEventArgs, it contains the Exception Property which is null for success notifications, and non-null in case of failure. You can use the Succeeded Property to make the corresponding test. The actual data of the dataset, if available, is in the DataSetData Property.
The EasyUADataSetMessageEventArgs also contain, in their Arguments Property, a copy of the arguments (EasyUASubscribeDataSetArguments Class) you have used when making the dataset subscription that caused this event or callback. You can use this property to identify the dataset subscription, in case you are using event handlers and have made more subscriptions on the same object, or if you have used the same callback methods with multiple subscriptions. Specifically, the State Property in the EasyUASubscribeDataSetArguments can be used for any information you need to pass from the code that makes the subscription to the code that handles the dataset messages.
The EasyUASubscriber invokes the DataSetMessage event or callback when a new dataset message (you have subscribed to) arrives, but also in some other cases. Below is a list of possible property value combinations and their meaning.
The main causes for failures are
If the OPC UA PubSub logical resolution took place, the ResolvedDataSetSubscriptionDescriptor Property is filled in with a dataset subscription descriptor that is derived from the one you have specified when calling the SubscribeDataSet Method, but with the logical identifiers resolved to physical ones.
The dataset message event notification has a PubSubLocators Property. This property is always non-null (even in case of errors), and contains the information that allows to relate the event to its "source" in the OPC UA PubSub model. The object (UAPubSubLocators Class) has properties for a publisher Id, writer group Id, writer group name, dataset writer Id, and dataset writer name. The component will fill in as many of these properties as possible, given the circumstances. Knowing such relation comes handy when the dataset subscription filter is not for a single dataset, but for multiple datasets. Note that all information contained in the PubSubLocators Property is also available inside the dataset data. The difference is that the PubSubLocators object is present even in cases when there is dataset data - such as in case of errors. The PubSubLocators thus allow to determine the "source" of the error programmatically.
A typical task when processing the dataset message is to extract one or more fields from the dataset and process them further. The field is identified by its name (or an index in its string form, such "#0", if field names are not available) in the FieldDataDictionary. The example below shows how it can be done.
If metadata is available, you can alternatively use the FieldDataDictionaryById Property, which also contains the data for each field of the dataset message, but keyed by a dataset field Id (a GUID).
Depending how OPC UA PubSub is configured, the publisher might be always sending all fields of the dataset with every dataset message, or it may use a combination of key frames and delta frames. While the key frame dataset message includes values for all fields of the dataset, the delta frame only contains values of the fields that have changed since the previous dataset message.
Key frames and delta frames are a concept that exists purely to spare the network bandwidth. When you subscribe with QuickOPC, the delta frames are interpreted internally, and a full dataset is always shipped to you in the dataset message event or callback. This way, you do not have to put in any additional code to handle the distinction between key frames and delta frames.
It is not necessary to unsubscribe and subscribe again, if you want to change some parameters of existing subscription, such as its filter (Message Filtering (OPC UA PubSub)) or the associated metadata (Dataset Metadata (OPC UA PubSub)). You change the parameters by calling the ChangeDataSetSubscription Method, passing it the dataset subscription handle, and the new parameters in form of an instance of the EasyUADataSetSubscriptionChangeArguments Class.
There is also an extension method (an overload - with the same name) that allows you to easily pass in just the dataset subscription handle, and a new filter.
If you no longer want to receive dataset messages, you need to unsubscribe. This is achieved by calling the UnsubscribeDataSet Method, passing it the dataset subscription handle obtained when calling the SubscribeDataSet Method.
Example:
You can also unsubscribe from all dataset messages you have previously subscribed to (on the same instance of the EasyUASubscriber Class) by calling the UnsubscribeAllDataSets Method.
QuickOPC merges together requests to the same PubSub objects. If, for example, you make multiple dataset subscriptions and they all use the same PubSub connection, QuickOPC will only make the connection once.
This merging is performed among all subscriptions on all EasyUASubscriber objects that have their Isolated Property set to 'false' (the default). If you set the Isolated Property on some EasyUASubscriber object to 'true', the merging is then performed on the subscriptions made on that object only.
Newer versions of OPC UA specification allow the publishers to inform interested parties about their status, either cyclically, or when the status changes. OPC Studio recognizes and processes the publisher status messages in UADP and JSON message mappings. Any non-operational publisher status is reported as an error through the dataset subscription event handler or callback.
This functionality is commonly used with OPC UA PubSub Topic Tree, in which case the topic tree rules prescribe the name of the topic where the status messages for a particular publisher are located.
// This example shows how to subscribe to all dataset messages on an OPC-UA PubSub connection with MQTT JSON mapping using // TCP. // // The following package needs to be referenced in your project (or otherwise made available) for the MQTT transport to // work. // - OpcLabs.MqttNet // Refer to the documentation for more information. // // 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.Collections.Generic; using System.Threading; using OpcLabs.EasyOpc.UA.PubSub; using OpcLabs.EasyOpc.UA.PubSub.Engine; using OpcLabs.EasyOpc.UA.PubSub.OperationModel; namespace UASubscriberDocExamples.PubSub._EasyUASubscriber { partial class SubscribeDataSet { public static void MqttJsonTcp() { // Define the PubSub connection we will work with. Uses implicit conversion from a string. // Default port with MQTT is 1883. UAPubSubConnectionDescriptor pubSubConnectionDescriptor = "mqtt://opcua-pubsub.demo-this.com"; // Specify the transport protocol mapping. // The statement below isn't actually necessary, due to automatic message mapping recognition feature; see // https://kb.opclabs.com/OPC_UA_PubSub_Automatic_Message_Mapping_Recognition for more details. pubSubConnectionDescriptor.TransportProfileUriString = UAPubSubTransportProfileUriStrings.MqttJson; // Define the arguments for subscribing to the dataset, specifying the MQTT topic name. var subscribeDataSetArguments = new UASubscribeDataSetArguments(pubSubConnectionDescriptor) { DataSetSubscriptionDescriptor = {CommunicationParameters = {BrokerDataSetReaderTransportParameters = { QueueName = "opcuademo/json" }}} }; // Instantiate the subscriber object and hook events. var subscriber = new EasyUASubscriber(); subscriber.DataSetMessage += subscriber_DataSetMessage_MqttJsonTcp; Console.WriteLine("Subscribing..."); subscriber.SubscribeDataSet(subscribeDataSetArguments); Console.WriteLine("Processing dataset message events for 20 seconds..."); Thread.Sleep(20 * 1000); Console.WriteLine("Unsubscribing..."); subscriber.UnsubscribeAllDataSets(); Console.WriteLine("Waiting for 1 second..."); // Unsubscribe operation is asynchronous, messages may still come for a short while. Thread.Sleep(1 * 1000); Console.WriteLine("Finished."); } static void subscriber_DataSetMessage_MqttJsonTcp(object sender, EasyUADataSetMessageEventArgs e) { // Display the dataset. if (e.Succeeded) { // An event with null DataSetData just indicates a successful connection. if (!(e.DataSetData is null)) { Console.WriteLine(); Console.WriteLine($"Dataset data: {e.DataSetData}"); foreach (KeyValuePair<string, UADataSetFieldData> pair in e.DataSetData.FieldDataDictionary) Console.WriteLine(pair); } } else { Console.WriteLine(); Console.WriteLine($"*** Failure: {e.ErrorMessage}"); } } // Example output: // //Subscribing... //Processing dataset message events for 20 seconds... // //Dataset data: 2020-01-21T17:07:19.778,836,700,00; Good; Data; publisher=[String]31, class=eae79794-1af7-4f96-8401-4096cd1d8908, fields: 4 //[BoolToggle, True {System.Boolean} @2020-01-21T16:07:19.778,836,700,00; Good] //[Int32, 482 {System.Int64} @2020-01-21T16:07:19.778,836,700,00; Good] //[Int32Fast, 2287 {System.Int64} @2020-01-21T16:07:19.778,836,700,00; Good] //[DateTime, 1/21/2020 5:07:19 PM {System.DateTime} @2020-01-21T16:07:19.778,836,700,00; Good] // //Dataset data: Good; Data; publisher=[String]32, fields: 4 //[BoolToggle, True {System.Boolean}; Good] //[Int32, 482 {System.Int32}; Good] //[Int32Fast, 2287 {System.Int32}; Good] //[DateTime, 1/21/2020 5:07:19 PM {System.DateTime}; Good] // //Dataset data: Good; Data; publisher=[String]32, fields: 100 //[Mass_0, 82 {System.Int64}; Good] //[Mass_1, 182 {System.Int64}; Good] //[Mass_2, 282 {System.Int64}; Good] //[Mass_3, 382 {System.Int64}; Good] //[Mass_4, 482 {System.Int64}; Good] //[Mass_5, 582 {System.Int64}; Good] //[Mass_6, 682 {System.Int64}; Good] //[Mass_7, 782 {System.Int64}; Good] //[Mass_8, 882 {System.Int64}; Good] //[Mass_9, 982 {System.Int64}; Good] //[Mass_10, 1082 {System.Int64}; Good] ////... } }
' This example shows how to subscribe to all dataset messages on an OPC-UA PubSub connection with MQTT JSON mapping using ' TCP. ' ' The following package needs to be referenced in your project (or otherwise made available) for the MQTT transport to ' work. ' - OpcLabs.MqttNet ' Refer to the documentation for more information. ' ' 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.EasyOpc.UA.PubSub Imports OpcLabs.EasyOpc.UA.PubSub.Engine Imports OpcLabs.EasyOpc.UA.PubSub.OperationModel Namespace PubSub._EasyUASubscriber Partial Friend Class SubscribeDataSet Public Shared Sub MqttJsonTcp() ' Define the PubSub connection we will work with. Uses implicit conversion from a string. ' Default port with MQTT is 1883. Dim pubSubConnectionDescriptor As UAPubSubConnectionDescriptor = "mqtt://opcua-pubsub.demo-this.com" ' Specify the transport protocol mapping. ' The statement below isn't actually necessary, due to automatic message mapping recognition feature; see ' https://kb.opclabs.com/OPC_UA_PubSub_Automatic_Message_Mapping_Recognition for more details. pubSubConnectionDescriptor.TransportProfileUriString = UAPubSubTransportProfileUriStrings.MqttJson ' Define the arguments for subscribing to the dataset, specifying the MQTT topic name. Dim subscribeDataSetArguments = New UASubscribeDataSetArguments(pubSubConnectionDescriptor) subscribeDataSetArguments.DataSetSubscriptionDescriptor.CommunicationParameters.BrokerDataSetReaderTransportParameters.QueueName = "opcuademo/json" ' Instantiate the subscriber object and hook events. Dim subscriber = New EasyUASubscriber() AddHandler subscriber.DataSetMessage, AddressOf subscriber_DataSetMessage_MqttJsonTcp Console.WriteLine("Subscribing...") subscriber.SubscribeDataSet(subscribeDataSetArguments) Console.WriteLine("Processing dataset message events for 20 seconds...") Threading.Thread.Sleep(20 * 1000) Console.WriteLine("Unsubscribing...") subscriber.UnsubscribeAllDataSets() Console.WriteLine("Waiting for 1 second...") ' Unsubscribe operation is asynchronous, messages may still come for a short while. Threading.Thread.Sleep(1 * 1000) Console.WriteLine("Finished...") End Sub Private Shared Sub subscriber_DataSetMessage_MqttJsonTcp(ByVal sender As Object, ByVal e As EasyUADataSetMessageEventArgs) ' Display the dataset. If e.Succeeded Then ' An event with null DataSetData just indicates a successful connection. If e.DataSetData IsNot Nothing Then Console.WriteLine() Console.WriteLine($"Dataset data: {e.DataSetData}") For Each pair As KeyValuePair(Of String, UADataSetFieldData) In e.DataSetData.FieldDataDictionary Console.WriteLine(pair) Next End If Else Console.WriteLine() Console.WriteLine($"*** Failure: {e.ErrorMessage}") End If End Sub ' Example output: ' 'Subscribing... 'Processing dataset message events for 20 seconds... ' 'Dataset data: 2020-01-21T17:07:19.778,836,700,00; Good; Data; publisher=[String]31, class=eae79794-1af7-4f96-8401-4096cd1d8908, fields: 4 '[BoolToggle, True {System.Boolean} @2020-01-21T16:07:19.778,836,700,00; Good] '[Int32, 482 {System.Int64} @2020-01-21T16:07:19.778,836,700,00; Good] '[Int32Fast, 2287 {System.Int64} @2020-01-21T16:07:19.778,836,700,00; Good] '[DateTime, 1/21/2020 5:07:19 PM {System.DateTime} @2020-01-21T16:07:19.778,836,700,00; Good] ' 'Dataset data: Good; Data; publisher=[String]32, fields: 4 '[BoolToggle, True {System.Boolean}; Good] '[Int32, 482 {System.Int32}; Good] '[Int32Fast, 2287 {System.Int32}; Good] '[DateTime, 1/21/2020 5:07:19 PM {System.DateTime}; Good] ' 'Dataset data: Good; Data; publisher=[String]32, fields: 100 '[Mass_0, 82 {System.Int64}; Good] '[Mass_1, 182 {System.Int64}; Good] '[Mass_2, 282 {System.Int64}; Good] '[Mass_3, 382 {System.Int64}; Good] '[Mass_4, 482 {System.Int64}; Good] '[Mass_5, 582 {System.Int64}; Good] '[Mass_6, 682 {System.Int64}; Good] '[Mass_7, 782 {System.Int64}; Good] '[Mass_8, 882 {System.Int64}; Good] '[Mass_9, 982 {System.Int64}; Good] '[Mass_10, 1082 {System.Int64}; Good] '... End Class End Namespace
REM The following package needs to be referenced in your project (or otherwise made available) for the MQTT transport to REM work. REM - OpcLabs.MqttNet REM Refer to the documentation for more information. 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. ' The subscriber object, with events 'Public WithEvents Subscriber4 As EasyUASubscriber Private Sub EasyUASubscriber_SubscribeDataSet_MqttJsonTcp_Command_Click() OutputText = "" ' Define the PubSub connection we will work with. Uses implicit conversion from a string. ' Default port with MQTT is 1883. Dim subscribeDataSetArguments As New EasyUASubscribeDataSetArguments Dim pubSubConnectionDescriptor As UAPubSubConnectionDescriptor Set pubSubConnectionDescriptor = subscribeDataSetArguments.dataSetSubscriptionDescriptor.ConnectionDescriptor pubSubConnectionDescriptor.ResourceAddress.ResourceDescriptor.UrlString = "mqtt://opcua-pubsub.demo-this.com:1883" ' Specify the transport protocol mapping. ' The statement below isn't actually necessary, due to automatic message mapping recognition feature; see ' https://kb.opclabs.com/OPC_UA_PubSub_Automatic_Message_Mapping_Recognition for more details. pubSubConnectionDescriptor.TransportProfileUriString = "http://opcfoundation.org/UA-Profile/Transport/pubsub-mqtt-json" ' UAPubSubTransportProfileUriStrings.MqttJson ' Define the arguments for subscribing to the dataset, specifying the MQTT topic name. subscribeDataSetArguments.dataSetSubscriptionDescriptor.CommunicationParameters.BrokerDataSetReaderTransportParameters.QueueName = "opcuademo/json" ' Instantiate the subscriber object and hook events. Set Subscriber4 = New EasyUASubscriber OutputText = OutputText & "Subscribing..." & vbCrLf Call Subscriber4.SubscribeDataSet(subscribeDataSetArguments) OutputText = OutputText & "Processing dataset message for 20 seconds..." & vbCrLf Pause 20000 OutputText = OutputText & "Unsubscribing..." & vbCrLf Subscriber4.UnsubscribeAllDataSets OutputText = OutputText & "Waiting for 1 second..." & vbCrLf ' Unsubscribe operation is asynchronous, messages may still come for a short while. Pause 1000 Set Subscriber1 = Nothing OutputText = OutputText & "Finished." & vbCrLf End Sub Private Sub Subscriber4_DataSetMessage(ByVal sender As Variant, ByVal eventArgs As EasyUADataSetMessageEventArgs) ' Display the dataset If eventArgs.Succeeded Then ' An event with null DataSetData just indicates a successful connection. If Not eventArgs.DataSetData Is Nothing Then OutputText = OutputText & vbCrLf OutputText = OutputText & "Dataset data: " & eventArgs.DataSetData & vbCrLf Dim dictionaryEntry2 : For Each dictionaryEntry2 In eventArgs.DataSetData.FieldDataDictionary OutputText = OutputText & dictionaryEntry2 & vbCrLf Next End If Else OutputText = OutputText & vbCrLf OutputText = OutputText & eventArgs.ErrorMessageBrief & vbCrLf End If End Sub ' Example output: ' 'Subscribing... 'Processing dataset message events for 20 seconds... ' 'Dataset data: 2020-01-21T17:07:19.778,836,700,00; Good; Data; publisher=[String]31, class=eae79794-1af7-4f96-8401-4096cd1d8908, fields: 4 '[BoolToggle, True {System.Boolean} @2020-01-21T16:07:19.778,836,700,00; Good] '[Int32, 482 {System.Int64} @2020-01-21T16:07:19.778,836,700,00; Good] '[Int32Fast, 2287 {System.Int64} @2020-01-21T16:07:19.778,836,700,00; Good] '[DateTime, 1/21/2020 5:07:19 PM {System.DateTime} @2020-01-21T16:07:19.778,836,700,00; Good] ' 'Dataset data: Good; Data; publisher=[String]32, fields: 4 '[BoolToggle, True {System.Boolean}; Good] '[Int32, 482 {System.Int32}; Good] '[Int32Fast, 2287 {System.Int32}; Good] '[DateTime, 1/21/2020 5:07:19 PM {System.DateTime}; Good] ' 'Dataset data: Good; Data; publisher=[String]32, fields: 100 '[Mass_0, 82 {System.Int64}; Good] '[Mass_1, 182 {System.Int64}; Good] '[Mass_2, 282 {System.Int64}; Good] '[Mass_3, 382 {System.Int64}; Good] '[Mass_4, 482 {System.Int64}; Good] '[Mass_5, 582 {System.Int64}; Good] '[Mass_6, 682 {System.Int64}; Good] '[Mass_7, 782 {System.Int64}; Good] '[Mass_8, 882 {System.Int64}; Good] '[Mass_9, 982 {System.Int64}; Good] '[Mass_10, 1082 {System.Int64}; Good] '...
# This example shows how to subscribe to all dataset messages on an OPC-UA PubSub connection with MQTT JSON mapping using # TCP. # # The following package needs to be referenced in your project (or otherwise made available) for the MQTT transport to # work. # - OpcLabs.MqttNet # Refer to the documentation for more information. # # 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 opclabs_mqttnet import time # Import .NET namespaces. from OpcLabs.EasyOpc.UA.PubSub import * from OpcLabs.EasyOpc.UA.PubSub.Engine import * from OpcLabs.EasyOpc.UA.PubSub.OperationModel import * def dataSetMessage(sender, e): # Display the dataset. if e.Succeeded: # An event with null DataSetData just indicates a successful connection. if e.DataSetData is not None: print('') print('Dataset data: ', e.DataSetData, sep='') for pair in e.DataSetData.FieldDataDictionary: print(pair) else: print('') print('*** Failure: ', e.ErrorMessageBrief, sep='') print('*** Failure: ', e.Exception, sep='') # Define the PubSub connection we will work with. Uses implicit conversion from a string. # Default port with MQTT is 1883. pubSubConnectionDescriptor = UAPubSubConnectionDescriptor.op_Implicit('mqtt://opcua-pubsub.demo-this.com') # Specify the transport protocol mapping. # The statement below isn't actually necessary, due to automatic message mapping recognition feature; see # https://kb.opclabs.com/OPC_UA_PubSub_Automatic_Message_Mapping_Recognition for more details. pubSubConnectionDescriptor.TransportProfileUriString = UAPubSubTransportProfileUriStrings.MqttJson # Define the arguments for subscribing to the dataset, specifying the MQTT topic name. subscribeDataSetArguments = UASubscribeDataSetArguments(pubSubConnectionDescriptor) subscribeDataSetArguments.DataSetSubscriptionDescriptor.CommunicationParameters.BrokerDataSetReaderTransportParameters.\ QueueName = 'opcuademo/json' # Instantiate the subscriber object and hook events. subscriber = EasyUASubscriber() subscriber.DataSetMessage += dataSetMessage print('Subscribing...') IEasyUASubscriberExtension.SubscribeDataSet(subscriber, subscribeDataSetArguments) print('Processing dataset message events for 20 seconds...') time.sleep(20) print('Unsubscribing...') subscriber.UnsubscribeAllDataSets() print('Waiting for 1 second...') # Unsubscribe operation is asynchronous, messages may still come for a short while. time.sleep(1) subscriber.DataSetMessage -= dataSetMessage print('Finished.')
// This example shows how to subscribe to all dataset messages on an OPC-UA PubSub connection with MQTT UADP mapping using // TCP. // // The OpcLabs.MqttNet assembly needs to be referenced in your project (or otherwise made available, together with its // dependencies) for the MQTT transport to work. Refer to the documentation for more information. // // 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.Collections.Generic; using System.Threading; using OpcLabs.EasyOpc.UA.PubSub; using OpcLabs.EasyOpc.UA.PubSub.Engine; using OpcLabs.EasyOpc.UA.PubSub.OperationModel; namespace UASubscriberDocExamples.PubSub._EasyUASubscriber { partial class SubscribeDataSet { public static void MqttUadpTcp() { // Define the PubSub connection we will work with. Uses implicit conversion from a string. // Default port with MQTT is 1883. UAPubSubConnectionDescriptor pubSubConnectionDescriptor = "mqtt://opcua-pubsub.demo-this.com"; // Specify the transport protocol mapping. // The statement below isn't actually necessary, due to automatic message mapping recognition feature; see // https://kb.opclabs.com/OPC_UA_PubSub_Automatic_Message_Mapping_Recognition for more details. pubSubConnectionDescriptor.TransportProfileUriString = UAPubSubTransportProfileUriStrings.MqttUadp; // Define the arguments for subscribing to the dataset, specifying the MQTT topic name. var subscribeDataSetArguments = new UASubscribeDataSetArguments(pubSubConnectionDescriptor) { DataSetSubscriptionDescriptor = {CommunicationParameters = {BrokerDataSetReaderTransportParameters = { QueueName = "opcuademo/uadp/none" }}} }; // Instantiate the subscriber object and hook events. var subscriber = new EasyUASubscriber(); subscriber.DataSetMessage += subscriber_DataSetMessage_MqttUadpTcp; Console.WriteLine("Subscribing..."); subscriber.SubscribeDataSet(subscribeDataSetArguments); Console.WriteLine("Processing dataset message events for 20 seconds..."); Thread.Sleep(20 * 1000); Console.WriteLine("Unsubscribing..."); subscriber.UnsubscribeAllDataSets(); Console.WriteLine("Waiting for 1 second..."); // Unsubscribe operation is asynchronous, messages may still come for a short while. Thread.Sleep(1 * 1000); Console.WriteLine("Finished."); } static void subscriber_DataSetMessage_MqttUadpTcp(object sender, EasyUADataSetMessageEventArgs e) { // Display the dataset. if (e.Succeeded) { // An event with null DataSetData just indicates a successful connection. if (!(e.DataSetData is null)) { Console.WriteLine(); Console.WriteLine($"Dataset data: {e.DataSetData}"); foreach (KeyValuePair<string, UADataSetFieldData> pair in e.DataSetData.FieldDataDictionary) Console.WriteLine(pair); } } else { Console.WriteLine(); Console.WriteLine($"*** Failure: {e.ErrorMessage}"); } } // Example output: // //Subscribing... //Processing dataset message events for 20 seconds... // //Dataset data: Good; Data; publisher="32", writer=1, class=eae79794-1af7-4f96-8401-4096cd1d8908, fields: 4 //[#0, False {System.Boolean}; Good] //[#1, 6685 {System.Int32}; Good] //[#2, 1444 {System.Int32}; Good] //[#3, 1/4/2020 6:06:20 PM {System.DateTime}; Good] // //Dataset data: Good; Data; publisher="32", writer=3, class=96976b7b-0db7-46c3-a715-0979884b55ae, fields: 100 //[#0, 85 {System.Int64}; Good] //[#1, 185 {System.Int64}; Good] //[#2, 285 {System.Int64}; Good] //[#3, 385 {System.Int64}; Good] //[#4, 485 {System.Int64}; Good] //[#5, 585 {System.Int64}; Good] //[#6, 685 {System.Int64}; Good] //[#7, 785 {System.Int64}; Good] //[#8, 885 {System.Int64}; Good] //[#9, 985 {System.Int64}; Good] //[#10, 1085 {System.Int64}; Good] //... } }
' This example shows how to subscribe to all dataset messages on an OPC-UA PubSub connection with MQTT UADP mapping using ' TCP. ' ' The OpcLabs.MqttNet assembly needs to be referenced in your project (or otherwise made available, together with its ' dependencies) for the MQTT transport to work. Refer to the documentation for more information. ' ' 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.EasyOpc.UA.PubSub Imports OpcLabs.EasyOpc.UA.PubSub.Engine Imports OpcLabs.EasyOpc.UA.PubSub.OperationModel Namespace PubSub._EasyUASubscriber Partial Friend Class SubscribeDataSet Public Shared Sub MqttUadpTcp() ' Define the PubSub connection we will work with. Uses implicit conversion from a string. ' Default port with MQTT is 1883. Dim pubSubConnectionDescriptor As UAPubSubConnectionDescriptor = "mqtt://opcua-pubsub.demo-this.com" ' Specify the transport protocol mapping. ' The statement below isn't actually necessary, due to automatic message mapping recognition feature; see ' https://kb.opclabs.com/OPC_UA_PubSub_Automatic_Message_Mapping_Recognition for more details. pubSubConnectionDescriptor.TransportProfileUriString = UAPubSubTransportProfileUriStrings.MqttUadp ' Define the arguments for subscribing to the dataset, specifying the MQTT topic name. Dim subscribeDataSetArguments = New UASubscribeDataSetArguments(pubSubConnectionDescriptor) subscribeDataSetArguments.DataSetSubscriptionDescriptor.CommunicationParameters.BrokerDataSetReaderTransportParameters.QueueName = "opcuademo/uadp/none" ' Instantiate the subscriber object and hook events. Dim subscriber = New EasyUASubscriber() AddHandler subscriber.DataSetMessage, AddressOf subscriber_DataSetMessage_MqttUadpTcp Console.WriteLine("Subscribing...") subscriber.SubscribeDataSet(subscribeDataSetArguments) Console.WriteLine("Processing dataset message events for 20 seconds...") Threading.Thread.Sleep(20 * 1000) Console.WriteLine("Unsubscribing...") subscriber.UnsubscribeAllDataSets() Console.WriteLine("Waiting for 1 second...") ' Unsubscribe operation is asynchronous, messages may still come for a short while. Threading.Thread.Sleep(1 * 1000) Console.WriteLine("Finished...") End Sub Private Shared Sub subscriber_DataSetMessage_MqttUadpTcp(ByVal sender As Object, ByVal e As EasyUADataSetMessageEventArgs) ' Display the dataset. If e.Succeeded Then ' An event with null DataSetData just indicates a successful connection. If e.DataSetData IsNot Nothing Then Console.WriteLine() Console.WriteLine($"Dataset data: {e.DataSetData}") For Each pair As KeyValuePair(Of String, UADataSetFieldData) In e.DataSetData.FieldDataDictionary Console.WriteLine(pair) Next End If Else Console.WriteLine() Console.WriteLine($"*** Failure: {e.ErrorMessage}") End If End Sub ' Example output: ' 'Subscribing... 'Processing dataset message events for 20 seconds... ' 'Dataset data: Good; Data; publisher="32", writer=1, class=eae79794-1af7-4f96-8401-4096cd1d8908, fields: 4 '[#0, False {System.Boolean}; Good] '[#1, 6685 {System.Int32}; Good] '[#2, 1444 {System.Int32}; Good] '[#3, 1/4/2020 6:06:20 PM {System.DateTime}; Good] ' 'Dataset data: Good; Data; publisher="32", writer=3, class=96976b7b-0db7-46c3-a715-0979884b55ae, fields: 100 '[#0, 85 {System.Int64}; Good] '[#1, 185 {System.Int64}; Good] '[#2, 285 {System.Int64}; Good] '[#3, 385 {System.Int64}; Good] '[#4, 485 {System.Int64}; Good] '[#5, 585 {System.Int64}; Good] '[#6, 685 {System.Int64}; Good] '[#7, 785 {System.Int64}; Good] '[#8, 885 {System.Int64}; Good] '[#9, 985 {System.Int64}; Good] '[#10, 1085 {System.Int64}; Good] '... End Class End Namespace
# This example shows how to subscribe to all dataset messages on an OPC-UA PubSub connection with MQTT UADP mapping # using TCP. # # The following package needs to be referenced in your project (or otherwise made available) for the MQTT transport to # work. # - OpcLabs.MqttNet # Refer to the documentation for more information. # # 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 time # Import .NET namespaces. from OpcLabs.EasyOpc.UA.PubSub import * from OpcLabs.EasyOpc.UA.PubSub.Engine import * from OpcLabs.EasyOpc.UA.PubSub.OperationModel import * def dataSetMessage(sender, e): # Display the dataset. if e.Succeeded: # An event with null DataSetData just indicates a successful connection. if e.DataSetData is not None: print('') print('Dataset data: ', e.DataSetData, sep='') for pair in e.DataSetData.FieldDataDictionary: print(pair) else: print('') print('*** Failure: ', e.ErrorMessageBrief, sep='') # Define the PubSub connection we will work with. Uses implicit conversion from a string. # Default port with MQTT is 1883. pubSubConnectionDescriptor = UAPubSubConnectionDescriptor.op_Implicit('mqtt://opcua-pubsub.demo-this.com') # Specify the transport protocol mapping. # The statement below isn't actually necessary, due to automatic message mapping recognition feature; see # https://kb.opclabs.com/OPC_UA_PubSub_Automatic_Message_Mapping_Recognition for more details. pubSubConnectionDescriptor.TransportProfileUriString = UAPubSubTransportProfileUriStrings.MqttUadp # Define the arguments for subscribing to the dataset, specifying the MQTT topic name. subscribeDataSetArguments = UASubscribeDataSetArguments(pubSubConnectionDescriptor) subscribeDataSetArguments.DataSetSubscriptionDescriptor.CommunicationParameters.BrokerDataSetReaderTransportParameters.\ QueueName = 'opcuademo/uadp/none' # Instantiate the subscriber object and hook events. subscriber = EasyUASubscriber() subscriber.DataSetMessage += dataSetMessage print('Subscribing...') IEasyUASubscriberExtension.SubscribeDataSet(subscriber, subscribeDataSetArguments) print('Processing dataset message events for 20 seconds...') time.sleep(20) print('Unsubscribing...') subscriber.UnsubscribeAllDataSets() print('Waiting for 1 second...') # Unsubscribe operation is asynchronous, messages may still come for a short while. time.sleep(1) subscriber.DataSetMessage -= dataSetMessage print('Finished.')
System.Object
OpcLabs.BaseLib.Object2
OpcLabs.BaseLib.Info
OpcLabs.BaseLib.Parameters
OpcLabs.EasyOpc.UA.PubSub.UAPubSubCommunicationParameters
OpcLabs.EasyOpc.UA.PubSub.UASubscriberCommunicationParameters