From Friday, April 19th (11:00 PM CDT) through Saturday, April 20th (2:00 PM CDT), 2024, ni.com will undergo system upgrades that may result in temporary service interruption.
We appreciate your patience as we improve our online experience.
Example Code
Code and Documents
Attachment
Introduction
The OPC UA (Unified Architecture) standard has been introduced by the OPC foundation and offers some distinct advantages over the DA standard that we are most familiar with. A key advantage is that it is no longer built on COM technology which means we can run the server on platforms other than Windows, including Real-Time.
This example uses the OPC UA library, introduced to LabVIEW DSC module 2011 SP1, to automatically mirror selected shared variable libraries on a OPC UA server. This can be used as a drop in VI to add this functionality to a LabVIEW system.
Please note this is only example code and is released under the NI sample code license (See below). It has been developed and shared in LabVIEW 2011 as this is first version to officially support the OPC UA libraries.
Application Description
Start Up
A key part of this application is start up as this is where the connections get set up. The shared variables are scanned from the specified libraries (with the exclusion of the blacklist which is useful when working with scan engine IO). For each of these we create a synchronised tag object.
Following this we then build the structure of the OPC UA structure to mimic the SV structure. The array of objects is then put in to a data value reference (DVR). This allows us to access them in parallel loops.
Polling
The architecture then runs two loops to update between the two systems. The OPC UA updates are detected from a user event which the library fires when it detects an update (this again is actually done at a set interval). On detecting a change we identify which indexes in our object array this corresponds to and then update them apprpriately. The data value is given as a variant which greatly simplifies this piece of code.
For the Shared Variables (SVs) we have to poll the items periodically instead. The object contains the previously known value so we can check if this has changed or not (the DVR and shared objects means we can also track updates from the OPC UA server as well) and the OPC UA tag is updated if needed.
For this loop performance was very important so some diagnostic code was removed that tracked errors to a tag as dealing with strings was too slow. This is also why there is a single DVR containing an array of objects as opposed to an array of DVRs, meaning we have 1x the overhead of dereferencing, instead of Nx (the tradeoff is that the other loop is locked out of the DVR for longer).
Performance
The exact performance is going to depend on your poll rate and number of tags. At a polling rate of 500ms with 140 tags we saw an increase of CPU of around 12% on a 9025 cRIO controller. A similar test with 44 tags showed an increase of 2.66%.
Please feel free to try this and post any feedback you have on this page.
Objects
I have used a couple of classes and object oriented programming in this design. Why? It suited well, I either created clusters and VIs for each tag or an object. They are largely functionally (& performance) equivalent in this code (I am not using any features of object oriented code such as dynamic dispatching) but I much prefer the organisation that comes with the object oriented implementation over the clusters.
If you are unfamiliar with them the simplest way is to think of them as clusters combined with specific functions that can act on them. In the project are the lvclass definitions which act as a library. The .ctl file will show you what data is stored in the object (looks a lot like a cluster 
) and any VIs associated with accessing the data are also in the library.
License
The attached Code is provided As Is. It has not been tested or validated as a product, for use in a deployed application or system, or for use in hazardous environments. You assume all risks for use of the Code and use of the Code is subject to the Sample Code License Terms which can be found at: http://ni.com/samplecodelicense
Example code from the Example Code Exchange in the NI Community is licensed with the MIT license.
I formated and reinstalled the software to the crio target. Now it is erroring as follows: "Deploying NI OPC UA Server.lvlib:Stop.viNI OPC UA Server.lvlib:Stop.vi loaded with errors on the target and was closed. LabVIEW: Failed to load shared library ni_opcua_server.*:NIOPCUA_StopServer:C. Ensure that the library is present on the RT target. Use MAX to install NI software or FTP to transfer custom libraries to the RT target"
When I press Ctrl-Shift Run, nothing visibly happens, I'm guessing it compiles in in the background because the "dirty" asterisk shows up in the title bar. I checked with an ftp tool that following are in the ni-rt/system folder: ni_opcua_base.out, ni_opcua_client.out, ni_opcua_server.out, ni_opcua_uastack.out.
The OPC US Demo example project has the same error.
