Troubleshooting
Why WinCC Flexible Edits Do Not Show in Runtime
Short answer
Saved WinCC flexible edits stay invisible in Runtime until the runtime output is regenerated with Rebuild all and transferred to the target; the panel runs a build, not your project file. After redeploying, confirm the edit on the panel itself, and test every VBScript command on that target class because Windows CE panels support fewer commands than PC Runtime.
On this page
- Where an edit can stop on the way to Runtime
- Run Rebuild all, then transfer and verify
- Worked example: tracing one tag edit through rebuild and transfer on a Windows CE panel
- Script commands depend on the target, not on the language
- Checks when Rebuild all did not fix it
- The decision for each case
- Questions asked
If you saved an edit in WinCC flexible and Runtime still shows the old screen, the edit never went through the two steps that deliver it: Runtime executes the last build that was regenerated and transferred, not the project file open in your editor. The fix is a fixed cycle — save, run Rebuild all, transfer the regenerated output to the panel, then confirm the change on the panel itself. The second trap is scripting: WinCC flexible accepts a condensed VBScript instruction set, and Windows CE operator panels accept fewer commands than PC Runtime, so a script proven on a PC can still fail at the machine. Work the rebuild-and-transfer path below, then check each script command on the target.
Where an edit can stop on the way to Runtime #
Between your keyboard and the operator there are three stages, and your edit can stop at any of them:
- the saved project data in the editor,
- the regenerated runtime output the build produces,
- the transferred build the target executes.
The operator sees only the third stage. Saving stops at the first. If the runtime output is never regenerated, the transfer delivers the previous output; if the transfer never completes, the panel keeps executing the previous build. All three failures look identical on screen — the change simply did not take effect.
The vendor's support answer to this exact report on the WinCC flexible 2007 and 2008 generation was to use the Rebuild all function, and that is the right first move: saving alone never updates a running Runtime. The same delivery path governs every editor of this kind — an HMI edit only reaches the machine when a new runtime download follows it, which Why an HMI edit needs a new runtime download covers in detail.
Run Rebuild all, then transfer and verify #
Run this cycle with one small, traceable change before you rebuild a large production project at the end of a shift. A full rebuild costs real time on a big project, and a small change proves the path cheaply.
- Make one identifiable change and save — a text object on the screen you can open fastest works well. Note the project revision so you know what to look for.
- Run Rebuild all and confirm the build finishes without a reported error. A failed build delivers nothing new, so clear the error before going further.
- Transfer the regenerated output to the panel with the project's transfer settings, and read the transfer log for a completion message, not just for the start of the transfer.
- Open the changed screen on the panel and compare it with the saved project, object by object.
- If the panel still shows the old build after a completed rebuild and a logged transfer, rerun Rebuild all and repeat the transfer once; if the change is still missing, the fault sits in the transfer path or the target — cable, transfer settings or the panel's transfer mode — not in your edit.
Record which build was transferred so the next engineer can tell builds apart. One safety note: until the new build is confirmed on the panel, treat every limit and acknowledgement shown there as the old build's, because that is what the operator is working to.
Worked example: tracing one tag edit through rebuild and transfer on a Windows CE panel #
Inputs. The target is one WinCC flexible operator panel running Windows CE, the panel class the vendor's scripting documentation covers next to PC Runtime. The test change touches three artifacts (values illustrative for this example):
- one screen text label, changed from
Rinse AtoRinse B; - one tag on that screen, a rinse time limit, changed from 30 s to 45 s;
- one script line behind the acknowledge button, replacing the unsupported
MsgBoxcall with a command from the supported set.
The rule in words. The panel displays the build it runs. Your edit reaches the screen only after the project is saved, the runtime output is regenerated with Rebuild all, and that output is transferred — and delivery comes as one whole build: Runtime never merges single edited objects into the build already on the panel.
The arithmetic. The saved project now carries 3 changed artifacts (1 label, 1 tag, 1 script line). The transfer completes, you open the screen, and it still reads Rinse A with the limit at 30 s. Edits visible on the panel: 0. Edits missing: 3 − 0 = 3. All three missing at once is the signature of a stale build, not of a partially applied edit — with whole-build delivery, the panel either runs the new build, 3 of 3, or the previous one, 0 of 3.
The result. Zero of three visible means the transferred build is the previous one. Your edits are intact; the delivery is not.
The decision. Rerun Rebuild all, transfer again, and recheck. The path is proven only at 3 of 3 — Rinse B on the label, 45 s on the tag, and the new script behaviour at the button. Then test the replacement command on this panel, because Windows CE panels support fewer script commands than PC Runtime: a pass on the PC proves the project, not the panel. The threshold to remember: any edit missing after a completed transfer means the whole build is stale — rebuild and retransfer before you touch anything else.
Script commands depend on the target, not on the language #
WinCC flexible scripting is a condensed VBScript instruction set, not the full language. The vendor's scripting documentation states the scope: the essential Visual Basic commands work both in PC Runtime and on operator panels with Windows CE, with exceptions, and the touch-panel set is smaller still, which the scripting help explains directly. MsgBox is the commonly reported example — WinCC flexible does not support it, and the working substitute in practice has been a WSHShell call that produces the same operator acknowledgement for starting a process.
Make the target check a rule: before any command goes into a production script, read the scripting help entry for the selected target class and run the script once on that class of target. A script that passes in PC Runtime and fails on the panel is an unsupported command on that target — replace it from the supported set rather than shipping a script proven only on the PC.
Budget the scripts when the project's next stop is TIA Portal: the WinCC V13 readme states that VB scripts from earlier versions are no longer supported, so every flexible-era script needs rework. How to migrate a WinCC flexible project to TIA Portal walks the conversion step by step.
Checks when Rebuild all did not fix it #
If the cycle leaves the change invisible, work this list; each check has a pass condition you can see:
- Saved project — reopen the project and inspect the edited object. Pass: the change is in the saved data. If it is not, the edit was never saved and no build can deliver it.
- Build result — Rebuild all finished without a reported error. A completed build is necessary but not sufficient; it proves nothing about the panel yet.
- Transfer — the log shows the regenerated output reaching the target. Pass: a completion message, not just a start.
- Runtime identity — the panel is executing the build you just transferred; How to verify the HMI project version running on a panel gives the checks that identify the build on the target.
- Visible behaviour — the changed screen, tag and script match the saved project on the panel itself. Pass: all three agree.
One lookalike fault: if the rebuilt runtime shows #### instead of values for PLC tags, the build and transfer succeeded and the fault is tag display formatting — Why rebuilt HMI runtime files show #### for PLC tags covers that separately.
The decision for each case #
- Change visible after rebuild and transfer — done. Record the build and revision you transferred.
- Change saved but not visible — the build on the panel is stale: run Rebuild all, retransfer, verify on the panel.
- Rebuild finished, transfer log incomplete — the panel still runs the old build: rerun the transfer and read the log for completion.
- Script passes on the PC, fails on the panel — unsupported command on that target: substitute a command from the supported set and test on the panel.
- Project headed for TIA Portal — plan the script rework now; flexible-era VBScript does not carry into WinCC V13 unchanged.
Questions asked
Can I edit a WinCC flexible project when the machine PC has only Runtime installed?
No. Runtime is the execution side only: it displays and controls, but it contains no editor and cannot regenerate a build. To change screens, tags or scripts you need the engineering software and the project file, from the engineering station or a project backup. Edit there, run Rebuild all, and transfer the regenerated output to the target; a runtime-only installation can run the HMI but cannot rebuild it.
How do I test a script on the panel before releasing it?
Run it on the panel itself. The vendor documents starting WinCC flexible Runtime with Script Debugger to debug a script: set test values, trigger the script, and watch the result on the panel. A pass in PC Runtime or in simulation proves the project logic only, not command support, because the Windows CE command set is smaller than the PC set. Release the script only after it passes on the target class that will run it.
What happens if the transfer to the panel is interrupted?
The panel keeps running the build it already had; an interrupted transfer does not leave a half-updated runtime behind. Rerun the transfer from the beginning and read the log for a completion message before trusting anything on screen.
Does the panel keep running while it receives the new build?
No. The panel leaves its runtime to receive the transfer and then starts the build it received, so every update is a short planned stop. Time it for a moment when the operator does not need that screen, let the transfer finish, and verify the changed screen before handing the machine back to production.