HMI language changes back after startup: find the runtime selector

Why does my HMI switch back to the old language after startup?

A runtime language selector is overriding your default. The flip at about 5 seconds after startup is the evidence: a default that failed to save would be wrong from the first frame, not correct for 5 seconds and then change.

An HMI project carries two language mechanisms. The first is the default language number, a value you set once that picks the starting language from the project's list. The second is the runtime selector, a number that sets the current language while the project runs. On a machine linked to a PLC, that selector usually lives in a PLC word: the project reads it, and whatever the logic writes becomes the language on screen.

That is why clearing panel memory and reloading the project changed nothing. A reset restores stored settings, and the write still arrives after startup, a few seconds in. Find the word and correct what writes it.

How do I tell a startup default problem from a runtime selector?

Watch the panel from power-up and time the flip. A startup-default fault is wrong from the first frame, while a runtime selector lets the panel start in your language and change seconds later, after the project reads the PLC.

The same two-phase pattern decides other power-up faults too, and testing startup and runtime behavior first is the bench habit that catches them. Match your symptom to one of these:

• Correct for a few seconds, then flips, on every start. The selector receives a value after the project starts, most often from the PLC.
• Wrong from the first frame and never correct. The default points at the wrong slot, or the project's language list is ordered differently from what you assumed.
• Simulation shows the right language, the connected panel flips. Simulation runs without the PLC, so a selector that reads live PLC memory behaves differently on the machine. This is the strongest sign of a PLC write.
• The flip follows an operator action or a machine mode change. Mode-based selection is a designed function. Trace the trigger before you treat it as a fault.
• The flip appeared right after a project reload. Start inside the project; the reload changed something a PLC write did not.

One test separates the PLC-side and project-side causes in the first three cases: watch the selector value through the flip. The procedure comes below.

Where do HMI projects keep their language settings?

Two places: the language list, which numbers every language the project carries, and the runtime selector, which picks one of those numbers while the project runs, either from a button or a word linked to the PLC.

The list holds numbered slots, numbered 1, 2, 3 and so on. Panel setups usually offer several slots; one widely used panel provides up to nine and ships every slot set to English until you assign a language. The default number is part of setup: in the imported machine's software it sits in the panel manager under setup, and in one major HMI package it sits in the runtime settings under Language and font. Your software will have an equivalent of one of the two.

The selector is the second mechanism, and packages implement it three ways: buttons that each call one language, a system function such as SetLanguage called from a button or a startup script, and a word mapped into PLC memory that the project reads as its current language. The mapped word is the one that overrides your default a few seconds after startup.

Note the slot numbers before you trace anything. In this machine's list, 1 is Japanese and 2 is English, and the default is 2.

How do I find the tag the panel watches for the language number?

Search the HMI project for the language-selection object or word and read its address from the project. The selector's address is defined by the project, and a guessed address will send you editing the wrong PLC memory.

Work in this order:

1. Back up the HMI project and the PLC program before you edit either one.
2. Search the project for language selection: enabled slots in the language setup, language buttons or drop-downs on screens, and startup scripts or macros that call the language function.
3. Read the selector's address and data type from the project, and note whether the project maps it to a PLC address.
4. Open the PLC and list every instruction that writes that address, including startup routines and mode-change logic.

If the address the project names is one the PLC rejects, sort that out first; fixing HMI invalid address errors covers the usual reasons a tag fails to resolve. The selector's address is whatever the project says it is, so trace it, then edit.

What does the selector do in the first seconds after power-up?

Sample the selector word about twice a second from power-up through the flip and record every reading. The values before and at the flip tell you which side wrote the change.

1. Connect a watch to the PLC address the project maps, or to the panel's language system tag if your software monitors it online.
2. Set the sample interval to 0.5 s or faster, so the flip and the value change appear together in the log.
3. Start the watch, then power the machine up under its normal procedure.
4. Record the selector from 0 to 30 s, then again through any mode change and any operator language button.
5. Compare the log with the screen: a value that changes exactly when the text flips points to the side that owns the write; a value that holds while the text flips points to the project itself.

Keep the startup sequence normal during the watch. A forced start can skip the routine that writes the value, and you would measure a startup the machine never runs on the floor.

Example: which side writes the language number at the 5-second flip?

The machine starts in English, holds it for 5 seconds, then flips to Japanese. The watch explains it: the selector reads 2 from 0 to 4 seconds and reads 1 at the 5-second mark, so the PLC wrote the change.

Scenario: a machine imported from Japan carries a panel project with slot 1 as Japanese, slot 2 as English, and the default language number set to 2 in the panel manager. The watch sampled the selector every 0.5 s through a normal startup:

The readings at 4.0 s and 5.0 s bracket the change, so the write lands in a 1.0 s window (5.0 - 4.0 = 1.0 s). At a 10 ms scan time, typical of a small machine program, that window spans 100 scans (1.0 s / 0.010 s = 100), so the logic search, not the stopwatch, locates the write: a routine that runs once the project connects and copies 1 into the selector address.

Decision: the panel and its default are working, and the correction belongs in the PLC. Change the constant in that write from 1 to 2, or make it copy the operator's stored choice. If the same watch had shown the word holding at 2 while the text flipped, the write would sit inside the HMI project, most likely a startup call to the language function, and the project would be the file to correct.

How do I fix the language change without breaking operator selection?

Correct the value or the logic that writes the unwanted language number, one change at a time. Leave the selector mechanism in place whenever operators use it to pick a language on the machine.

PLC side: find the instruction that writes the selector address and change what it writes. Replace the fixed constant 1 with 2 in the example, or copy the operator's stored choice so the last language an operator picked survives a restart. Project side: remove or correct the startup call to the language function, and confirm the language buttons on screen write the same word with numbering that matches the list.

The trace-the-writer method covers a family of startup faults: an HMI that overwrites PLC retained variables at startup is the same shape of problem, and the same discipline finds that writer too.

Removing the PLC-linked selector from the project does stop the flip, and it is the right move only when the machine has no operator language selection and no mode-based selection. Otherwise you are disconnecting a function the builder designed. Make the PLC edit with the machine stopped and under your site's change procedure, and download one corrected side at a time.

Recommendation: Watch the selector word through startup before you edit anything. If it changes from 2 to 1 at the flip, correct the PLC value or logic that writes 1. If it holds at 2 while the text flips, correct the startup selection inside the HMI project. Remove the PLC-linked language word only when the machine has no operator language selection and the machine owner approves the removal.

How do I verify the fix survives a power cycle?

Power the machine down and up under its normal procedure and watch the panel through a full startup. The chosen language must hold past the old flip time, about 5 seconds in the example, and through every mode change a shift will produce.

Run the checks in order:

• Record the default language number and the selector value at startup.
• Confirm the chosen language still shows after the project connects to the PLC, past 5 seconds and through 30 s of normal startup.
• Press every operator language button and step through each machine mode used in a shift, and confirm the language follows the designed path.
• Power down and up again and repeat the watch. The result must survive a restart, because a selection held only in runtime memory is gone at power-off.

If the language flips again, capture the selector value at the new transition and apply the same decision: value changed, the PLC side needs another look; value held, the project still has a selection path. A second pass through the watch usually isolates it.

Questions