Troubleshooting
Why HMI Screens Fill With Question Marks After a Return Goto
Short answer
Question marks filling a screen after a return Goto mean the display's objects cannot resolve their tag values. The usual cause after adding a return button is a parameterized display opened without its parameters. Compare the failing route with a known-good route to the same display before touching communications.
On this page
- What do question marks on an HMI screen actually mean?
- Is the runtime really crashing when the question marks appear?
- Why does the screen work from its old button but not my return Goto?
- How do I compare the failing route with the known-good route?
- How do I trace one question-marked object back to its tag?
- When should I suspect the communications path instead?
- How do I fix the return button without changing the screen?
- Questions asked
Question marks flooding a screen right after a return Goto almost never mean the application crashed. They mean the objects on that display cannot resolve the tag values they were built to read, and after you have just added a return button the most common cause is a parameterized display opened without its parameters. Prove which it is by comparing the failing route with a known-good route to the same display, before anyone touches communications settings.
What do question marks on an HMI screen actually mean? #
They are the runtime's unresolved-value indicator: an object asked for a tag value it could not resolve, so it draws placeholders instead of data — a reference problem first, not proof that the runtime stopped or that the controller went offline.
An object shows them when the value source behind it — a controller tag, an HMI tag, or an expression input — cannot be turned into something readable at display time. Trend and graphic objects can also draw with placeholder lines when the data behind them is missing. The runtime keeps executing, navigation keeps working, and the controller can be fully online while one screen shows nothing but placeholders.
Not every question mark is a data failure, though. If literal text that references no tag also turns to question marks on every screen, the fault is text rendering — cases are documented after Windows updates on FactoryTalk View 6.1 systems — and the fix belongs with fonts and regional settings, not tags. A released patch numbered 2.10.02 also fixed trend legends showing question marks because the property was not supported by the tag, so read the release notes for your build once the reference checks below come back clean. The diagnosis pattern itself is general: Fixing STARTER question marks in the G150 expert list is the same unresolved-reference hunt in a drive commissioning tool.
Is the runtime really crashing when the question marks appear? #
Usually no: if you can still navigate and a known-good value elsewhere keeps updating, the runtime is alive and the fault sits in that display's references — treat it as a data-resolution fault, not a crash.
Take two readings before touching anything: whether navigation still works, and whether a value you trust still updates somewhere else.
- Press an existing navigation button that worked before. If the display changes, the runtime is alive.
- Open a display that reads the same controller and watch a value you know changes — a counter or a time-of-day field. A static number proves nothing; a stale value can sit on screen with no communications behind it.
- Record the scope with a count: how many of the display's data objects show question marks, and whether any other display is affected.
- Capture the failing state — route used, objects affected, any diagnostics — before restarting anything. A restart wipes the evidence.
| What you observe | Where the fault sits | Next check |
|---|---|---|
| Navigation works, other controller values update, only the reopened display fails | Missing display parameters or route-specific references | Compare the two opening actions |
| Values from one controller fail on several displays | Shortcut, target path, or controller availability | Check the runtime communications target |
| Only some objects fail on the display | Individual references, placeholders, or expressions | Trace one object through substitution |
| Navigation stops responding or the runtime closes | A real runtime fault, not unresolved data | Capture diagnostics and the exact reproduction steps |
If the runtime genuinely closes or freezes, that is a separate fault with its own evidence trail — fixing HMIRTM.EXE runtime crashes on a Comfort panel is one documented case on another platform — and question marks alone do not diagnose it.
Why does the screen work from its old button but not my return Goto? #
Because opening the same display through a different action is not the same operation: the original entry supplies the parameters its objects require, and your return Goto names the display without them, leaving placeholders unresolved.
A parameterized display is built with placeholders where fixed tag names would otherwise be. The values that fill those placeholders are supplied by the action that opens the display — as direct assignments or through a parameter file the opening action names. With the values supplied, the runtime substitutes them and every reference completes. Without them, the reference stays incomplete and the object shows question marks while the controller runs on, untouched.
That is why only your new route fails. Every pre-existing entry point — the original buttons, and possibly the startup display configuration — already supplies what the display needs. Your return button is the first action that names the display without the arguments its objects depend on.
If the return button does nothing at all when pressed — no screen change, no question marks — that is a different fault: fixing Goto Display buttons locked by HMI global connections covers that case.
How do I compare the failing route with the known-good route? #
Open the same display both ways under the same runtime and controller conditions, then compare destination, parameter source, and supplied values action by action; the difference you find is the fault.
- Find any working action that opens the same display: the original button, a menu entry, or the startup display configuration.
- Read its destination and the parameters or parameter file it supplies at open time. This setting lives in the display-open configuration of the button, alongside the destination display name.
- Read your return Goto's identical settings.
- Open one of the failed objects and check whether its value source contains a placeholder rather than a fixed reference.
- Open the display both ways, same runtime, same controller state, and record which objects fill in and which do not.
Decide on the result. If the original route fills the screen in and the return route does not, the controller, its connection, and the display's objects are all proven good — the fault is the return action's missing arguments, and no communications setting will change that. If both routes fail, move to the communications check below. If no working route exists, sort out the display's parameter dependencies first, then test a direct controller reference separately.
How do I trace one question-marked object back to its tag? #
Read the object's configured value source, list every placeholder in it, write out the reference that results after substitution, and compare it with the reference the working route produces — the mismatch is your answer.
- Record the object's configured value source: a controller tag, an HMI tag, or an expression.
- List every placeholder that appears in it.
- Apply the values the opening action actually supplied and write the resulting reference.
- Compare that with the reference produced by the working route: shortcut, controller tag path, and any element or member selection.
- For an expression, check each input separately — one unresolved input marks the whole expression even while the others update.
Worked example, with illustrative names. The StationBuildStatus display carries 18 data objects. Reading their configurations, 15 of the 18 reference the station-selection placeholder — call it P1 here, a name chosen for this example — and 3 use fixed tags.
Through the original button, the opening action assigns P1 = Station3. A level object whose source reads P1_Level resolves to Station3_Level, the runtime reads it, and the failed-object count is 18 - 18 = 0.
Through the new return Goto, no assignment happens. P1 never receives a value, P1_Level cannot become a real tag name, and 18 - 3 = 15 objects show question marks — exactly the 15 that share P1. The 3 fixed-tag objects keep updating on the same screen at the same moment.
The numbers give the decision. When a whole group of objects fails together on one route while fixed-tag objects beside them keep updating, the group shares an opening parameter: repair the route, not the objects. Editing the 15 objects individually hides the configuration error and multiplies the maintenance.
When should I suspect the communications path instead? #
Suspect communications only when every object that uses one controller fails on every display and every route — one failed display reached by one new button is a routing fault, and changing the communications path will not fix it.
The trigger is scope, not the symbol. Work the shared connection when the failure crosses displays:
- Identify the shortcut or tag source behind one failed object.
- Read the runtime target that shortcut maps to and confirm it names the intended controller — read the configuration the runtime actually runs, not the development copy.
- Confirm the controller is reachable through that connection.
- Compare a known-good object using the same shortcut with a failed one.
On PanelView Plus terminals the same symbol has a known trail of its own: a PanelView Plus logic module showing question marks on live values walks the communication-path check. And if nothing has shown live data since the last runtime download, start from why an MER download shows no live data on the HMI rather than from the button.
Do not repoint a shortcut at a different controller just to make values appear. A healthy connection to the wrong controller displays believable, incorrect machine status — worse than question marks, because nobody questions it.
How do I fix the return button without changing the screen? #
Copy the working entry's configuration: same destination display, same parameter file or parameter assignments, supplied at the moment the return Goto opens the display — keep the screen parameterized rather than hard-coding tags.
- Save a recoverable copy of the application before editing.
- List the parameters the display requires and what each one selects: station, equipment, tag prefix.
- Configure the return Goto to supply them, copying the parameter file name or the assignments from the working entry so both routes pass the same values.
- Test the return route, then retest the original route and the forward route into your new display. A fix that breaks the other direction is not a fix.
- If you cannot tell what a parameter selects, copy it from a working opener rather than inventing a value — an invented value resolves cleanly and quietly displays the wrong data.
The final decision follows the evidence: original route good and return route bad, repair the button's parameter assignment; both routes bad across the controller's objects, repair the communications target; scattered objects bad on every route, repair the references themselves. In the classic case — a new return Goto into a parameterized display — the first of those three is what you will find.
Questions asked
Will restarting the runtime clear the question marks?
Not this fault. A restart reopens the startup display, which normally receives its parameters, so the screen looks healthy again until someone presses the return button on the same route. Capture the failing state first — the route used, which objects failed, any diagnostics — because the restart destroys that evidence and the fault only reproduces on the route that omits the parameters.
Can I fix it faster by replacing the placeholders with fixed tags?
You can, and it will look fixed, but the display is then pinned to one station: it shows that controller's data no matter which button opened it, and every station that used to share the screen needs its own copy and its own edits. Supplying the values from the button keeps one screen serving several stations.
How can I tell within a minute whether it is parameters or communications?
Open any other display that reads the same controller. If its values update, the connection is healthy and the fault is the reopening route's missing parameters. If every controller-backed value is dead on every display, it is communications — and if that has been true since the last runtime download, treat it as a download problem before a navigation one.
Do question marks on one object type mean its driver failed?
No. Question marks are per reference, not per driver: an expression with three inputs shows placeholders when one input is unresolved, even while the other two keep updating. The connection itself only becomes the suspect when every object sharing that controller connection fails together across displays.