IMDTouchKnowledge BaseShop main store

Troubleshooting

When OPC UA tag browsing fails and manual NodeIds work

HMI and touchscreens Published 9 min read

Short answer

A connected OPC UA endpoint and a populated browse tree are different results. When a server exposes process data only through explicit addressing, browse returns nothing while the tags remain readable: enter the NodeId by hand with the string identifier designator and the server's own namespace URI, then verify value, quality and update rate on the client.

On this page
  1. Why does my OPC UA client connect but show no tags when I browse?
  2. How do I address a tag by hand when the browse tree is empty?
  3. Which identifier type does the NodeId need, string or numeric?
  4. Which namespace goes after ns=, the index or the URI?
  5. Why did the documented example address fail for my process tag?
  6. What does a complete working configuration look like?
  7. How do I verify a hand-entered NodeId on the panel?
  8. When can a hand-entered NodeId be reused after a server change or restart?
  9. Should you fix the browse or enter the address by hand?
  10. Questions asked

A green connection and a populated tag tree are two different results, and this article is about the gap between them. In the recorded case, a WinCC v11 runtime on a Siemens Comfort Panel connected cleanly to an Ignition OPC UA server at opc.tcp://10.100.42.200:4096, yet the browse returned no process tags and the hand-typed address [Test]MB500 refused to read. The server published its Siemens driver process data for explicit addressing only, so there was nothing to browse. The entry that finally read the tag was ns=uri://10.100.42.200/Ignition%20OPC-UA%20Server;s=[Test]MB500, typed by hand on a server updated from the 7.5.0 RC release to 7.5.6. The sections below show where each part of that address comes from, why the earlier attempts failed, and how to prove the tag works on the panel.

Why does my OPC UA client connect but show no tags when I browse? #

Because a connection only proves the endpoint is reachable, while a browse result depends on the server publishing nodes with references a client can walk, and a server may expose its process data through explicit addressing without any browsable process-tag tree.

The OPC UA address space is a graph of nodes linked by references, not a flat list of names. Browsing walks those references from a starting node; a server that never hangs its process data off a browsable branch gives the client no path to walk, no matter how healthy the session is. Reading is a separate service: the client supplies a NodeId — the namespace plus identifier that selects one node — and asks for its value or a subscription to it.

Both facts together explain the recorded symptom. WinCC v11 held a session to the endpoint while the server published its Siemens driver process addresses only as explicitly addressable nodes, with the driver's diagnostic branch as the one browsable area. Nothing was wrong with the transport; the process data simply had no browse path. Which side publishes and which side consumes is a design decision of its own — which direction works between an OPC UA server and a client settles that choice — and this article starts after it: the panel runtime is the client, the gateway is the server.

How do I address a tag by hand when the browse tree is empty? #

Get the exact identifier from the server side, then enter the NodeId yourself: a namespace after ns= and an identifier after a type designator, written together as ns=<namespace>;s=<identifier> when the identifier is text.

In the recorded case the identifier was [Test]MB500: Test is the name of the device connection as configured on the server, and MB500 is the Siemens memory address behind it. The two halves must match the server-side configuration exactly, because the identifier is plain text to the client — renaming the device connection on the server changes the identifier, and an address typed against the old name stops resolving. Some clients split the entry into a namespace field and an identifier field; others take one combined string. The client type does not change the rule: a panel runtime is just another OPC UA client, as the walkthrough for connecting a Windows mobile HMI panel to a ctrlX controller over OPC UA also shows.

Which identifier type does the NodeId need, string or numeric? #

The identifier [Test]MB500 is text, so it needs the string designator s=; the numeric designator i= in front of the same text, as tried in ns=1;i=[Test]MB500, declares a number that can never match, and that mismatch is why the first attempts failed.

OPC UA defines four identifier types: numeric (i=), string (s=), GUID (g=) and byte string (b=). The server matches on the identifier value and its type together, so i= before text is not a formatting slip the server forgives — it describes a different node that does not exist. Decide the type from the identifier itself: text with letters, brackets or punctuation is a string identifier, and a driver address such as [Test]MB500 is exactly that.

Which namespace goes after ns=, the index or the URI? #

Either form can be correct, because both name the same row in the server's namespace table: an index such as ns=1 is the row number, while the URI after ns= is the stable name recorded in that row, and the client decides which notation its address field accepts.

OPC UA Part 3 defines the namespace as a URI that identifies the naming authority responsible for assigning the identifier, and the server publishes its namespace table so every index has a URI behind it; row 0 is reserved for the standard namespace, and a driver's own namespace sits in a numbered row after it. The practical consequence decides the choice: an index works only while that row still holds the same namespace, because row numbers shift when the table changes, while the URI keeps naming the same owner regardless. That mapping is explained in more depth in how OPC UA NodeIds use namespace URI mapping rather than a fixed index.

In the recorded case, index 1 was the correct namespace for the driver tags and the client's address field recorded the working entry with the URI after ns=. One nearby trap: an application URI identifying a server instance is a different object from a namespace URI, and the discovery-server identity that turned up during this troubleshooting belongs in the application slot, not after ns=.

Why did the documented example address fail for my process tag? #

The example ns=http://opcfoundation.org/UA/;i=2275 points at a numeric identifier inside the standard OPC UA namespace, so it is a template for standard nodes only; retyping the identifier as [Test]MB500 left the namespace and the identifier type both wrong for a process tag.

The copied example came from documentation for a different node entirely. http://opcfoundation.org/UA/ is the standard namespace, row 0, which holds the nodes the OPC UA specification itself defines, such as server status and session diagnostics. Substituting the text into the numeric slot changed neither problem. Each attempt failed for its own checkable reason:

Address entered What it declares Outcome
[Test]MB500 identifier text only, no namespace client cannot resolve a naming domain; failed
ns=1;i=[Test]MB500 namespace index 1, numeric identifier identifier type contradicts the text; failed
ns=1;s=[Test]MB500 namespace index 1, string identifier structurally correct for index 1; not tested in the case and not the entry recorded as accepted
ns=uri://10.100.42.200/Ignition%20OPC-UA%20Server;s=[Test]MB500 server's namespace URI, string identifier read [Test]MB500 on the updated server

The lesson generalizes: an example address from any documentation carries its own namespace and identifier type, and both travel with the copy.

What does a complete working configuration look like? #

In the recorded case the working entry was ns=uri://10.100.42.200/Ignition%20OPC-UA%20Server;s=[Test]MB500 on a server updated from 7.5.0 RC to 7.5.6, read through the endpoint opc.tcp://10.100.42.200:4096, and browse still returned no user-defined tags afterwards.

Build the address in four steps, each piece from a documented source:

  1. Endpoint. opc.tcp://10.100.42.200:4096 — server host 10.100.42.200, UA port 4096 as that server publishes it. This is the only piece that transports anything.
  2. Identifier. On the server side, the device connection is named Test and the point is the Siemens address MB500; the identifier string is therefore [Test]MB500.
  3. Namespace. The driver's namespace sits at index 1 in the server's table, published under the URI uri://10.100.42.200/Ignition%20OPC-UA%20Server.
  4. Assembly. Namespace after ns=, string designator before the identifier: ns=uri://10.100.42.200/Ignition%20OPC-UA%20Server;s=[Test]MB500.

Entered on the WinCC v11 side, that address read the tag with the value tracking the S7-400 data the server already saw. Two qualifications keep the example honest. The server moved from the 7.5.0 RC release to 7.5.6 in the same session as the address fix, so the recorded success couples the two changes; treat a release-candidate build as a suspect in its own right whenever an otherwise-correct address refuses to read. And the fix changed nothing about browsing: user-defined tags stayed unbrowsable, so the manual address carried all the process data the panel needed.

How do I verify a hand-entered NodeId on the panel? #

Read the tag back in three separate checks — value, quality and update rate — because a connected session, a browse result and a live tag are independent results, and only a tag that reads with Good quality and keeps refreshing proves the address.

Work down the checks in order; each isolates a different layer:

  1. Session. The client reports its OPC UA channel connected to the endpoint — this proves transport and security only.
  2. Single read. Trigger one read and compare the returned value against the value the PLC actually holds at that address.
  3. Quality. Confirm the tag's quality is Good; a value carrying a bad or uncertain quality code has not proven anything.
  4. Update. Force a change on the PLC side and watch the panel follow it within the subscription or polling period configured for the tag.
  5. Name match. Re-open the server-side device configuration and confirm the identifier still matches character for character, device name inside the brackets included.

One safety note belongs here: a hand-typed NodeId skips the discovery checks a browse gives you, so keep a manually addressed tag read-only until its value has been proven against the PLC, because a wrong namespace or identifier selects whatever node the text describes, not the node you intended.

When can a hand-entered NodeId be reused after a server change or restart? #

Normally for good: OPC UA servers typically keep NodeIds stable across restarts, so a client may cache hand-entered addresses, but re-verify the full entry after a server upgrade, a namespace-table change or a rename of the device connection, because each of those can change what the identifier means.

That stability is the documented normal case, which is why caching a hand-entered address is safe practice between changes. The fragile half is the namespace index: row numbers shift while URIs persist, so prefer URI-based entries where the client allows them, and when an index-based entry starts failing after a server change, resolve the current table instead of guessing the new row number — the procedure for resolving a namespace URI mismatch between client and server walks that comparison. In the recorded case the re-check was built into the remedy: the tag was read and proven on the updated server before the panel went into service.

Should you fix the browse or enter the address by hand? #

Enter the address by hand and stop waiting for the browse tree: browsing depends on how the server publishes its nodes, which you do not control, while a correct manual NodeId reads today and keeps reading across restarts as long as the identifier and namespace stay valid.

Hand entry is the shorter path whenever the tag count is small: four pieces — endpoint, identifier, namespace, designator — plus the five-step verification above. Ask the server side for a browsable process-tag tree only when point-and-pick configuration for many tags would pay for itself; in the recorded case the answer was that driver process data is not published that way, with diagnostics as the only browsable branch. For a tag that still refuses after the structure is right, split the remaining suspects in this order: the identifier text against the server-side device configuration, the namespace against the server's published table, then the server build, which the recorded case proved can matter on its own.

Questions asked

Why can two nodes share a browse name but not a NodeId?

The browse name is a naming attribute for display and search; the NodeId is the unique key that selects a node. An address space can legitimately contain several nodes with the same browse name and identical attributes apart from the NodeId, so a match by name alone is ambiguous. Hand entry avoids that ambiguity because it addresses the NodeId itself.

Is a namespace URI that contains an IP address a network address?

No. After ns=, the URI only names the authority that owns the identifier; the data still travels to the endpoint URL. In the recorded case the namespace URI contained 10.100.42.200 while the connection ran over opc.tcp://10.100.42.200:4096, two different roles for the same numbers. The namespace URI stays whatever the server publishes in its namespace table, regardless of where the server is installed.

Can one HMI panel read OPC UA tags from two servers at once?

Yes, when the client runtime's documented drivers, ports and connection limits support multiple OPC UA connections; a dedicated panel and a PC runtime can both serve several controllers that way. Each server keeps its own namespace table, so tags from different servers never share a namespace: enter each tag against its own connection and never carry a namespace index from one server over to another.

How does a wrong manual NodeId fail compared with a lost connection?

A wrong NodeId fails as a tag-level status while the session stays up: the server reports that it does not recognize the node, and every other tag keeps updating. A lost connection drops the whole channel and every tag goes bad together. Diagnose from the blast radius: one dead tag points at the identifier or namespace, a dead channel points at the endpoint, security or network.

Keep reading

  • Explainer

    HMI OPC UA Server vs Client: Which Direction Works

    OPC UA support on an HMI spec sheet almost always means the panel runs a server that serves its tags to external clients. Reading PLC symbols by name needs an OPC UA client driver, a separate capability you verify in the driver list for your exact software release, target and license.

    HMI and touchscreens

  • How-to

    Connecting a Windows mobile HMI panel to ctrlX over OPC UA

    The panel connects when five things line up: a working network path, the OpcuaItf.cfg client configuration, a Basic256Sha256/SignAndEncrypt self-signed certificate with a matching application URI, a ctrlX user holding permissions for the OPC UA Server and PLC apps, and a GVL named KeTop shared in the symbol configuration. Prove the link by trusting the client certificate on the CORE and watching the Alive variable increment every 1 second.

    HMI and touchscreens

  • How-to

    Connecting Operator Terminal Expert to a Third-Party PLC

    Operator Terminal Expert connects to a third-party PLC through a protocol both ends document — typically Modbus TCP or RTU, or OPC UA with the HMI as client and the PLC as server. Select the driver for your exact terminal target, match the driver's address notation to the PLC's register references, and prove one read and one controlled write on the deployed terminal before mapping the rest.

    HMI and touchscreens