PLC Simulator
HMI Builder

Industrial HMI Simulator — Build PLC Operator Screens

Practice HMI development against a running PLC simulation: bind widgets to simulated tags, test interlocks and diagnose operator-screen behaviour. No install. The concepts prepare you for vendor tools such as FactoryTalk View, WinCC and GP-Pro.

Join 15600+ learners practicing PLC programming

The first exercise is free. Create a free account to save your screens.

HMI simulator for building operator screens against a running PLC training simulation
Real hmi simulator footage

See this exact skill in the working simulator.

Watch the real browser product respond to the task on this page, then try the same practical workflow yourself. No slides, concept mockups, install, or credit card.

Try this in the browser
HMI Simulator Online — Build an Operator Screen on a Live PLC

Industrial HMI work in context

See the screen, the tags and the machine behavior together.

An operator display is not a poster. It sits in a control system, writes commands, reads status, exposes alarms and helps a technician decide what to do next. These scenes connect the browser exercises to recognisable plant work.

Industrial HMI touchscreen with motor start and stop controls, running status and emergency stop
01Start with a motor operator panel: separate commands from feedback and keep the emergency stop in the hardwired safety system.
HMI design workstation showing widget properties and tag binding beside a PLC training rack
02Bind each button, lamp and numeric object to the intended PLC tag, data type and read-or-write behavior.
Process tank HMI showing level, valves, pump state, trend and high-level alarm
03A process screen combines scaled measurements, equipment states, trends and alarms so the operator can understand the whole condition.
Conveyor HMI screen with photoeye states, item count and jam alarm beside the conveyor cell
04Discrete-machine screens make sensor state, sequence progress and faults visible without bypassing the PLC interlocks.
Technician diagnosing an HMI pilot-lamp and PLC tag mismatch at a training panel
05When a widget disagrees with the machine, trace the command, tag, PLC logic and feedback instead of assuming the graphic is correct.
Multi-screen industrial HMI project with plant overview, motor detail, alarm summary and faceplate
06Progress from one panel to an overview, detail displays, alarm summary and reusable equipment faceplates.

What it is

What is an HMI simulator?

A Human-Machine Interface (HMI) is the operator panel that lets a person interact with a machine: the touchscreen in a control cabinet showing pump pressures and conveyor status, the pushbuttons and pilot lights on a panel door, the SCADA overview screen in a control room. An HMI simulator lets you build and test those screens without physical hardware, without a real PLC, and without a vendor software license.

This browser HMI simulator goes beyond a drawing tool: the screens run against a JavaScript PLC training engine. When you press a pushbutton widget, the simulated scan reads the input, executes the ladder rung, updates the output, and changes the pilot lamp. That reproduces the core command-and-feedback relationship while remaining distinct from a vendor runtime or commissioned control system.

MOTOR CONTROL PANELRUNNINGO:0/0STARTI:0/0STOPI:0/1Tag: O:0/0Tag: I:0/0Simulated tag binding — widgets read and write training-engine values
An HMI operator panel built in the browser simulator. Pilot lamp and pushbuttons are each bound to a PLC tag address.

How it works

Build, bind and run against a PLC training simulation

The HMI Builder has three modes: Design, Configure, and Run. In Design mode you place widgets on a canvas. In Configure mode you bind each widget to a PLC tag. In Run mode the simulation executes and your widgets respond in real time.

1

Place widgets on the canvas

Drag a pushbutton, pilot lamp, numeric display, or bar graph onto the HMI canvas. Resize and position it. The canvas maps to a fixed screen resolution — the same constraint you face when sizing a real HMI panel.

2

Bind each widget to a PLC tag

Click a widget to open its tag binding panel. Select the PLC memory address — an input bit (I:0/0), an output bit (O:0/0), a timer accumulator (T4:0.ACC), or an integer register (N7:0). The binding tells the HMI where to read or write during run mode.

3

Switch to run mode

The PLC simulation starts executing its scan cycle. Input widgets (pushbuttons) write to PLC input tags. Output widgets (pilot lamps, numeric displays) read from PLC output or internal tags. Press the Start pushbutton and watch the motor-running lamp light up because the ladder seal-in rung energised the output coil.

4

Observe interlock behavior

The interlock logic lives in the PLC ladder — not in the HMI. If the PLC program has a safety interlock that prevents motor start while a door is open, your HMI Start button will be unresponsive even if you press it, because the PLC logic is blocking the output. This is the correct real-world behavior — HMIs command; PLCs decide.

First exercise

Motor start/stop: the first HMI exercise

Every industrial controls curriculum starts with a motor start/stop circuit, and so does the HMI Builder. The PLC simulation runs a ladder seal-in circuit: a Start contact (I:0/0) in parallel with a Hold contact (O:0/0) in series with a Stop contact (I:0/1), driving the Motor coil (O:0/0).

Your task is to build the operator panel: place a green Start pushbutton bound to I:0/0, a red Stop pushbutton bound to I:0/1, and a green pilot lamp bound to O:0/0. Switch to run mode. Press Start — the lamp lights and stays lit because the seal-in branch holds O:0/0 true. Press Stop — the lamp goes dark. This is the correct behaviour of a motor seal-in circuit and you just verified it on a live simulation, not a screenshot.

The short first exercise establishes three concepts used throughout HMI work: a momentary command, a separate status indication, and the separation between what the HMI requests and what the PLC logic permits.

STARTWRITEHMI widgetI:0/0I:0/0= 1 (true)Input tagscanXICLadder rungO:0/0O:0/0= 1 (true)Output tagREADPilot lampHMI widget → PLC tag write → scan → ladder logic → output tag → HMI widget read
Tag binding data flow: a pushbutton widget writes to the PLC input tag, the ladder rung drives the output coil, the pilot lamp reads the output tag.

Why it works

Why practicing on a simulator beats screenshots and videos

Most HMI learning material is a screenshot walkthrough: here is the software, here is a menu, here is a property dialog. Watching those screenshots does not build the muscle memory of binding a tag, debugging a non-responsive widget, or reasoning about why an interlock prevents a start command from reaching the output.

Immediate feedback

When your pilot lamp does not light, you have to debug it. Wrong tag address? Wrong bit number? Interlock blocking the rung? That debugging loop builds the same skill you use on a real panel.

Interlock behavior is live

A screenshot can show you an interlock exists. A running simulation shows you what it feels like when a button press does nothing because the PLC logic says no. That behavioral understanding is what separates competent HMI developers from people who just know the menus.

No vendor lock-in for practice

FactoryTalk View ME requires a Rockwell Automation license and a Windows machine. WinCC requires TIA Portal. Practicing the underlying concepts here costs nothing and prepares you to pick up either tool faster.

What you will learn

Momentary vs latched pushbuttons

A momentary pushbutton writes a true value to its tag only while it is held. A latched/toggle pushbutton flips the tag state on each press. This distinction drives how the PLC ladder must be written — a motor sealed by a latch button needs no seal-in rung; one driven by a momentary button does.

  • Motor start circuit requires momentary + ladder seal-in
  • Alarm reset toggle uses a latched button
  • Jog mode: motor runs only while jog button is held
Purposeful color and state conventions

Color should follow a documented HMI philosophy and support situation awareness instead of decorating every normal state. ISA-101 covers graphics, color, navigation and alarming conventions, but a site must define and apply its own consistent meaning with shape, text and state—not color alone.

  • Reserve high-salience color for conditions that require attention
  • Pair alarm color with text, priority and acknowledgement state
  • Use the same equipment and state conventions on every screen
Interlocks live in the PLC, not the HMI

Safety and permissive interlocks must be enforced in the PLC ladder logic, not in HMI button enable/disable properties. An HMI button can be grayed out as a convenience but must never be the only barrier to an unsafe command. The simulation exercises this: even if you build a Start button, the PLC interlock can block it.

  • Guard door interlock blocks motor start at PLC level
  • Low oil pressure interlock prevents pump start
  • HMI button gray = visual aid only; PLC is the real guard
Tag types and addressing

HMI widgets bind to specific PLC memory locations. Understanding the address space — digital input bits (I:), digital output bits (O:), internal bits (B3:), integers (N7:), timer accumulators (T4:.ACC), counter accumulators (C5:.ACC) — is prerequisite knowledge for building any real HMI screen.

  • Pilot lamp → O:0/0 (digital output bit)
  • Numeric display → T4:0.ACC (timer elapsed)
  • Bar graph → N7:5 (analog value integer)
What you build

These diagrams show what the browser HMI Builder does: the operator panel you assemble, the widget palette you drag from, how each widget binds to a simulated PLC tag, and the analog, alarm and multi-screen features the exercises teach.

HMI operator panel built in the simulator — Start and Stop pushbuttons, a lit running pilot lamp, a numeric readout and a status line on a browser operator screenAn HMI operator panel: a green Start and red Stop pushbutton, a lit running pilot lamp, a numeric pressure readout, and a status line.MOTOR CONTROLRUNNINGSTARTSTOP42PSIStatus: motor running — no faults
The operator panel — pushbuttons, a lit pilot lamp, readout and status line.
HMI Builder widget palette — Button, Lamp, Gauge, Level, Slider, Selector, Trend and Alarm widgets you drag onto the operator screen canvas in the browser simulatorAn HMI builder widget palette of eight drag-and-drop tiles: Button, Lamp, Gauge, Level, Slider, Selector, Trend and Alarm.WIDGET PALETTEdrag onto canvasButtonLampGaugeLevelSliderSelectorTrendAlarm
The widget palette — drag Button, Lamp, Gauge, Level, Slider, Trend and Alarm.
HMI tag binding in the simulator — a pushbutton and pilot lamp widget bound through live PLC tags to a running simulated PLC, writing inputs and reading outputs in real timeAn HMI Start button and run lamp bound through named PLC tags START_PB and RUN_LAMP to a running PLC controller — binding a widget to a live tag.HMI widgetSTARTLAMPlive tagSTART_PBRUN_LAMPPLCrunningwidget ↔ tag ↔ PLC — bound live
Tag binding — each widget connected to a simulated PLC tag it reads or writes.
HMI gauge widget in the simulator — an analog gauge showing a 4.2 bar process value, the analog visualization you bind to a scaled PLC tag in the builderAn analog HMI gauge widget with a sweeping needle on a graduated dial and a numeric readout of 4.2 bar pressure.PRESSURE GAUGE4.2bar010
The gauge widget — an analog process value bound to a scaled tag.
HMI alarm summary in the simulator — critical, high and medium severity alarm rows with state and an acknowledge control, the alarm subsystem the exercises teachAn HMI alarm summary list with severity-ranked rows — critical, high and medium — each showing a message, an active or acknowledged state, and an acknowledge control.ALARM SUMMARY2 activeCRITHigh pressure — vessel 1ACTIVEACKHIGHMotor overload tripACTIVEACKMEDLow level — feed tankACK✓
The alarm summary — severity tiers, state and an acknowledge workflow.
HMI multi-screen navigation in the simulator — an overview screen with nav buttons opening detail screens and a pop-up faceplate, the multi-screen projects the builder supportsAn HMI overview screen with navigation buttons opening detail screens and a pop-up faceplate — multi-screen navigation in an operator application.OVERVIEWLine ALine BAlarmsDETAIL — LINE AFACEPLATE
Multi-screen navigation — overview, detail screens and a pop-up faceplate.
HMI and SCADA architecture — the operator HMI screen sitting above the PLC, reading and writing tags, within a SCADA supervisory layerA SCADA supervisory layer above a PLC, an operator HMI panel beside the PLC, and the PLC wired down to field devices such as sensors and a motor.SCADAsupervisory layerHMI panelPLCcontrollerSMfield devices (sensors, motor)
HMI / SCADA layers — where the operator screen sits above the PLC and its tags.
HMI runtime loop in the simulator — operator input, the PLC scan, the tag update, then the widget reflecting the new value, the live binding cycle behind every widgetThe HMI runtime loop: operator input, the PLC scan, the tag update, then the widget reflecting the new value — the live binding cycle, repeating.1Operator input2PLC scan3Tag update4Widget reflectsLIVEBINDING
The live binding loop — input, scan, tag update, widget reflects the value.
The PLC scan cycle behind the HMI — read inputs, execute the ladder, update outputs, while the HMI continuously reads and writes the same tags between scansThe repeating PLC scan cycle: read inputs, execute the ladder logic, update outputs, then housekeeping, looping continuously.1Read Inputs2Execute Logic3Update Outputs4HousekeepingSCANCYCLE
The scan cycle — the loop that drives every widget the HMI binds to.
Skills that transfer

Common HMI platforms use a related model: screens contain graphic objects, tags connect those objects to data, and runtime logic determines how operators read or change values. Product terminology and implementation details differ, so use this page as concept practice rather than vendor certification.

Concept learned hereFactoryTalk View ME/SEWinCC (TIA Portal)
Tag bindingTag Browser → tag link on each object propertyHMI tag table → process tag connection
Momentary pushbuttonMomentary Pushbutton objectButton with Set Bit on mouse-down, Reset on mouse-up
Pilot lampMulti-state indicator (2-state)Circle / ellipse with tag animation
Numeric displayNumeric display objectI/O field with process tag
Interlock visibilityEnable property linked to tagVisibility / Enable animation on tag
Screen navigationDisplay → Go To Display buttonScreen navigation with Click event

For a deeper bridge into the specific vendor tools, see: FactoryTalk View tutorial, WinCC tutorial, HMI programming concepts, and the PLC vs HMI explainer.

Keep exploring

Questions

HMI simulator FAQ

The first motor start/stop HMI exercise is included with a free account and does not require a credit card. A Pro subscription unlocks the remaining HMI exercises, including process, alarm and multi-screen projects.

Technical review

Primary references for HMI behavior and design

Reviewed 7 August 2026. The simulator teaches transferable concepts; use the exact vendor documentation and your site HMI philosophy for production work.

Build and test your first operator screen.

No install. Start free. A running PLC training engine drives the widget states.

Operator-screen builder field guide

HMI simulator: tag binding, button modes, alarm states and screen testing

Direct answer

An HMI simulator lets you build an operator screen and test it against running control logic before any panel exists. The useful test is not whether the graphic looks right, but whether each button writes the intended tag, each lamp reflects real PLC state, alarms move through acknowledge and clear correctly, and navigation reaches every screen the operator needs.

This guide is written for controls learners, maintenance technicians moving into HMI work and instructors who want operator-screen exercises that fail visibly when a binding, button mode or alarm rule is wrong. The intended result is specific: the learner can bind widgets to the correct tags, choose momentary or latched behavior to suit the PLC logic, set display ranges, define alarms with severity and deadband, and prove the finished screen against a scripted operating sequence.

System map / 02

NODE 01observable

Tag contract

Before placing a widget, write down which tag it reads or writes, its data type and who else writes it. A lamp bound to a status bit, a numeric entry writing an INT setpoint and a selector writing a position index each carry a different contract, and most screen faults are a broken contract rather than a broken graphic.

NODE 02observable

Momentary versus latched

A momentary button holds its tag true only while pressed; a latched button toggles and keeps the value. Start and stop commands are normally momentary because a seal-in rung owns the run memory. The builder stretches a very quick click to a short minimum pulse so the scan cannot miss it, which mirrors why real panels care about pulse width.

NODE 03observable

Command versus feedback

Pressing Start is a request. The running lamp should be bound to evidence that the PLC decided to run, or better to an auxiliary feedback input, not to the button tag itself. Binding a lamp to its own command makes the screen report success even when an interlock blocks the output.

NODE 04observable

Display range and units

Gauges, level bars, sliders and trends take a minimum, maximum and units label. That range only positions the value on the widget; it does not convert raw counts into engineering units. If the PLC tag holds raw data, scale it in logic first, then set the widget range to the real process span.

NODE 05observable

Alarm lifecycle

Each alarm is a condition on a tag, on, off, above or below a limit, with a severity from low to critical and an optional deadband. It moves between normal, active unacknowledged, active acknowledged, cleared unacknowledged and shelved. Acknowledging confirms the operator has seen it; only a cleared and acknowledged alarm leaves the summary.

NODE 06observable

Screen structure

A project can hold several screens. The first is the home screen, navigation buttons either replace the current screen or open a pop-up faceplate, and a button whose target screen has been deleted does nothing. An overview that routes to detail screens and an alarm summary scales better than one crowded panel.

Procedure / 03

  1. 01

    List the operator tasks

    Write what the operator must start, stop, adjust, confirm and respond to, and name the PLC tag behind each action and indication.

    Evidence: Every widget planned for the canvas traces back to a task and a named tag with a stated direction.

    Avoid: Dragging widgets onto the canvas first and hunting for tags afterwards.

  2. 02

    Place and bind in Configure mode

    Add each widget, bind it to its tag, set pushbutton mode, ranges, units and selector positions.

    Evidence: No widget remains unbound, and each binding matches the direction and type on the tag list.

    Avoid: Binding a status lamp to the command tag because the names look similar.

  3. 03

    Run the normal sequence

    Switch to Run mode and operate the screen exactly as the exercise brief describes, one action at a time.

    Evidence: Lamps, numbers and trends change only after the scan updates the tags they read.

    Avoid: Judging success by the button highlight rather than the feedback indication.

  4. 04

    Exercise the interlocks

    Hold a permissive false, such as an overload or guard input, and press the command again.

    Evidence: The command tag changes but the output and running indication stay off, proving the PLC owns the decision.

    Avoid: Disabling the button on screen and calling that the interlock.

  5. 05

    Drive the alarms

    Push each alarm tag across its limit, acknowledge it, clear the condition and repeat in the opposite order.

    Evidence: The summary shows the expected state at every step and the alarm disappears only when both cleared and acknowledged.

    Avoid: Testing only the raise path and never the clear-before-acknowledge path.

  6. 06

    Check the whole project

    Visit every screen from home, open each faceplate, then run the built-in screen check.

    Evidence: Navigation reaches every screen and the grader reports each requirement row as passed.

    Avoid: Leaving an orphaned screen or an inert navigation button in the finished project.

Diagnostic matrix / 04

Diagnostic symptoms, inspection points, interpretations and next actions for HMI simulator: tag binding, button modes, alarm states and screen testing
Observed symptomInspectInterpretationNext proving action
Lamp never lights in Run modeWidget binding, tag spelling, the scenario tag list and whether any logic writes that tagAn unbound lamp, a lamp bound to an input nobody drives or a rung that never goes true all look identical on screen.Bind a spare lamp to the upstream command tag; if the command changes but the status never does, the fault is in logic or a permissive, not the widget.
Motor stops when Start is releasedPushbutton mode, seal-in branch and the tag the holding contact usesA momentary button needs a seal-in rung; without one the output follows the button and drops as soon as the pulse ends.Add or repair the seal-in in logic rather than switching the button to latched.
Latched button snaps back after one scanOther writers of the same tag, especially an output coil or reset rung in the PLC programTwo owners are writing one tag and the PLC scan wins, so the HMI write is overwritten on the next pass.Give the HMI its own request tag and let logic decide the resulting state.
Alarm stays in the summary after the fault clearsAlarm state, acknowledgement history and whether the condition has truly returned to normalCleared but unacknowledged is a deliberate state: the operator has not confirmed seeing the event, so it stays listed.Acknowledge it; if it still remains, check the limit and deadband against the live value.
Gauge pinned at full scale or near zeroWidget minimum and maximum, the tag units and the range of values the PLC actually writesA raw count shown on a 0 to 100 widget, or a percentage on a 0 to 1,000 widget, gives a misleading picture without any error.Scale the value in logic and set the widget range to the real process span.
Display frozen while the process should be movingRun mode status, the bound tag, and whether the value is written only by logic that is currently idleThe simulator does not model communication loss or tag quality, so a frozen value here means a binding or logic issue, not a dropped link.Confirm Run mode, then trace the writer of the tag; on a real HMI, also check quality and driver diagnostics.

Product evidence / 05

What the browser practice can actually demonstrate

The HMI Builder places pushbuttons, lamps, numeric displays and entries, gauges, level bars, sliders, selectors, trends, alarm banners, alarm summaries and navigation buttons on a canvas, then runs them against the simulated PLC scan. Exercise grading first checks that required widgets exist with the right tag and button mode, then runs the exercise program on a fresh engine and executes a check sequence.

Answer surface / 07

What is the best way to practice HMI design without a panel?

Build a screen against running logic and try to break it. Bind commands and feedback to separate tags, block an interlock, push alarms across limits and navigate every screen. A drawing tool or screenshot course cannot show you a button that writes the right tag while the PLC refuses to act.

Should an HMI start button be momentary or latched?

Momentary in most motor circuits. The PLC holds the running state through a seal-in or latch, and a stop press breaks it. A latched start button would leave the command true after a stop or trip, which can cause an unexpected restart. Use latched buttons for deliberate operator toggles the logic reads directly.

What is the difference between acknowledging and resetting an alarm?

Acknowledging records that an operator has seen the alarm; it does not remove the cause. Resetting is a separate machine action, usually a PLC command, that clears a latched fault after the cause is gone. In this builder, an alarm leaves the summary only once its condition has cleared and it has been acknowledged.

Why does my HMI value look wrong even though the tag is correct?

The widget range or units usually disagree with what the tag holds. A gauge set to 0 to 100 will sit at full scale if the PLC writes raw input counts. Check the scaling in logic, then set the widget minimum, maximum and units to the real engineering range.

Can an HMI button be used as a safety interlock?

No. Hiding or disabling a button is a convenience only, because other screens, clients or a fault can still write the tag. Permissives must be enforced in PLC logic, and emergency stop and other safety functions belong in the hardwired or safety-rated system defined by the risk assessment.

Does this simulator model tag quality or communication loss?

No. Widgets read and write tags inside the browser training engine, so there is no driver, network or quality flag to fail. On a production HMI you should also design stale-value indication and test what the screen shows when communication drops, using the target product documentation.

Can I set up operator log-in levels in the HMI Builder?

No user roles or passwords are modeled. Treat access control as a requirement to specify and test in the target HMI product. In practice sessions, focus on the PLC side: validate every written setpoint in logic so a wrong value is rejected whoever enters it.

Will these screens import into FactoryTalk View or WinCC?

No. Projects stay in the browser builder. The transferable part is the method: a tag list, command and feedback separation, button modes, alarm rules and navigation structure. Rebuild the screen in the vendor software and repeat the same tests there before any commissioning.