IMDTouchKnowledge BaseShop main store

How-to

Validating HMI variables during a software migration

HMI and touchscreens Published 8 min read

Short answer

A converter promise with no release date is not a migration plan. Inventory every source variable with its name, type, address, read/write use and consumers; convert only a working copy or recreate variables from the inventory; then test each variable's reads, approved writes, screens, alarms and scripts against that inventory before commissioning.

On this page
  1. The migration sequence
  2. Confirm what the converter covers before you plan around it
  3. Build the variable inventory first
  4. Convert a working copy, never the original
  5. Compare the target variable list against the inventory
  6. Test every read and every approved write
  7. Worked example: a 96-variable machine project moving platforms
  8. Walk every screen, alarm and script that consumes a variable
  9. Close the migration with records and a rollback path
  10. Questions asked

Do not schedule a platform migration around a converter that has been announced but not released. A statement of intent carries no release date, no supported version list and no conversion scope, so it cannot carry a schedule. The working decision: inventory every variable first — name, data type, controller address, read or write use, and every screen, alarm and script that consumes it — then convert or rebuild only a working copy, and validate each variable's reads, approved writes and dependent functions against that inventory before the machine runs on the new project. Whether your move is Vijeo Designer to EcoStruxure Operator Terminal Expert or any other platform change, this is the procedure that holds.

The migration sequence #

  1. Record the exact source product and version, the target software version, the controller and the connection. Ask the vendor's support channel what their converter covers for those versions.
  2. Inventory every variable: source name, target name, data type, address or source reference, read or write use, consumers, and one known value captured from the running machine.
  3. Convert or rebuild a working copy only. The original project stays untouched as the rollback.
  4. Compare the target variable list against the inventory entry by entry and fix every mismatch before the project touches live equipment.
  5. Test every read against its captured value and every approved write at the controller, under the site's commissioning controls.
  6. Walk every dependent screen, alarm and script in the target runtime, record the results, and close the migration only when every counter reads 100 percent.

Confirm what the converter covers before you plan around it #

Start with the versions. Record the exact source product and build, the target software version, the controller or data source, and the driver the project communicates through. If the target software does not list your terminal yet, clear that first — the article Why an HMI Model Is Missing From the Programming Software walks that check.

Then put three questions to the vendor's support channel — Schneider Electric owns both Vijeo Designer and EcoStruxure Operator Terminal Expert — about their converter: is a released version offered for your exact source and target versions, which versions does it support on each side, and what does it convert — variables only, or screens, alarms and scripts as well. Ask for the documented procedure in the same reply.

Judge the answer by its contents, not its tone. A confirmation you can schedule against names versions and scope. An announcement of a converter in preparation names neither, so treat it as unavailable and plan the manual path.

Two vendor-documented facts belong in the same plan. Some terminals document a runtime move instead of a project conversion — the HMIG3U, for example, moves its runtime from Vijeo Designer to EcoStruxure Operator Terminal Expert by downloading to the target — and a runtime move still leaves every variable to convert or rebuild and revalidate. And Mitsubishi Electric's upgrade guidance for HMI and SCADA replacements makes the general points explicit: plan to export and import as much information as the tools allow, and review every existing graphic interface as part of the move.

If this migration is also the moment the aging operator terminal gets replaced, read Planning an HMI Terminal Replacement From an Older Operator Panel alongside this procedure; it covers the hardware side of the same project.

Build the variable inventory first #

Build the inventory from the source project before anything converts. It is the baseline every later step compares against, and it carries one row per variable with these fields:

Field Record What it catches
Identity Source name and the name the variable will carry in the target Renames, duplicates and name collisions
Data definition Declared data type and the controller address or source reference Silent type-width changes and mappings to the wrong address
Use Every screen, alarm, script and recipe that consumes the variable, and whether each use reads or writes Variables that converted while their consumers did not
Expected behavior One known value captured from the running machine, with its units and the machine state it came from Gives every read test its pass mark

Clear up duplicates, missing references and unclear read or write behavior in the inventory before conversion. A name match proves nothing: the target variable can keep the same name and still point at different data or behave differently.

Convert a working copy, never the original #

Keep the source project untouched and attempt the first conversion on a copy. Run only a converter confirmed for your exact source and target versions, keep the report and every warning it produces, and never let conversion output overwrite the original project.

If no converter covers your versions or your scope, rebuild the required variables in the target project with the inventory as the controlled mapping: one inventory row in, one target entry out, nothing from memory. That is slower, and it is the path your schedule should already assume, because an announced converter is not a plan.

Either way, a conversion message confirms the files converted and nothing more. Whether the dependent screens, alarms and scripts survived is what the remaining steps establish.

Compare the target variable list against the inventory #

Before the project connects to live equipment, check every inventory row against the target variable list: name, data type, address or source reference, and read or write permission. Three silent mismatches show up again and again in platform moves: a type widened during conversion, scaling fields reset to raw values, and a write permission dropped to read-only. None of them is visible on a screen that happens to show a plausible number.

Correct every missing, changed or unmapped entry in the target project before runtime testing. Then configure the target project's data source with the connection details of the real controller and confirm communication before the first read.

Test every read and every approved write #

Where the tools allow it, exercise the migrated screens against a simulated controller first — the setup is the one described in Testing HMI Simulation Against a Live PLC. Then move to the real controller.

  1. Read test: display each variable in the target runtime and compare it against the captured known value, units included.
  2. Re-check captured values after any project transfer, because a transfer can reset variable values in the target; Why HMI Variable Values Reset After a Project Transfer explains what moves and what clears.
  3. Write test, one safety rule first: write only inside an approved commissioning window, with the machine in a state where the commanded action is safe, and never on a safety or interlock tag.
  4. Exercise every approved write from the target project, confirm the new value at the controller, restore the original value and confirm the restore.
  5. Log each pass and fail against its inventory row so the remaining work is a list, not a memory.

Both directions get tested, variable by variable. A successful read proves nothing about a write, and a plausible display can sit on the wrong address; operators act on both.

Worked example: a 96-variable machine project moving platforms #

Inputs, all taken from the inventory built earlier (these counts are an example scale for a small machine project, not a limit): 96 variables, of which 84 are read-only and 12 are read and write; 12 screens, 9 alarms and 6 scripts consume them; one known value captured per variable during a production run, with its engineering units; the converter report shows 96 name matches and 3 type mismatches; the first read pass finds 2 wrong-address failures.

The rule in words: the migration is releasable only when four counters all reach their full counts — entry check, read test, write test, consumer walk — with the consumer count equal to screens plus alarms plus scripts. One failure anywhere blocks cutover.

The arithmetic:

  • Consumers to exercise: 12 + 9 + 6 = 27.
  • Entry check: 96 compared, 3 type mismatches corrected and recompared, giving 96 of 96 entries matching the inventory on name, type and address.
  • Read test: 96 reads against captured values; 2 returned the wrong number because both variables had been mapped to swapped addresses; both corrected and retested, giving 96 of 96 reading back their captured values.
  • Write test: 12 approved writes exercised in the commissioning window, each verified at the controller and restored, giving 12 of 12.
  • Consumer walk: 27 of 27 screens, alarms and scripts exercised in the target runtime.

Result: entry check 96 of 96, read test 96 of 96, write test 12 of 12, consumer walk 27 of 27.

Decision: the project is releasable — cut over, keep the original project as the rollback, and file the test log with the inventory. If the read test had stopped at 94 of 96, the decision inverts: one wrong address behind a display is a wrong number an operator will act on, so the cutover stays blocked until the count reaches 96 of 96.

Walk every screen, alarm and script that consumes a variable #

Use the inventory's Use column as the test list. Each screen: confirm it displays the variable the row names. Each alarm: force its condition in a controlled way and confirm it triggers on that condition and only on it. Each script and command: confirm it operates on the named variable. Recipes and historical trends count as consumers too; if the target project stores trends, the checks in Verifying HMI Historical Trend Retention Before Committing apply before you commit.

Work through the converter's warnings at the same time, function by function, and never dismiss one because the project opens.

Close the migration with records and a rollback path #

Record the test result on every inventory row, then record the migration as a whole: source product and version, target version, converter identity if you used one, and every unresolved difference you accepted. Keep the original project and the source-to-target mapping available for rollback and for whoever maintains the machine next.

Close commissioning when every inventory row and every dependent function has passed its check. Until then, the original project stays the running one and the migrated project stays off the machine.

Questions asked

Should I schedule the cutover around a converter the vendor says is planned?

No. Build the variable inventory now, because you need it whether the converter arrives or not, and plan the manual recreation path as the baseline. If a compatible converter appears before cutover, use it to shorten the conversion step, then run the same comparison and the same runtime tests. An announcement without a release date, supported versions and conversion scope is not a schedule dependency.

How do I test a write from the migrated project without risking the machine?

Pick a variable the process tolerates changing, such as a screen-only value or a non-critical setpoint, and follow the write test in the body: commissioning window, safe machine state, no safety or interlock tags. Keep production writes inside the approved window so an operator never sees an unexplained value change on a live screen.

What proves an individual variable migrated correctly?

Three matches. The target entry equals the inventory row on data type and controller address or source reference. A runtime read returns the known value you captured from the running machine before the move, units included. And each approved write changes the controller value it should and restores cleanly. Run all three even when the converter reports a clean match, because its report checks names and files, not controller mapping.

What if the converter changes a variable's data type?

Treat it as a failed entry even though the project opens. Compare source and target ranges and scaling: a value moved into a wider type keeps its magnitude but can pick up a different raw-versus-engineering interpretation. Correct the type and scaling in the target project, update the inventory row, and rerun the read test against the captured value before you trust that variable anywhere.

Keep reading

  • Troubleshooting

    When an HMI Model Is Missing From the Programming Software

    The model-selection list in HMI programming software contains only the panels whose definitions are installed on that workstation, so a missing model means missing model support. Run the editor's model-support setup utility from its own installation directory, or get the software upgrade from the vendor, and never substitute the nearest similar model number.

    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

  • Troubleshooting

    Why HMI Variable Values Reset After a Project Transfer

    HMI values reset after a transfer because the transfer's Initialize settings requested it, the variables were never marked retentive, or the editor's newer version forced a firmware update that initializes all variable memory. Clear [Variable Value] and [Backup Memory] under Initialize, mark operator values retentive, and retrieve the program plus current values with Shift + X before you transfer. Only the firmware-update path wipes retentive values; capture them first, because no setting protects them through it.

    HMI and touchscreens

Implementing operator screenshots in mappView with GetScreenCapture