IMDTouchKnowledge BaseShop main store

Troubleshooting

Why an HMI Edit Needs a New Runtime Download

HMI and touchscreens Published 7 min read

Short answer

An HMI panel executes a compiled runtime file, not the open project, so a saved display edit never reaches the screen by itself. The edit goes live only after you build the runtime, transfer it to the terminal, launch it and verify the new build is the one running.

On this page
  1. The two files that explain the symptom
  2. Why Studio 5000 is not the model
  3. The cycle that puts an edit on the screen
  4. Worked example: proving the 14:07 build is the one running
  5. When the build is right but the screen is wrong
  6. Choosing the architecture on purpose
  7. Keeping the next deployment boring
  8. Questions asked

The panel is not running your project. A FactoryTalk View Machine Edition terminal executes a compiled runtime file — the Machine Edition Runtime, or MER — built earlier from the editable project on your workstation. Saving an edited display changes the engineering copy and nothing else; the file on the terminal keeps running until you replace it with a newer build. An edit reaches the screen through a fixed sequence — build a new runtime, transfer it, launch it, then verify the launch picked up the new build. Studio 5000's online editing feels like the natural model, but it is the specialized case in automation software, not the rule, and expecting it from an ME panel burns hours. The sections below mark the boundary, walk the cycle, and end with the timestamp check that proves your edit went live.

The two files that explain the symptom #

An ME workstation holds two artifacts. The editable project is the master you open and change. The MER is the compiled package the terminal loads and executes. The MER already is the runtime — there is nothing to convert back — and neither file can do the other's job: the terminal cannot run the project, and the workstation does not execute the MER.

That boundary explains every variant of the fault:

  • Save a display and watch the panel: the save changed the project. The MER on the terminal predates it and keeps running.
  • Transfer the same runtime again: the panel receives identical screens. A re-sent build cannot carry an edit that was never built into it.
  • Look for an online session with the HMI: none exists for an ME target, so there is nothing to join.
  • Upload the panel's MER: it is still a compiled runtime, and the compiled file is not an editing surface, as why the compiled HMI project view is not for editing explains. The documented route back to an editable project is the vendor's Application Manager utility and its restore runtime application action, and it succeeds only when the build allows it. A runtime built with a password stops the restore; the legitimate path then is the engineering source or whoever holds that credential.

If the panel is your only copy and restoration is unavailable, the hunt moves to the engineering backup or the machine builder — recovering an HMI program when the source file is lost covers that search.

Why Studio 5000 is not the model #

An accepted Studio 5000 online change is compiled and downloaded too — the modified routines go to the controller, which keeps scanning while they arrive. What Studio 5000 buys you is granularity: the change lands without stopping the controller. The ME equivalent replaces the entire runtime and restarts the application. Same compile-then-transfer sequence, different batch size.

Other platforms show the same shape. In TIA Portal, any compile changes the project's compile date and time stamp, and panel loads come from that compiled result. Compile-then-load is the normal pattern for controller and panel targets; live editing is the exception, engineered for controllers.

So when an edited object fails to appear, suspect the deployment sequence first. Staying online with an HMI accomplishes nothing, and re-saving a display ten times never touches the terminal. It is not a PLC fault either — the screen is showing exactly the build it was given.

The cycle that puts an edit on the screen #

Every change takes the same five steps, and skipping any one leaves the old screen in service:

  1. Edit the maintained project. Open the development master, confirm it contains the display, object, tag or navigation you intend to change, and first establish which runtime the terminal actually launches — finding the runtime file the terminal actually loads takes minutes and prevents editing a project the panel never starts.
  2. Add a proof marker. Put small revision text in a corner of the edited display. The marker later tells you at a glance which build is running.
  3. Validate, then build a new runtime. Clear unresolved references, display errors and communication configuration faults, then create the runtime application. Building writes a new MER with its own file date and time; saving the project never updates a MER that already exists.
  4. Transfer to the chosen terminal. FactoryTalk View Studio's Transfer Utility on the Tools menu takes the MER from its Source file area and sends it to the terminal you select. Confirm the target by name instead of trusting the last-used one.
  5. Launch and verify. A transferred file sits idle until the terminal's startup selection loads it — the same kind of setting WinCC keeps under Runtime settings for the HMI device in the project tree. Start the new runtime, then confirm the marker and the timestamp with the check below.

Keep the previous MER on the terminal until the checks pass. Operate changed pushbuttons and setpoints only when the equipment they command can move safely.

Worked example: proving the 14:07 build is the one running #

The times below are illustrative clock readings from a typical change window; the steps they attach to are the documented workflow above.

Inputs:

  • One display edited in a small ME application, no larger than the single data point tag the vendor's runtime-creation walkthrough uses as its example. Marker text "Rev C" added to the display corner.
  • 14:05 — project saved after the edit (workstation clock, 24-hour time).
  • 14:07 — build finished; the new MER carries that file date and time.
  • 14:09 — transfer completed through the Transfer Utility.
  • 14:10 — new runtime launched from the startup selection.
  • Previous MER on the terminal: stamped 13:40 from the prior shift's build.

The rule in words: the running application contains your edit only if the file that launched was built after your last edit save — build time greater than edit time, and the active application's stamp equal to the transferred build's stamp.

The arithmetic:

  • 14:05 edit < 14:07 build < 14:09 transfer < 14:10 launch — the sequence is in deployment order, so no step was skipped.
  • The terminal reports the active application stamped 14:07. 14:07 > 14:05, so the running runtime postdates the edit and must contain "Rev C".
  • Counter-case: an active stamp of 13:40 gives 13:40 < 14:05, so the edit cannot be on screen — the launch selection is at fault, not the build.

Result: "Rev C" appears and the active stamp reads 14:07, matching the transferred build. The deployment is proven end to end.

Decision: accept a build as live when the active runtime's stamp is at or after your build completion time — 14:07 or later in this window — and the marker shows. If the active stamp predates your last edit (before 14:05 here), stop rebuilding; correct the startup selection and start the right file. The comparison assumes workstation and terminal clocks agree within a couple of minutes; when they do not, match file names and the marker instead.

When the build is right but the screen is wrong #

  • No marker after a completed transfer: the terminal launched a different file or the transfer reached a different terminal. Check the active application list and the target name before building again.
  • New screens with dead values: the deployment finished and the fault sits in tags or communications — why an MER download shows no live data on the HMI walks that problem.
  • The screen reverts after a power cycle: the startup selection still points at the previous MER, so every boot reloads the old build. Change the selection, not the project.
  • An interrupted transfer: the terminal keeps running the file it already launched, because a running runtime is never partially replaced. Rerun the transfer rather than rebuilding.

Choosing the architecture on purpose #

An ME target cannot accept a display edit while its runtime executes — that is the architecture, not a defect to patch. FactoryTalk View Studio opens SE applications through the same interface, but SE network clients render from a server, so a saved display reaches every running client without a per-terminal build; an SE local station still runs its own deployed copy. Newer platforms narrow the edit-to-screen delay further. Adopting one is a platform decision weighed against the whole application — who edits, how often, what gets backed up — never a repair for a missed build step. If you do move the operator interface onto a computer at the machine, that is the moment to specify industrial panel PCs instead of a dedicated terminal.

Keeping the next deployment boring #

One maintained project per terminal, with the terminal never its only copy. A fixed habit of edit, validate, build, transfer, launch, verify, then archive the build against the change record. A visible revision marker in every released build, so any technician can tell at a glance which runtime is live. None of this removes the compile step — it makes each pass through it take minutes and leave evidence behind.

Questions asked

Can the terminal hold more than one runtime file?

Yes. A terminal stores several compiled runtime files side by side, and its startup configuration decides which one loads. That is why keeping the last known-good file on the terminal is standard practice: if a new build misbehaves, select the previous file and start it again. The flip side is that a transferred file does nothing until it is selected, so after any change, confirm which file the startup selection points at before trusting the screen.

Do other HMI platforms skip the compile step?

Most dedicated terminals share some version of it: the panel executes a copy built for it on a workstation, so projects are compiled and loaded rather than edited in place. The design means the terminal always boots into a fixed, tested application that no workstation can change in place. What differs between products is granularity: server-client designs can push a saved screen to running clients, while self-contained panels still need each new build delivered.

Why does the screen drop out when the new runtime starts?

The terminal stops the old runtime before it loads the new compiled application, so the operator interface blanks briefly and comes back on the new file. Plan the switch for a moment the machine can spare its operator screen, tell the operators a change is coming, and expect the terminal to return to its startup selection afterwards rather than to whatever was running before.

Is it worth moving to a platform with live editing to avoid downloads?

Treat that as an architecture decision, not a convenience upgrade. Live or near-live editing changes where the application lives, how it is backed up, who can edit it and how the operator station is built, and some of those designs still compile as part of the change. If displays change a few times a month, the compiled cycle costs minutes; if they change daily across many terminals, a server-based design starts to earn its keep.

Keep reading

  • Troubleshooting

    Fixing an HMI MER runtime version mismatch

    The transfer fails because the runtime version and the terminal's ME Station version differ: a PanelView Plus 600 hardware ceiling is firmware 5.10, while Studio 11 defaults to a version 11 runtime. Read the station version at the terminal, select 5.10 in the Create Runtime Application dialog, rebuild, and remove the gradients or PNG images the build errors name until the 5.10 compile passes.

    HMI and touchscreens

  • Troubleshooting

    Why an HMI Is Detected but Project Download Fails

    Automatic LAN detection proves the panel answers on the network, not that the transfer function works. When USB and LAN both end in "failed to connect to the display unit", work the shared conditions in order: the exact system error code, supply voltage measured during the transfer, transfer settings in the engineering software, and the software version against the project target.

    HMI and touchscreens

  • How-to

    How to Recover an HMI Program When the Source File Is Lost

    If an editable backup was stored on the HMI at download time, upload it and open it as a project. If the terminal holds only the compiled runtime, no upload can recreate the source: document every screen and tag behavior from the running unit, rebuild against the controller project, and convert the runtime only where the vendor documents a path.

    HMI and touchscreens

EasyBuilder Pro animation loop needs an address-driven position