OPC UA

Open Platform Communications Unified Architecture is a standardized open-source communication protocol that enables seamless and secure data exchange between robot controllers and other systems within a robotic cell. It ensures interoperability across different devices and manufacturers, simplifying the integration, monitoring, and coordination of automation setups in production environments.

In robotic programs, OPC UA is commonly used to perform I/O operations during program execution. This is accomplished by using an OPC UA client that connects to an OPC UA server, which must be network-accessible from NOVA. Python provides functionalities to integrate OPC UA operations into their workflows.

To use Wandelbots NOVA Python SDK in conjunction with an OPC UA server, you need a Python OPC UA client library.

from nova.extentions.opcua.client import OPCUAClient
 
async def connect_example():
    url = "opc.tcp://192.168.0.100:4840"  # Replace with your server URL
 
    async with OPCUAClient(url) as client:
        print("Connected to OPC UA server")

from nova.extentions.opcua.client import OPCUAClient
 
async def read_example(url: str):
    async with OPCUAClient(url) as client:
        temperature = await client.read_node("ns=2;s=Machine.Temperature") # Replace with OPC UA server node ID
        print("Current temperature:", temperature)

from nova.extentions.opcua.client import OPCUAClient
 
async def write_example(url: str):
    async with OPCUAClient(url) as client:
        await client.write_node("ns=2;s=Machine.StartButton", True) # Replace with OPC UA server node ID
        print("Machine start signal sent")

from nova.extentions.opcua.client import OPCUAClient
 
async def call_method_example(url: str):
    parent_node = "ns=2;s=Machine.Controller" # Node containing the method, replace with OPC UA server node ID
    method_node = "ns=2;s=Machine.Controller.Reset" # Method to call, replace with OPC UA server method node ID
 
    async with OPCUAClient(url) as client:
        result = await client.call_node(parent_node, method_node, "param1", 42)
        print("Method result:", result)

from nova.extentions.opcua.client import OPCUAClient, SubscriptionConfig
 
def condition(value):
    return value == 100  # Stop when value reaches 100
 
async def subscribe_example(url: str):
    config = SubscriptionConfig(print_received_messages=True)
 
    async with OPCUAClient(url) as client:
        await client.watch_node_until_condition(
            key="ns=2;s=Machine.Counter", # Replace with OPC UA server node ID
            condition=condition,
            config=config,
        )
        print("Condition met, subscription stopped")

Configure data exchange with config parameter

The Nova Python SDK provides comprehensive configuration parameters for OPC UA data exchange between server and client. These parameters are applied through OPC UA subscriptions, where the server notifies the client about all data changes for the respective nodes. The client can monitor and receive this information in real-time.

For detailed implementation guidance, refer to the official OPC UA documentation on:

Use the official OPC UA documentation to

1. subscribe to a data exchange  and
2. monitor data exchanges 

Available config parameters

Available config parameters and their default values are:

Configuration can be applied completely, partially, or not at all. When not specified, default values are used automatically.

Server response handling

OPC UA servers may modify requested configuration parameters due to their own restrictions. When this occurs, the subscription is created with the server’s revised settings, and you’ll be notified through the logging system. For example, if you request a publishing interval of 1000 ms, the server might enforce a different value based on its capabilities.

The client implementation includes parameter comparison logic that logs any differences between requested and revised subscription parameters

Use NOVA authentication with OPC UA

The Nova OPC UA client supports username and password-based authentication by embedding credentials directly in the connection URL.

The authentication follows the standard OPC UA URL format: opc.tcp://username:password@host:port.

Example: Communicate with a camera

The Python SDK provides functions for comprehensive OPC UA communication with industrial devices like Cognex cameras. The typical workflow includes:

• Loading jobs onto devices using opcua_call
• Writing configuration values with opcua_write
• Triggering operations via method calls
• Reading multiple values in batches with opcua_read

For complete implementation examples, see the OPC UA functions documentation  in the Python SDK repository.

SSL certificates for secure communication

When establishing OPC UA connections, following OPC UA security best practices is essential.

SSL certificates enable encrypted communication channels and verify the identities of both client and server, ensuring data integrity and confidentiality.

Notes

• The NOVA SDK uses the asyncua library as the underlying OPC UA implementation
• All OPC UA functions (opcua_read, opcua_write, opcua_call, wait_for_opcua_value) support the same security configuration format
• Certificate paths refer to files stored in the NOVA platform’s storage service, not local file system paths
• The SDK automatically handles temporary file creation and cleanup for certificates during secure connections

Wiki pages you might want to explore: Overview (wandelbotsgmbh/wandelbots-nova)