How-to
How to verify the HMI project version running on a panel
Short answer
A panel does not expose a build signature you can read back, so make the project carry its own: a release label on a maintenance screen, an approved archive, and a deployment-record entry per panel. Read the label on every panel and compare it with the record; a checksum of runtime files is a different check over different bytes, and neither value substitutes for a safety signature.
On this page
The fix, stated up front: put a release value such as REL 2.1.0 into the project as static text on a maintenance screen, keep one approved project archive, and enter every panel in a deployment record that lists its approved value and transfer date. Verification is then a read-and-compare on every panel — the displayed label must equal the record entry, confirmed by one release-specific functional check.
An HMI panel exposes no equivalent of a safety program's signature, so do not go looking for one on the box. Below: where the label lives, what the record holds, the seven-step routine, a four-panel worked example, and what each failed reading means.
Why the panel has no signature to read back #
A safety controller signs its safety program because the certification of the safety function depends on that signature. An HMI runtime carries no such construct: nothing in the documented panel interface returns an identifier for the build you downloaded. Two near-misses come up in every discussion of this problem:
- File timestamps. A timestamp records when a transfer happened, not what was transferred, so it cannot identify a release on its own.
- A hash of the runtime files. The bytes reachable on the panel are the compiler's transformed output, not the project itself — the boundary problem has its own section below.
What the panel does report is its own software level. On a Comfort Panel, the Option entry in the panel's Control Panel displays the Image Version of the loaded TIA version together with the device type and serial number. Read it before a transfer to confirm the panel runs the software level the project targets — never to tell your releases apart, because an old and a new project downloaded at the same software level show the same Image Version. A project that will not load because the terminal's software level is wrong is a different fault entirely; that compatibility mismatch has its own fix in Fixing an HMI MER runtime version mismatch.
Put a release label inside the project #
The label is a value that lives in the project and nowhere else. The practical form is static screen text on a maintenance or information screen — a text field reading REL 2.1.0, for instance — or a project constant displayed there, read-only during operation. Three sources disqualify a label:
- A PLC-supplied value identifies what the controller reports, not which HMI application was downloaded.
- An operator-entered value can be changed on any panel without touching the project.
- A value kept in a file or tag outside the project survives the download independently, so it can disagree with what the panel actually runs.
Project-resident text travels with every download, which is the point: an older project restores an older label, and the mismatch becomes visible on the screen. A runtime-writable tag behaves differently — tag values are reinitialized by a transfer, as why HMI variable values reset after a project transfer explains — which is why the label belongs in static project content rather than a tag.
The screen cannot enforce discipline; your release process does. Write the rule down: any functional change — a script edit, a connection change, a new faceplate, even one invisible on the screens — requires a new release value, checked at review and archived with the approved project. If scripts are managed as library types, the type version travels with the script and an outdated instance flags a changed script; a type version identifies one script, not the application, so it supplements the label and never replaces it.
One boundary: this label is an administrative identity, not a safety signature. A safety program validated through the safety controller is revalidated only through that process, whatever the label says.
Keep a deployment record for every panel #
The record turns a screen reading into a verification. Give it one entry per physical panel: panel asset number, approved release value, transfer date, source archive name, who performed the transfer. Identical panels still get separate entries, because the comparison that matters is panel against record, not panel against panel. A fleet can agree with itself and still be wrong — six panels showing the same obsolete release match each other perfectly and fail the record six times.
Verify every panel against the record #
- Add the label to a maintenance or information screen as static text or a displayed project constant.
- Assign the approved value from your site's revision convention, and record which changes force a new value.
- Archive the approved project with its release notes. If you checksum the archive, note exactly which file the checksum identifies.
- Enter each target panel in the deployment record before the transfer, not after — identical panels still get their own entries.
- Transfer from the controlled archive only, never from a working copy, then open the maintenance screen on that panel and read the label back.
- Run one release-specific functional check — the screen, faceplate or navigation item the approved revision introduced — under conditions that cannot move the machine.
- Close the loop on any mismatch: pull the panel, re-transfer from the archive, re-read the label, and trace the download that overwrote the approved release.
If a panel carries a release whose engineering source no longer exists, read what is on it before you overwrite anything — the steps in reading an old HMI program before panel replacement recover the loaded program first.
Reading the result: a worked example #
Four KTP900 Mobile panels run the same application. The record lists REL 2.1.0 as the approved release, entered against all four assets; the maintenance screens are read on 2024-06-03:
| Panel | Record entry | Screen shows | Verdict |
|---|---|---|---|
| MOB-01 | REL 2.1.0, transferred 2024-05-14 | REL 2.1.0 | pass |
| MOB-02 | REL 2.1.0, transferred 2024-05-14 | REL 2.1.0 | pass |
| MOB-03 | REL 2.1.0, transferred 2024-05-14 | REL 1.8.2 | fail |
| MOB-04 | REL 2.1.0, transferred 2024-03-02 | REL 2.1.0 | pass |
The arithmetic: 3 of 4 labels match their record entries, and 3 ÷ 4 is 75 percent — but the pass rule is all panels, so 3 of 4 is a fail. The unverified panel is exactly the one that can run old code. MOB-03 is that panel: its screen shows REL 1.8.2 where the record says REL 2.1.0 reached that asset on 2024-05-14, so a later, unrecorded download from somewhere other than the archive overwrote it. Pull MOB-03, re-transfer from the archive, re-read the label, and find the working copy that produced the overwrite. MOB-04 passes despite the older date: its record entry already lists REL 2.1.0, so an earlier transfer from the same approved release is still the approved release.
Three readings fall outside the example, each with its own decision:
- Blank label — the wrong screen is open or the text was edited out; check the archived project, re-transfer, re-read.
- Labels match but behavior differs — something shipped without a label bump; treat it as an uncontrolled change.
- Image Version differs between panels — the software levels differ, which no label can see; rebuild from one TIA version and re-transfer.
Where a checksum fits and where it does not #
A checksum answers one question: do these exact bytes match the reference bytes. It is defined only when both sides hash the same byte set, which is why the two hashes in this story never meet. The approved archive is one file — say 8,412,319 bytes — and the SHA-256 value recorded at approval proves that archive untouched when you re-hash it a year later. The panel's runtime directory is a different byte set: compilation and transfer transform the project into runtime files, so no hash of the archive can equal any hash of the runtime files, and a hash of some runtime files identifies only those files, not the application.
The panel's documented scripting gives no way around that boundary. VB scripts on the panel can create, read and write simple files such as text or CSV, and a script that opens files through FileCtl.File reaches only the panel's Windows CE file system — start the same script on a PC with a different operating system and it stops with a runtime error. Nothing in the documented scripting interface returns a signature of the loaded project, so a panel-side checksum covers only the files you name, a weaker copy of what the deployment record already does. Decision: checksum the archive when you want byte-level proof of the archive; do not build the verification on runtime files.
If you checksum anything, fix the convention in writing, because byte order and value width change the result — the BCC checksum that appends four bytes because the value is a U32 is one documented instance of the same trap.
What each check decides #
- Release label vs deployment record — which application download the panel holds. This is the verification; run it after every transfer and on a fixed schedule for every panel in service.
- Archive checksum — the approved archive is unchanged since approval.
- Image Version, read through Option — the software level and device the panel runs.
- Runtime-file comparison — only the files you named; diagnostics, never the release proof.
- Safety signature — the safety validation process, untouched by everything above.
The decision, stated once: a panel is accepted when its displayed label equals its record entry and the release-specific functional check passes. A checksum, a timestamp or a matching neighbor panel proves something other than which release the panel runs — accept nothing on their word.
Questions asked
What should the release label string contain?
Keep it short and sortable: a release code such as REL 2.1.0 is enough when the deployment record holds the archive name, date and approver. Avoid embedding a date or a free-text note inside the label, because anything in the string that goes stale makes operators distrust a reading that is actually correct.
Can I compare file timestamps instead of a label?
A timestamp tells you when a transfer happened, not what was transferred. Identical projects downloaded on different days carry different times, so equal times are not required for equal content; two different projects downloaded the same day can carry the same time. Compare the release label against the deployment record instead — that answers which release the panel holds.
The labels match but one panel behaves differently — now what?
Treat it as an uncontrolled change that shipped without a label bump. Compare the panel against the archived project item by item — screen contents, scripts, tag definitions, connection settings — to find what moved, then decide whether it stays and needs a new release value or goes and the panel is re-transferred. Afterwards, tighten the rule that every functional change bumps the label.
The panel's software level is wrong for the project — how do I change it?
Back the project up first. In TIA Portal, double-click Devices & Networks in the project tree, select the HMI device in the device view, and use Change Device/Version to set the software version the project should target. Recompile, transfer from the approved archive, and read the release label back on the maintenance screen — the label procedure itself does not change.
How often should I re-verify panels already in service?
After every transfer, without exception, and then on a schedule that outpaces any uncontrolled download path. The label can only change through a transfer, so a fixed panel with locked transfer access can be read at each planned maintenance round, while mobile panels that dock to engineering stations get a monthly reading. Add a last-verified date to the record so the fleet's exposure is visible.