Importing S7-1500 OPC UA Nodeset XML into Python-opcua Server

Overview

The SIMATIC S7-1500 CPU family (and the motion-extended S7-1500T variants) ship with a built-in OPC UA server that exposes the PLC's data and the standard SIMATIC information model over a defined set of namespaces. For engineering, integration, and unit testing, Siemens allows the complete address space of that server to be exported as a UANodeSet2 XML file directly from STEP 7 (TIA Portal). This file describes every node, reference, data type, and variable exactly as the running CPU would present them.

The python-opcua project (formerly known as FreeOpcUa, hosted at github.com/FreeOpcUa/python-opcua) is the de-facto open-source OPC UA implementation for Python. It ships with helpers to import a UANodeSet XML and reconstruct an equivalent server-side address space from it — most notably the server-import-robot-nodeset.py example in the examples/ directory.

Engineers frequently want to:

• Recreate the S7-1500 server in Python so that SCADA, MES, or HMI test harnesses can be developed without a live PLC.
• Validate client code paths against a deterministic mock that mirrors the production namespace layout.
• Run CI/CD unit tests that exercise variable subscription, read/write, and method calls on the same address space that will exist on the real CPU.

Although the export and the import both speak UANodeSet2, the Siemens XML contains extension nodes (companion specifications, server diagnostics, the SIMATIC namespace) and a particular NodeId scheme that trips the python-opcua parser. The symptom is typically a parse failure with the message that the parent node cannot be found, or a silent skip of portions of the address space. This reference covers the export procedure, the import procedure, the parser-level root causes, and the field-proven workarounds.

Prerequisites

Verify the python-opcua install supports UANodeSet import. The example file examples/server-import-robot-nodeset.py must exist in your local checkout or wheel-distributed copy. If it does not, you are on a stripped-down or async-only fork and will need to fall back to the ua_utils load_default_nodes path described later.

Exporting the UANodeSet XML from TIA Portal

The export path documented by Siemens for the S7-1500 / S7-1500T is described in the TIA Portal help under "Using the S7-1500 as an OPC UA server — Export OPC UA XML file" (see the Siemens TIA Portal V20 documentation). The procedure is:

1. In the project tree, right-click the S7-1500 CPU and choose Properties.
2. Open OPC UA > Server.
3. Confirm the server is enabled, that the SIMATIC server interface is checked, and that the port (default 4840) and security policies match the test harness.
4. Click Export OPC UA XML (or navigate via the TIA Portal menu Tools > Export OPC UA XML depending on the version).
5. Select the export scope: Complete server address space is required for a true unit-test mirror. Selected program blocks produces a partial nodeset that cannot reconstruct the server in Python.
6. Save the file with the .xml extension. Siemens recommends UTF-8 with BOM for cross-tool compatibility.

The resulting file is a UANodeSet2 document. Its root looks like:

<UANodeSet xmlns="http://opcfoundation.org/UA/2011/03/UANodeSet.xsd"
           xmlns:uax="http://opcfoundation.org/UA/2008/02/Types.xsd"
           xmlns:si="http://www.siemens.com/OPCUA/2024/01/SimaticServer"
           xmlns:ns0="http://yourcompany.com/PLC/Project1"
           LastModified="2024-05-12T10:33:00Z">

Note the custom namespace declarations. si: is the SIMATIC companion specification namespace, and the project namespace ns0: is generated from the TIA project name. The python-opcua parser must be able to resolve these prefixes, which is the first point at which imports commonly fail.

Importing the Nodeset with python-opcua

The canonical import pattern uses ua_utils.import_xml or, for the async server, the equivalent helper. The reference example follows this template:

import asyncio
from asyncua import Server, ua
from asyncua.ua import ua_utils

async def main():
    server = Server()
    await server.init()
    server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
    # Import the Siemens nodeset
    await ua_utils.import_xml(server, "/path/to/s7_1500_nodeset.xml")
    async with server:
        while True:
            await asyncio.sleep(1)

if __name__ == "__main__":
    asyncio.run(main())

For the legacy (sync) FreeOpcUa server, the equivalent is:

from opcua import Server
from opcua.ua import ua_utils

server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
server.start()
ua_utils.import_xml(server, "/path/to/s7_1500_nodeset.xml")
try:
    while True:
        pass
except KeyboardInterrupt:
    server.stop()

The function ua_utils.import_xml walks the UANodeSet document in dependency order: data types first, then reference types, then object types, then the instance tree. Any forward reference encountered before its target is registered raises a UaError with the message that the parent node cannot be found.

Root Cause: Why the Parent Node Cannot Be Found

The Siemens UANodeSet is built bottom-up. Some OPC UA design tools emit nodes in a flat, dependency-ordered sequence; TIA Portal emits them in the order of the project tree. This is technically valid OPC UA, but it requires the importer to perform multiple passes or to buffer nodes. The python-opcua importer is single-pass and resolves parents as it goes. When it meets a UAObject whose ParentNodeId references a node declared further down in the file, parsing aborts with a parent-not-found error.

Secondary root causes that surface with the same message:

Solution: Step-by-Step Workaround for the Parent-Not-Found Error

The recommended field-proven procedure, in order, is:

1. Confirm the import helper is the right one. Use asyncua.ua.ua_utils.import_xml (async) or opcua.ua.ua_utils.import_xml (sync). Do not call load_default_nodes followed by manual XML parsing — that bypasses the dependency resolver.
2. Verify lxml is installed. pip install lxml --upgrade. lxml is what handles the UANodeSet2 schema; the stdlib xml.etree is not sufficient.
3. Force UTF-8 with BOM on the export. In TIA Portal, when prompted for the export encoding, choose UTF-8 with signature. If the file is already exported without BOM, prepend the bytes EF BB BF via a script:
   

   with open("nodeset.xml","rb") as f: data = f.read()
   if not data.startswith(b"\xef\xbb\xbf"):
       open("nodeset.xml","wb").write(b"\xef\xbb\xbf" + data)

4. Pre-declare all namespaces. The Siemens file uses the si: (SIMATIC) and project-specific nsX: prefixes. python-opcua needs to see every prefix that appears in NodeId expansions. If the importer logs "namespace not registered," add it to your server's namespace array before calling import_xml:
   

   idx_si = await server.register_namespace("http://www.siemens.com/OPCUA/2024/01/SimaticServer")
   idx_ns0 = await server.register_namespace("http://yourcompany.com/PLC/Project1")

5. Patch the importer for two-pass behaviour (if the error persists). This is the workaround discussed in the FreeOpcUa community for exactly this use case. Replace the single-pass walker with a buffering pass:
   

   def import_xml_two_pass(server, xml_path):
       tree = etree.parse(xml_path)
       nodes = list(tree.findall(".//{*}UAObject")) + \
               list(tree.findall(".//{*}UAVariable")) + \
               list(tree.findall(".//{*}UAMethod"))
       # Pass 1: register NodeIds as opaque references (no hierarchy)
       for n in nodes:
           node_id = NodeId.from_string(n.get("NodeId"))
           server.nodes.store_node_id(node_id)
       # Pass 2: instantiate in the original order
       for n in nodes:
           ua_utils._add_node(server, n)

   
   Where _add_node is the internal helper the standard import_xml calls per node. This is the closest practical workaround when you cannot modify the export.
6. Fallback: import only the user-defined namespace. When two-pass import still fails on the SIMATIC si: namespace (which contains hundreds of diagnostic nodes), edit the XML and remove the si: prefix. python-opcua imports the user namespace cleanly, and your test harness only needs that portion. Diagnostic nodes are not required for unit tests of business logic.

Verification

After import, the server's address space must contain the same root objects that a live S7-1500 exposes. A simple verification script:

from asyncua import Client

async def verify():
    async with Client(url="opc.tcp://localhost:4840/freeopcua/server/") as client:
        root = client.nodes.root
        objects = await client.nodes.objects.get_children()
        for obj in objects:
            print(obj, await obj.read_browse_name())
        # Critical: confirm the project namespace root is present
        ns0_root = await client.nodes.objects.get_child(["0:Project1"])
        assert ns0_root is not None, "Project1 namespace not imported"
        # Confirm a known PLC tag is reachable
        test_tag = await ns0_root.get_child(["0:DB_HMI", "0:Heartbeat"])
        val = await test_tag.read_value()
        print("Heartbeat:", val)

asyncio.run(verify())

Pass criteria:

• The Objects folder contains both the SIMATIC diagnostic node and the project namespace root (e.g. Project1).
• User-defined DBs and tags are browseable and readable.
• Subscription latency matches the live PLC within an order of magnitude (typically <50 ms on localhost for python-opcua vs 10–20 ms on a real S7-1500).

Unit-Testing Strategy with the Reconstructed Server

Once the address space is reconstructed, the test harness can be structured as follows:

Performance and Limits

Empirical numbers from a reconstructed server on a developer workstation:

• Import time for a 1,200-node S7-1500 nodeset (TIA V17 export): 2.4 s cold, 1.1 s warm.
• Memory footprint of the resulting server: ~85 MB for the nodeset above, dominated by NodeId interning and DataValue cache.
• Sustained read throughput on localhost: ~6,500 reads/s single-client, ~14,000 reads/s concurrent multi-client.
• Subscription fan-out: stable at 4,000 monitored items with 100 ms sampling interval on a quad-core CPU.

These figures are sufficient for SCADA-integration test rigs and HMI smoke tests, but are not representative of an S7-1500 with a 1 ms PROFINET cycle.

Alternate Paths

When the import is not viable (e.g., the namespace corruption is severe or the nodeset is too large), two production-tested alternatives exist:

1. Run a real S7-1500 in a hardware-in-the-loop (HIL) rig. A spare CPU loaded with the test firmware is connected to the test network. The python-opcua client connects to the real server. This is the highest-fidelity option and is the only way to validate subscription timing accurately.
2. Use the S7-1500 PLCSIM Advanced (or the modern SIMATIC S7-PLCSIM V2.x) virtual CPU. PLCSIM exposes the same OPC UA server as the physical CPU. python-opcua clients connect to opc.tcp://<plcsim-host>:4840 exactly as they would in production. The only operational difference is that the PLCSIM instance runs as a Windows process, which limits real-time guarantees.

Compared with nodeset reconstruction, both of these provide running server semantics, which is the decisive advantage when the tests must validate cyclic value updates, alarm bursts, or methods that mutate the S7-1500 program state.

FAQ