IMDTouchKnowledge BaseShop main store

Explainer

How an HMI Works in an Industrial Control System

HMI and touchscreens Published 8 min read

Short answer

An HMI displays controller tag values and writes operator inputs back to controller tags; the two paths fail independently. Trace every fault from the live controller tag value, because that one reading splits tag, binding, driver and logic faults cleanly.

On this page
  1. What does an HMI actually do in a control system?
  2. What is the path from a controller tag to a screen object?
  3. Which protocol connects the HMI to the controller?
  4. Why does the display work when the buttons do not?
  5. Where do I start when a screen value is wrong or frozen?
  6. How do I tell a tag fault from a binding fault or a driver fault?
  7. How do I verify a write reaches the machine?
  8. Which habits cause the most HMI troubleshooting mistakes?
  9. Questions asked

An HMI works as two one-way paths between the operator and the controller: a read path that pulls controller tag values into screen objects, and a write path that pushes operator inputs back into controller tags. The two paths fail independently — a screen can display perfectly while every button on it is dead — so every fault hunt starts at one place: the live controller tag value, the dividing point that separates source problems from panel problems in a single reading. This page follows the chain the way you meet it on the floor: object, tag, driver, protocol, controller, and back.

What does an HMI actually do in a control system? #

An HMI renders controller tag values as screen objects and sends operator inputs back as tag writes; it stores no process state of its own and executes no control logic.

The controller executes the logic, scan after scan, deterministically, and holds the process state in its tags. Power the panel down and the machine keeps running — that is the design intent. What the HMI owns is presentation: turning tag values into numbers, bars, alarms and trends, and turning touches into tag writes an authorized operator meant to make.

One boundary you do not cross: an HMI is not a safety device. Stops, guards and interlocks belong in the safety controller and the safety circuits designed for them, never in screen logic, because a dark, frozen or unplugged panel has to leave the machine safe.

What is the path from a controller tag to a screen object? #

The path has four links you can test separately: the screen object, its HMI tag reference, the communication driver, and the controller tag — and data crosses it in both directions.

Walk it in the direction the data moves:

  • Screen object — the number, indicator, bar or button the operator sees. Its properties carry the display math (gain, offset, decimal places) and, for inputs, the write behavior.
  • HMI tag — the project's reference: which controller address to read or write, and with which data type.
  • Communication driver — the part of the project that turns tag references into protocol reads and writes against one configured controller connection.
  • Controller tag — the storage in the PLC that logic reads and writes every scan.

You build all of this in the manufacturer's engineering software and download the project to the panel, so the tool, the panel and the controller driver have to match — the first compatibility check covered in Which HMI software works with which HMI panel hardware.

Which protocol connects the HMI to the controller? #

Whichever protocol the HMI's driver and the controller share — in plants today that means Modbus RTU or Modbus TCP, EtherNet/IP, or PROFINET — and the two endpoints must use identical settings.

Each configured device connection in the project runs one protocol against one endpoint. On serial, baud rate, parity, stop bits and the station address have to match exactly; on Ethernet, the IP settings and port do. The register layout and data types must agree at both ends too — a 32-bit float read as two integers displays convincingly wrong numbers, and Displaying a PLC real value over Modbus on an HMI shows where word order decides it.

Two controller brands add a wrinkle: a Model A PLC and a Model B PLC generally cannot exchange data directly, so plants either hard-wire I/O between them or let a panel — or a gateway — carrying drivers for both platforms do the translating. That multi-platform bridging role is where an HMI with several drivers often ends up.

Why does the display work when the buttons do not? #

Because the read path and the write path are separate bindings and separate transactions on the wire: an HMI can be polling values every second and still have every write blocked by a permission or a wrong address.

Reads run on a poll schedule you configure: the driver asks for each tag over and over, and the object paints whatever the last cycle brought back. Writes wait for an event — a touch — and then one transaction carries the value out. Nothing in the panel guarantees the two agree. On top of the mechanics, write permissions and user security can block inputs while reads continue untouched, and a write aimed at a read-only or wrongly-typed address can fail with no visible reaction beyond a status word in the diagnostics. Commission both directions explicitly: a screen that displays is not a screen that controls.

Where do I start when a screen value is wrong or frozen? #

At the controller tag, always: read the live tag value in the controller's programming tool, because that single reading splits every HMI fault into a source problem or a display problem before you touch the panel.

Record the object, the tag name, what the screen shows (value and quality) and the time. Then watch the tag live in the controller.

A worked example with illustrative numbers: a dryer temperature arrives in a controller register as 0 to 10000 counts, standing for 0.0 to 250.0 °C. The object's scaling is gain = (250.0 − 0.0) / (10000 − 0) = 0.025 °C per count, offset = 0.0 − 0.025 × 0 = 0.0 °C. With the register at 7420 counts, the object should display 7420 × 0.025 + 0.0 = 185.5 °C.

Three outcomes decide the next move:

  • Controller tag 7420 counts, screen 185.5 °C — the read path is healthy. If the operator still disputes the number, the argument is with the sensor or the scaling assumption, not the panel.
  • Controller tag 7420 counts, the panel's tag monitor also shows 7420, screen reads 18.55 °C — display math: the gain was entered as 0.0025. Fix the object's scaling; leave the wiring and the PLC alone.
  • Controller tag 7420 counts, panel shows 0 or bad quality — the read path is broken between panel and controller; go to the driver check.

How do I tell a tag fault from a binding fault or a driver fault? #

By what the controller tag shows compared with the screen: a wrong or static controller tag is a source fault, a correct tag behind a wrong object is a binding fault, and many tags failing together is a driver fault.

What you observe Where the fault lives Next check
Controller tag wrong or static Source: sensor, input wiring, or the logic that writes the tag Trace the signal into the controller and the rungs that update it
Controller tag correct, one object wrong Binding: wrong address, data type or scaling Compare the object's tag reference character-for-character with the controller variable
Many unrelated tags bad at once Driver or network: endpoint, cable, settings Read the connection diagnostics on the panel and on the controller side
Write reaches the tag, machine does not move Logic: interlock, mode, permissive Trace the command through the logic and its feedback

The single-tag versus many-tag split is the one to remember: a device-level fault takes every tag on that connection down together, while one wrong number with healthy diagnostics is almost always an address or a data type. A green connection icon only says the driver reached the controller — it says nothing about whether each tag is mapped right, which is why an indicator can sit dark while the controller bit is on, the case traced in Why HMI indicators stay off over Modbus RTU polling.

How do I verify a write reaches the machine? #

Watch the destination tag in the controller while an authorized operator makes one deliberate input: if the tag changes, the HMI's part is proven and the fault is in the logic that consumes the value.

  1. Record the object, tag, live controller value and connection status before touching anything.
  2. Have an authorized operator make one deliberate input at a moment the process permits.
  3. Watch the destination tag live in the controller's programming tool.
  4. If the tag never changes, inspect the object's write configuration, then the tag binding, then permissions, then the connection — in that order.
  5. If the tag changes and the machine stays put, the HMI is exonerated: trace interlocks, mode selectors, permissives and the feedback that confirms the action happened.
  6. Close the loop on screen with the feedback tag, not the button, telling the operator the machine obeyed.

Some architectures reverse the roles and let the controller poll the panel as a slave; there, a read that returns nothing points at the panel's slave mapping, the situation in Why a PLC Modbus master read returns nothing from an HMI.

Which habits cause the most HMI troubleshooting mistakes? #

Three: trusting a green connection icon over per-tag status, changing controller logic to compensate for a bad binding, and reading a button's animation as machine feedback instead of a status tag.

The button is a request; the machine's answer comes back on a status or process tag, and only that tag describes state. A screen change affects what the operator sees, a logic change affects what the machine does — they are not interchangeable, and swapping one for the other hides the real fault while adding a new one. Add two disciplines and most HMI faults become short work: record the object, tag, controller value and connection status before you edit anything, and apply every change, panel or controller, under the plant's change-control procedure. Verify with a value you can watch move, in both directions, before you call it fixed.

Questions asked

Does the HMI run any of the machine's logic?

No. The controller owns the decisions; the panel only requests writes and displays results. Many HMIs can run internal scripts for recipes, animations or screen navigation, and it is tempting to put machine behavior there — do not. Anything that must act on the machine belongs in the controller, so behavior stays identical across every operator station and survives a panel replacement.

Can one HMI serve two PLCs from different manufacturers?

Yes, when the panel's driver list covers both controllers' protocols and its connection count allows it. Each controller gets its own configured device connection and driver in the project, and every tag is bound to the right connection. Confirm the driver, the connection limit and any runtime license for the exact panel before you commit the design.

Why does a button animate when the machine does nothing?

The animation is drawn by the screen itself, so it proves only that the press registered locally. Check the destination tag in the controller next: if it never changes, the write path failed; if it changes and the machine stays put, the block is in controller logic — an interlock, a mode condition or a missing permissive.

What is the difference between an HMI tag and a PLC tag?

A PLC tag is storage inside the controller. An HMI tag is a reference in the panel project: the controller address it points to, plus how the value is typed and displayed. HMI projects also hold internal tags used for screen logic and local functions, and those never leave the panel — mixing up the two kinds is a classic silent fault.

How fast does an HMI screen update a value?

As fast as the poll cycle configured for that tag or tag group, not as fast as controller logic executes. The screen shows the result of the last completed poll, so freshness on screen can never beat freshness on the wire. When an operator needs quicker response, put the fast-moving tags in their own poll group instead of chasing the display.

Keep reading

  • Selection guide

    How to Select a Low Cost HMI With EtherNet/IP Support

    A low cost HMI qualifies for an EtherNet/IP job only when its installed driver reads and writes your controller's application variables — for Omron NJ/NX that means tag-name access, because device and address codes cannot be used with NJ/NX tag data. An Ethernet port on the datasheet proves nothing. Qualify the driver on the bench first, then compare screen size and cost.

    HMI and touchscreens

  • Selection guide

    Selecting a Compact HMI for ControlLogix Over Ethernet

    Select a compact HMI only by a documented ControlLogix tag-based EtherNet/IP client driver plus its matched software and firmware set: the C-More CM5-T4W documents ControlLogix through 1756-ENBT or 1756-ENET/B bridges with CM5-PGMSW 8.0 or later, and PanelView 5310 terminal firmware from the same release pairs with View Designer 8.01.00 and needs Logix firmware 27 or later. CompactLogix-only support, such as the PanelView 800 documented list, disqualifies a terminal for this station.

    HMI and touchscreens

  • Selection guide

    Selecting an HMI That Talks Modbus RTU to Remote I/O

    Select the HMI whose exact software release documents a Modbus RTU client driver that can open the serial port, or route the data through a supported communications server. Prove the choice by polling one module and reading the driver diagnostics before comparing graphics or scripting.

    HMI and touchscreens