Troubleshooting
HMI Function Key Does the Wrong Action: Find the Hidden Object
Short answer
When an HMI function key performs an action you never assigned, the assignment exists in the project. On the affected screen, ungroup the visible artwork, move the static bitmap aside and inspect the concealed pushbutton: it carries its own function-key number and screen-change action. The simulator is reproducing the project faithfully; remove or reassign the hidden object, then put navigation on the function bar on a non-touch panel.
On this page
Press a function key and the panel does something you never programmed: the claim is in the project, not in the simulator. In the documented case, F4 on a small non-touch graphic panel jumped back to screen #1 on screens where F4 had never been assigned. The cause was a screen-change pushbutton set to F4, hidden inside a grouped graphic — a static bitmap drawn over it in the editor. A covered pushbutton still receives its key while its screen runs, so the panel did exactly what the project told it. Fix it in the editor: ungroup the graphic, move the bitmap aside, delete or reassign the exposed pushbutton, and put screen navigation on the function bar. Then retest every screen. Here is how to find the object, decide what each object keeps, and audit the key so the symptom cannot return.
Why the panel does an action you never wrote #
A function-key number lives on an object, not on your intention. Any pushbutton sitting on the active screen carries its own function-key property, and while that screen runs, a press of that physical key reaches the object — whether or not you can see it. Grouping a static bitmap over the pushbutton hides it in the editor and on the display, but the assignment survives untouched. The editor will also let a second object claim a key that is already claimed, without a warning.
That is why the symptom follows the screen, not the program you believe you wrote. On the affected screen the exit graphic was two objects deep: a bitmap drawn over a screen-change pushbutton assigned to F4 and aimed at screen #1. The simulator ran the project exactly as built and showed the truth the artwork concealed. If you suspect the runtime instead of the project, testing HMI simulation against a live PLC is the structured way to separate the two — but read the screen's objects first, because a hidden assignment is faster to find than a runtime argument.
Expose the pushbutton hidden in the group #
Work on the screen where the wrong action happens. The grouped graphic looks and clicks like a single object; the ungroup command is what splits it.
- Click the graphic that covers the area where the wrong action starts — in the documented case, a small exit graphic.
- Right-click it and choose Ungroup. If the command is unavailable, the object is already single and the claim lives elsewhere on the screen.
- Click the static bitmap and drag it a few grid squares aside. Leave it in the project; you may still want the artwork.
- Click what was underneath. A screen-change pushbutton announces itself: its action opens another screen — screen #1 here — and its properties carry a function-key assignment, F4.
- Write down the pair: the key number and the target screen. That pair is the entire cause of the symptom.
- Repeat on every screen where the key misbehaves. A group copied between screens carries its hidden pushbutton and its assignment into every copy.
Resist deleting the whole group in one move. The bitmap may be the only thing giving that area its graphic, and the pushbutton may be carrying an action you want somewhere else. Split them, then judge each object on its own.
Decide what each object keeps #
If the exposed pushbutton has no job on that screen, select it alone and delete it; the bitmap and everything else stay as they were. If the screen needs key-driven navigation and the panel has no touchscreen, put the screen change on the function bar instead — the same place this kind of project already puts F1 — and leave no on-screen navigation object to compete with it. A panel without a touchscreen gains nothing from an on-screen pushbutton that a function key does not do more clearly.
Then give F4 its intended job: the decrement action, pointed at the variable you actually want it to change. Verify the target variable in the editor rather than trusting a remembered tag, and never add a second claim to fix a first one — find the object you did not write and clear it.
On a touchscreen panel the on-screen pushbutton is a legitimate control; just never group artwork with it. Keeping each control visible, single-purpose and separate from decoration is the same discipline as designing HMI screens for clear operator decisions. The pass condition is one claim per key per screen: with one claim, the key does one thing and the panel is predictable; with two, you are guessing editor precedence at the machine.
Worked audit: count the claims on F4 #
The audit below is an illustrative example built on the documented case's numbers: four screens, function keys F1 through F4, F1 set as a screen change on the function bar, and F4 meant to decrement a counter on every screen. You believe F4 is programmed four times, once per screen; the project actually claims it six:
| Screen | F4 claims before the fix | The extra claim | F4 claims after the fix |
|---|---|---|---|
| Screen #1 | 1 | none | 1 |
| Screen #2 | 2 | hidden pushbutton, F4 to screen #1 | 1 |
| Screen #3 | 2 | hidden pushbutton, F4 to screen #1 | 1 |
| Screen #4 | 1 | none | 1 |
The arithmetic: 1 + 2 + 2 + 1 = 6 claims on F4 across the project, of which you wrote 4. Deleting the two unwritten pushbuttons gives 6 − 2 = 4 claims, and 4 claims across 4 screens is exactly one per screen. The symptom appeared on precisely the two screens whose count was 2, and the jump target matched the target screen stored inside the hidden pushbutton. Run this same count for any key that surprises you: list every object and function-bar entry claiming that key on that screen, delete what you did not write, and one claim per key per screen falls out of the arithmetic.
Retest and hand it back #
Run the simulator and press F4 on each screen: the display should stay put while the counter decrements. Then press F1 on the navigation screens and confirm the screen change you kept still works, so clearing the pushbutton has not removed navigation you did want. Put the machine in a safe state before you download the corrected project, because a transfer can reset runtime values and a key whose meaning changes under an operator's finger can start something nobody expects.
If F4 still changes screens, go back and list every remaining claim on F4 for the active screen — another object, another function-bar entry — and clear the one you did not write. If the screen change has stopped but the counter does not move, the navigation conflict is cleared and the decrement object itself is the next suspect: check its target variable and its action settings. Stop and take the case to the panel vendor's support when the editor will not expose the assignment, or the panel behaves differently from the simulator; bring the project file, the panel model, the editor version, the screen number and the exact key sequence that reproduces the action.
The decision, restated: a key that does something you never wrote is a project object you have not found yet. Ungroup, expose, clear the extra claim, and hold the line at one claim per key per screen.
Questions asked
I moved the bitmap aside but the key still changes screens. Why?
Moving the bitmap only exposes the pushbutton in the editor; the function-key assignment is a property of the pushbutton itself, so it keeps firing until you delete that pushbutton or clear its key field. Select the pushbutton alone, delete it if it has no job on the screen, transfer the project again, and retest the key.
Why does the same wrong action appear on screens I never edited?
Grouped artwork copies with everything inside it. If the group holding the hidden screen-change pushbutton was pasted onto other screens, every copy carries the pushbutton and its function-key assignment along. Ungroup on each affected screen and clear the extra pushbutton there; a fix made on one screen never propagates to the copies.
Can two objects share one function key on the same screen?
The editor will not stop you: assigning a key that is already claimed to another object or a function-bar entry produces no warning, and both assignments stay in the project. Which one you observe then becomes unpredictable. Treat one claim per key per screen as the pass condition and clear duplicates whenever an audit finds them.
How do I keep this from happening on the next project?
Keep artwork and controls as separate, ungrouped objects so nothing can hide inside a group, and press every function key on every screen in simulation before handing the project over. A four-screen panel with four function keys needs sixteen presses; that walk surfaces every unwritten claim while it is still cheap to fix.