Selection guide
How to Prove a PC-Based HMI Before Replacing Panel Terminals
Short answer
Use an isolated bench controller to compare candidate PC-based HMI runtimes. Test the read path, one write to a spare test tag, touch response, communication loss and automatic recovery. Check the deployed license on the target PC.
On this page
- What must the acceptance screen prove before anything is bought?
- How do I verify the driver against the controller I actually have?
- What numbers make the acceptance test a pass?
- Should I choose the software or the display first?
- Is an integrated panel PC or a separate computer and touch monitor better?
- How do I prove the runtime license and startup before the machine depends on it?
- Why does the screen work in development but fail on the shop PC?
- When is a dedicated terminal still the right answer?
- Questions asked
Start with one acceptance screen on an isolated bench. Use a controller representative of the installed model and firmware and run each candidate on the intended target PC. Check live data and a discrete status bit, write one spare test tag, count touch responses and verify that the screen clearly marks lost communications. Test the deployed license and startup before selecting the screen size and packaging.
What must the acceptance screen prove before anything is bought? #
The screen should read live data, deliver a write to an isolated test tag, register touch input and clearly flag the loss of usable controller data. Check the runtime and license on the target PC, and verify startup separately.
A numeric object can retain its last value when communications fail. A button can animate locally even when the write never reaches the controller. Show stale or bad-quality data clearly and verify successful writes in the controller diagnostics.
Use a spare test tag on the isolated bench controller. Cross-reference the tag and verify the test configuration cannot command outputs or move equipment. Conduct the disconnect and restart tests on that bench.
How do I verify the driver against the controller I actually have? #
Read and write representative tags through the documented driver and compare both against the controller's programming software; a controller name on a compatibility list is a starting point, not a result.
Treat the checks separately: the engineering tool, target model and firmware are one verification, the PLC driver and the runtime license are another, and a pass on one proves nothing about the other. Record the controller identification and communication configuration from the installed project, then build test tags that represent the application's real data types — a floating-point setpoint, a 16-bit integer count, a Boolean state.
For writes, the evidence is the target register in the programming software, not the entry field on the screen. Where the controller is a Rockwell product, its Product Compatibility and Download Center publishes the version dependencies between firmware, software and runtime components, and other vendors publish equivalent matrices; where a version mismatch blocks a project transfer to the controller, the documented fix is aligning the project's firmware version with the installed one.
The mapping of which engineering software targets which panel family is a separate question from driver fitness, covered in which HMI software works with which panel hardware.
Decision: if the driver cannot address a data type or register block the application needs, stop there. No processor, screen size or memory upgrade fixes an addressing limit.
What numbers make the acceptance test a pass? #
Set limits from the machine requirements and the candidate driver settings. The example below uses a 10-minute bench run, a 1 Hz source counter, 125 touches and a 2 s controller readback limit. Record the actual values and timestamps.
A 1 Hz counter generates 600 increments over 600 seconds. A matching final display value confirms that the HMI caught up. To count each update, capture a time-aligned controller and runtime trace, account for polling or subscription cadence, and check the full sequence. If the application only requires fresh data, measure the maximum observed update delay against that requirement.
| Object on the screen | What it proves | Example pass criterion |
|---|---|---|
| Numeric display on a 1 Hz test counter | Read path and update age | Controller generates 600 increments in 10 min. Compare time-aligned checkpoints and record the longest display delay. |
| Indicator on a controller-driven bit | Discrete data path | Toggle the bench bit, hold it long enough for the configured update interval and time the visible change against your limit. |
| Numeric entry to a spare test tag | Write path and permissions | Enter 42.0 and verify controller-side readback within the example 2 s limit. |
| Touch targets | Touch response across the display | Tap five positions 25 times each. Verify 125 accepted actions and confirm where each touch registered. |
| Communication-health indicator | Failure visibility | Disconnect the bench link and time when the screen marks data stale or disconnected. Compare with the defined limit. |
Time fault detection and recovery separately. Account for the driver timeout and retries, tag quality and display update interval. When you restore the bench connection, verify good quality and advancing values before clearing the fault. For a restart, this example requires live values within 120 s without operator action. Confirm your runtime and license start correctly on the target PC.
Keep a runtime as a candidate when it passes every required bench check on the target hardware. Qualify the full application and installed system before service.
Should I choose the software or the display first? #
Software first: a 21-inch panel running a runtime that cannot address your registers is a sunk cost, while a proven runtime moves to any screen you like later.
Judge candidates by pixel resolution, brightness and viewing distance rather than diagonal alone. Between the 19-inch and 21-inch sizes most shops shortlist, a 19-inch panel with more pixels shows more process information than a 21-inch panel with fewer, because a larger diagonal at the same resolution only enlarges objects.
The display decision also settles how many stations you buy, so make it with the runtime facts in hand, after the pass.
Is an integrated panel PC or a separate computer and touch monitor better? #
Use a separate computer and touch monitor when you want to replace either half independently; use an integrated panel PC when one sealed front panel and a single mounting cut-out matter more than that serviceability.
| Arrangement | Why you choose it | What to verify before committing |
|---|---|---|
| Integrated panel PC | One cut-out, one sealed front, one power drop — the natural shape for replacing a terminal | The service path: whether a failed display or board means replacing the whole assembly |
| Modular panel PC, computer and monitor engineered to mount together | Panel-PC packaging with the option to replace the display or the computer on its own | That the two modules you combine are documented as a supported pair |
| Separate computer plus touch monitor | Each half is replaced and stocked independently, and the computer can sit deeper in the cabinet | Video and touch cable lengths, power wiring on terminal blocks, and access to both units |
The integrated shape is what industrial panel PCs deliver out of the box. Decision by case: washdown sealing and a single door cut-out point to the integrated or modular panel PC; a shop that keeps one spare computer and swaps displays machine to machine points to the separate arrangement.
How do I prove the runtime license and startup before the machine depends on it? #
Install the exact runtime build on the target PC, configure it to start with the operating system, and confirm the license covers that machine — a demonstration on the development seat proves none of the three.
A development seat and a deployed runtime are different entitlements. Find out what the runtime license attaches to — the PC, a dongle or a license server — because that decides how you handle a hardware swap years from now. Match the runtime version configured in the project to the version installed on the target, and confirm the target's operating system edition is a supported one for that release.
Then prove startup with the restart row of the acceptance sheet rather than trusting a setting. Plan the platform's service cycle around the operating system's support horizon rather than the hardware's, and record that end date in the platform plan. For a controller on Modbus TCP, the same proof applied end to end is walked through in choosing a PC-based HMI runtime for a Modbus TCP PLC.
Why does the screen work in development but fail on the shop PC? #
Because development runs use the engineering seat's drivers, paths and license; the shop PC runs the deployed runtime, so failures there point at installation, licensing, startup or connection configuration, not at your graphics.
| Observation on the shop PC | Where the fault usually is | Next reading |
|---|---|---|
| Every value fails or freezes together | The shared connection, driver or controller access | Runtime connection diagnostics, then compare with controller-side values |
| One object is wrong while its neighbors update | Tag address, data type, scaling or object binding | Compare the raw tag value with the controller value |
| A value reads correctly but an entry does nothing | Write permission, command handling or controller logic | Watch the target register in the programming software during the write |
| The screen answers a mouse but not touch | The touch interface, its driver or its calibration | Run the same control with each input method |
| It worked until the last reboot | Startup configuration or a license check | Read the runtime's own diagnostics on the target PC |
A command that briefly changes and then returns can be a healthy write followed by a controller decision; the register trace settles which. Touch that misses only in parts of the screen is a touch-controller question rather than an HMI software one, and separating the real causes when touch calibration fails or drifts keeps the blame off the runtime.
Decision: if every value fails together, work the shared connection before touching a single tag; if one object fails, stay on that tag and its binding. Never rebuild the communication configuration to fix one bad object.
When is a dedicated terminal still the right answer? #
Keep dedicated terminals when each machine needs one simple, sealed operator interface and nobody asked for data logging, reports or multi-line views; move to the PC when those jobs appear or the screens must be large.
A dedicated terminal wins on survivability, fixed startup time and sealed packaging for single-machine monitoring, and it loses as soon as the job list grows to historians, database or report integration, web clients or large shared displays — the work a general-purpose PC runtime does well.
Either way the control logic stays in the PLC: a PC-based HMI moves visualization only, and dedicated PLC versus PC-based control is the separate decision to make if you are tempted to move the logic onto the PC.
Shortlist runtimes, record the bench results on the intended hardware, and verify the deployed license, firmware and recovery before releasing the purchase specification.
Questions asked
How long should the platform soak after the acceptance test passes?
Run the same isolated bench test for a representative shift. Keep a timestamped record of update age, tag quality and reconnects. A 1 Hz source generates 28,800 increments in eight hours. Equal start-to-end counts show net catch-up. Use a time-aligned trace to check intermediate delays and missed observations.
Do I need to build the full application before testing a candidate?
Start with a small test screen for the read path, a test write, touch response, communication loss and recovery after a restart. Build the full application after qualifying a candidate on the intended target PC.
Can one PC-based HMI serve several machines?
Yes, when the documented drivers, ports and connection limits support the combination, and when one screen still matches how operators work the line. Count stations by the job each one does: an overview belongs on one PC, while a machine-local start and stop still wants its own panel at the machine.
What if two runtimes pass the same acceptance screen?
Break the tie on deployment facts the test exposed: licensing model, tag-count limits for the full application including alarms and diagnostics, startup behavior and the support path. Count the real application's tags, not the four on the test screen, before comparing limits.
What if the driver lists my controller but not its firmware?
Treat the listing as unproven until your exact controller and firmware read and write your test tags. Vendors publish compatibility databases for this check, and where a version mismatch blocks a project transfer, the documented fix is aligning the project's firmware version with the installed firmware.
Corrections
- : Clarified the bench test, what the counter proves, and how to measure loss and recovery against the selected runtime settings.