Troubleshooting
Why rebuilt HMI runtime files show #### for PLC tags
Short answer
Hashes on every tag after transferring a rebuilt WinCC Runtime Advanced project are a display symptom, not a communication code. Restore the working runtime files as a baseline, add an alarm view showing buffered System alarms, and branch on the message text: connection establishment, TLS certificates and clocks, hidden project pairing, or single-field formatting.
On this page
- What does #### in every tag field actually mean?
- Why do the old runtime files work while the rebuilt ones fail?
- How do I read the fault class from buffered HMI system alarms?
- Does S7-1500 firmware V2.9 force TLS on the HMI connection?
- Do the CPU clock and certificates decide this branch?
- Why do tags fail only after the connection is established?
- Should the S7ONLINE access point on the target PC be changed?
- What is the fastest way back to a working HMI?
- Questions asked
Hashes on every PLC tag right after you transfer a rebuilt WinCC Runtime Advanced project are a display symptom, not a communication fault code: the runtime cannot deliver values, so the fields render ####. Because the previous runtime files still work on the same target PC, the cables, the IP subnet and the S7ONLINE mapping are proven good, and the rebuilt application itself is the only untested variable. Read the fault class from an alarm view set to Alarm Buffer showing System alarms, then branch on the message text: a connection that never establishes, certificate and clock failures under firmware V2.9's TLS, hidden project pairing exposed by tag read/write errors, or single-field formatting. Do not start by editing tag formats or stepping device versions down; the alarm text picks the branch.
What does #### in every tag field actually mean? #
The hashes are a display symptom: a field renders #### when its runtime cannot deliver a value to display, so hashes on every PLC tag at once mean the rebuilt application lost tag access, not that tag formats or field widths changed.
A runtime renders hashes when the value behind a field cannot be delivered or cannot be formatted into the field. One hashing field is a formatting question; every tag hashing together is a tag-access question, and that distinction decides where you look first. It also tells you what not to touch: output formats, field widths and the tag table stay innocent until the alarm buffer shows the connection itself is healthy.
Why do the old runtime files work while the rebuilt ones fail? #
Because the same target PC, cable, subnet and S7ONLINE mapping serve both applications, the working old files prove the communication path is good and leave the rebuilt application's connection data and project pairing as the only untested variables.
That comparison is the strongest diagnostic in the case, so protect it: archive the working files before anything overwrites them, and treat every test as reversible because they can be restored in minutes. The same comparison already settles four suspicions:
- Cabling, switch ports and IP subnet — the old files cross the same path.
- The Windows Set PG/PC Interface mapping of S7ONLINE — both applications use it unchanged.
- The CPU program and its configuration — the blocks compare 100% identical online, so no data block signature mismatch exists.
- Access protection — the CPU sits at Full access (no protection), so no login is failing.
One caveat belongs next to that baseline: working runtime files are not proof about the engineering project. They were compiled by someone else from a source you have not seen, so the current TIA Portal project may never have produced them — and that divergent engineering source is a candidate fault in its own right.
How do I read the fault class from buffered HMI system alarms? #
Add an alarm view set to Alarm Buffer (or logs) showing System alarms, because that buffer keeps the first events after runtime start and lets you separate a connection that never established from certificate rejections and tag read/write errors.
A screen that shows only current process alarms cannot do this job, because it misses the first seconds after runtime start where the connection decision happens — and those seconds carry the branch. Capture the evidence in this order:
- Run the old files and record what healthy looks like: the connection shows established within a few seconds of runtime start, and the tags carry values.
- Start the rebuilt files on the same PC and network and watch the same alarm view from startup.
- Record the alarm number, the full message text, the connection name and the timestamp of every system alarm.
- Open the CPU diagnostic buffer and look for matching secure-communication events in the window around the runtime start time.
| What the alarm buffer shows | What it means | Next branch |
|---|---|---|
| Connection stays disconnected and retries | Transport or secure-session establishment fails | Compare the connection table against the baseline; open the CPU diagnostic buffer |
| Connection establishes, then tag read/write errors | Hidden project pairing mismatch | Rebuild the HMI application from the source that matches the loaded CPU project |
| Certificate or security alarm text | Trust or clock failure | Match the clocks; verify the trusted certificate belongs to the running CPU |
| Only single fields hash after startup | Field width or output format | Correct those fields; leave the connection untouched |
Worked example: the rebuilt runtime starts at 08:14:03. At 08:14:04 the buffer logs the connection to the PLC as established — one second after start, inside the normal few-second window — and at 08:14:05 it logs tag read errors. Established-then-tag-errors, one second apart, selects the pairing branch; a first entry showing failed connection attempts would instead select the establishment branch. The hashes never select the branch; the ordering and the text do.
If even the old baseline starts dropping and re-establishing its connection later in the shift, stop treating this as a rebuild problem and work through Diagnosing intermittent HMI to PLC Ethernet comms hangs (article:diagnosing-intermittent-hmi-to-plc-ethernet-comms-hangs).
Does S7-1500 firmware V2.9 force TLS on the HMI connection? #
Yes: firmware V2.9 added TLS with X.509 certificates for PG/PC and HMI communication across the S7-1500 and ET 200 CPU families, and TIA Portal V17 with a V2.9 CPU is a documented supported combination, so the versions themselves are not the fault.
TLS reached WinCC at V16, one version before the one in this case, so stepping the HMI device from V17.0 down to V16.0 and the PLC entry from V2.9 to V2.8 does not strip the secure-session requirement — it only adds a version mismatch on top of the original fault. Siemens' security documentation lists TIA Portal V17 against S7-1500 firmware V2.9 onward as a supported TLS-based PG/HMI combination, including a PC configured with WinCC Runtime Advanced, so the pairing in this case is documented to work. Keep the repair HMI-side: with the machine producing, a hardware download that stops the CPU to chase a display symptom trades a screen fault for line downtime.
Do the CPU clock and certificates decide this branch? #
They can: certificate validation fails when a clock is wrong enough to place the CPU's certificate outside its validity interval, so compare the Windows clock on the target PC with the CPU's date and time before touching any connection setting.
Ask first whether the CPU's clock was ever set. Windows on the target PC is usually right; a CPU that has never been time-synchronized drifts, and validation then fails on an otherwise correct certificate. Bringing the CPU's time to the current date while it stays in RUN is a non-disruptive write, and keeping the clocks matched afterward is the routine described in Setting HMI clock time from PC and PLC daily (article:setting-hmi-clock-time-from-pc-and-plc-daily).
The second check is trust. The HMI connection must trust the communication certificate of the running CPU; a rebuilt application whose connection references a stale or different certificate fails even when everything else is healthy. Read which certificate the engineered connection references before changing anything, and compare it against what the running CPU actually presents.
Why do tags fail only after the connection is established? #
That pattern points at project pairing: when the alarm buffer shows the connection come up and then tag read/write errors, the PLC station in your rebuilt HMI project does not match the project loaded in the CPU, because TIA Portal pairs them through hidden identifiers rather than tag names.
The identifiers are hidden, so no comparison or edit exposes them; the practical test is history instead. The working files were compiled by someone else from a source that matched the CPU's loaded program. The rebuilt files come from a source that does not — typically one that predates or postdates the CPU's last program change, even though the blocks now compare identical online, because block identity and HMI pairing are checked separately. The repair is to abandon the divergent source rather than hunt the identifier: take the project state that produced the working files, copy the graphical modifications into it, recompile and transfer. That rebuild pairs the way the CPU already recognizes.
Should the S7ONLINE access point on the target PC be changed? #
No: the old files connect through the same S7ONLINE mapping, so leave the Windows Set PG/PC Interface setting alone unless the alarm text specifically names a connection or access-point failure right after runtime starts.
WinCC documentation for simulation against a real PLC pairs one specific case with this setting: alarm 140001 appearing immediately after the simulation starts points at Windows Control Panel → Set PG/PC Interface → S7ONLINE and the network adapter selected there. A real runtime uses the same mapping, and the walkthrough in Testing HMI Simulation Against a Live PLC (article:testing-hmi-simulation-against-a-live-plc) exercises it end to end.
A successful TIA Portal online session from the engineering station does not validate the HMI application's own interface — the two take separate paths — but in this case the working old files already validate it. Re-check the mapping only when the alarm text names it; repeatedly editing a working adapter selection adds variables instead of isolating the fault.
What is the fastest way back to a working HMI? #
Restore the old runtime files as the baseline, recover the engineering project that generated them, add the buffered system-alarm view, copy the graphical changes into that project and recompile — expect the connection to establish within a few seconds of runtime start and the tags to carry values.
Each alarm class closes with a different action:
- Connection never establishes: compare the rebuilt connection's partner, interface and access point against the baseline, and touch the PC mapping only if the alarm names it.
- Certificate or security text: match the CPU clock to the PC clock and verify that the certificate the connection trusts belongs to the running CPU.
- Connection established with tag read/write errors: rebuild from the engineering source that matches the CPU's loaded program and carry the graphical changes across.
- Only isolated fields hashing: widen those fields or correct their output format; the connection is already proven.
Run the comparison once more after the rebuild: old files establish and display, rebuilt files establish and display. That pair of results, not the disappearance of the hashes alone, is what closes the fault and puts the graphical change into production.
Questions asked
Can I view or clear the hidden identifiers TIA Portal uses to pair the HMI project with the CPU project?
No. The pairing runs on internal identifiers that no engineering view shows, so they cannot be compared, edited or reset. A mismatch is therefore not repaired in place: rebuild the HMI application from the engineering source that matches the program loaded in the CPU, and the new compile pairs correctly on its own.
Does restoring the old runtime files lose process data, recipes or logs?
No. Runtime files only present values arriving live from the CPU; the values themselves are not stored inside the application, and logs and recipes the runtime writes to disk stay in place when the files are swapped. Restoring the old files is reversible, which is what makes it a safe diagnostic baseline.
Why do only a few fields show hashes while the rest of the screen updates normally?
Then the connection and the project pairing are healthy and the fault sits in those fields: the formatted value is wider than the field, the output format does not match the tag's data type, or the tag still points at an address the current program no longer fills. Fix the field width or format pattern for those tags only.
Does Full access (no protection) on the CPU remove the certificate requirement?
No. The protection level and the connection security are separate checks: the access level decides who may read and write once connected, while the TLS session decides whether the HMI may connect at all. A CPU with no protection set still rejects a runtime whose certificate trust or clock fails, so hashes remain possible.
How do I place new compiled runtime files on the target PC without the engineering station?
Start the WinCC Runtime Loader on the target PC and transfer over the network, or stop the runtime process and copy the compiled output into place before restarting it. Stop the runtime first: files it holds open cannot be overwritten cleanly, and a partial overwrite produces a second fault on top of the first.