IMDTouchKnowledge BaseShop main store

How-to

Running One HMI Interface on Multiple Touchscreens From One PC

Panel PCs and displays Published 7 min read

Short answer

One computer can drive four touchscreens without four copies of the interface. Put data and commands in one controller, give every screen its own display instance that subscribes to published state and submits commands to one handler, and verify display outputs and touch mapping per screen before you build any views.

On this page
  1. Decide what each screen must do
  2. Verify display outputs and touch mapping first
  3. Sizing the graphics output for four 1920 x 1080 touch screens at 60 Hz
  4. Keep one owner of data and commands
  5. Wire the update and command paths
  6. Build the fourth screen from the same instances
  7. Questions asked

Do not build a fourth interface that copies the other three. Put the data and the commands in one controller, give every touchscreen its own display instance that renders published state and sends operator commands back to that controller, and the combined fourth screen becomes just another subscriber: the complete first view plus whatever indicators you select from the second and third, all fed by one acquisition path. Before you build any view, verify the display side — that the PC drives every screen at the working resolution, that each touch digitizer is mapped to its own screen, and that updates reach every screen through one path. Get those three checks right first, and four synchronized screens cost one acquisition path instead of four.

Decide what each screen must do #

A combined screen mixes three requirements that are easy to blur:

  • Composition — which controls appear where: the complete first interface, plus selected indicators and controls from the second and third.
  • State — which values appear: every screen shows the controller's published state, never a private copy of the measurement.
  • Commands — which actions run: a touch on any screen must request the same application action as its counterpart on the original screen.

Identical behavior means identical command meaning and one authoritative state value, not identical control objects. A button on the fourth screen requests the same start action; it does not pretend the button on screen 2 was physically pressed. Before writing any view, list every value and action that appears on more than one screen, confirm each has a single owning controller operation, and note which screens present it. That list becomes the test plan for the whole setup.

Verify display outputs and touch mapping first #

Work through the display side before opening the development environment:

  1. Connect every screen and set the desktop to extend mode, not duplicate, then run the identify function and write down which physical screen each video output feeds.
  2. Run the built-in touch setup that asks you to touch each display in turn, so every touch digitizer is mapped to its own screen; repeat it after any screen swap, renumber or re-cable.
  3. Calibrate the screen you just mapped before moving to the next one.
  4. Open a test window with a known target on each screen and press it; the press must land on the screen you touched, and only there.
  5. Record the graphics path — which outputs run on integrated graphics and which on an add-in card — because the sizing check below needs it.

Touch digitizers connect separately from the display signal, normally over USB, so they add nothing to the graphics load. If video reaches a screen but touch does not register at all, that is a device and driver fault rather than a mapping one; the failure pattern matches Why HDMI Video Works but USB Touch Does Not on a Panel.

Sizing the graphics output for four 1920 x 1080 touch screens at 60 Hz #

The inputs: four screens, the setup in question; 1920 x 1080 pixels each, the full HD resolution carried by the multi-touch displays on current industrial panel PCs; a 60 Hz refresh rate, the common desktop rate, taken here as a stated assumption; and 32-bit color, four bytes per pixel, for the bandwidth line.

The rule in words: required pixel throughput equals the number of screens times the width times the height times the refresh rate.

The arithmetic:

  • 1920 px x 1080 px = 2,073,600 px per frame on one screen
  • 2,073,600 px x 60 frames/s = 124,416,000 px/s on one screen
  • 124,416,000 px/s x 4 screens = 497,664,000 px/s, about 498 Mpixels/s
  • 497,664,000 px/s x 4 bytes/px = 1,990,656,000 bytes/s, about 1.99 GB/s of frame data at 32-bit color

Result: four full HD screens at 60 Hz need about 498 Mpixels/s of simultaneous graphics output, roughly 2 GB/s of frame data at 32-bit color.

Decision: size the graphics against about 500 Mpixels/s of simultaneous output. Read the specification's multi-display pixel rate, not its single-display rating; if the aggregate demand exceeds what the graphics sustain with every output live, screens drop to a lower mode or the desktop stutters. The number moves linearly with its inputs: the same four screens at 30 Hz need about 249 Mpixels/s, and four 1280 x 800 screens at 60 Hz need about 246 Mpixels/s. If the computer you have cannot make that number with all outputs in use, that is the point to specify industrial panel PCs rated for simultaneous multi-display output at your working resolution instead of stretching a desktop tower past its graphics limit.

Keep one owner of data and commands #

The module that already talks to the device and holds your communications state stays the single boundary between the application and the screens. It accepts commands, coordinates acquisition and control, and publishes state. Every display instance renders that state and reports operator intent; none of them reads the device itself. Do not add a second acquisition path because a second indicator shows the same measurement.

That boundary is what makes faults readable. Compare what each screen shows against the controller's published value, and the failure separates cleanly:

What you see Boundary to inspect Deciding check
The original screen updates; its copy on the fourth screen does not That view's registration and payload mapping Confirm both views receive the same controller update
Both screens show the same wrong value Controller state or upstream acquisition Compare the published value against the acquired value
A duplicated button changes its appearance but does nothing That view's event-to-command mapping Trace the command from the view into the common handler
One touch fires the action twice A duplicate command path Count command submissions against handler executions
A newly opened screen stays blank until the next change Initial-state delivery Confirm the view requests a snapshot after registering

The same arrangement runs at plant scale: a PLC-hosted visualization served to remote HMI panel PCs keeps the program and tags in one place while each operator panel subscribes as a client. Your fourth screen is that same client arrangement inside one computer.

One limit does not scale with the screen count: a command any of four screens can issue is still only an operator request. Keep emergency stop and guard interlocking hardwired to the machine, so no mapping fault, hung view or lost display can take their place.

Wire the update and command paths #

Every HMI development environment has some form of broadcast update — user events, message queues or a publish-and-subscribe tag mechanism. Whichever yours uses, three rules keep four screens synchronized:

  1. The controller creates and owns the update mechanism and hands each display instance what it needs to subscribe when it launches.
  2. Each screen registers separately for the updates it uses. One shared queue makes screens steal updates from each other; separate registrations give every view its own copy of each update.
  3. A view registers first, then requests a snapshot of the current state. Registration alone delivers only future changes, so a screen opened mid-run stays blank until the next update unless it asks for that snapshot.

One combined state message is simplest while the screens share most of their data. Split into separate update streams when one screen needs a fast, small payload that another does not, so each subscriber processes only what it displays. If point updates crawl after the fourth screen joins, the update path is the limit, not the screen; the causes and fixes line up with Why HMI point updates run slow on an Ethernet PLC link.

Commands run the same shape in reverse. A touch produces one command request with its data; the controller executes the application action once and publishes the resulting state; every screen updates its controls from that published state without issuing a second command. Do not programmatically trigger the counterpart control to keep its event case alive — that builds a second command path, and the double-fire row in the table above is what it looks like a month later.

Build the fourth screen from the same instances #

Compose the fourth screen from instances of the views the other screens already run. The complete first interface is one instance placed on the larger panel; the selected indicators from the second and third screens are instances of those same views. Because each one is a subscriber rather than a copy, editing the first interface once updates every place it appears, including the fourth screen — there is no separate fourth-screen version to maintain.

Two points keep the composition honest:

  • A view container organizes layout; it does not merge several screens into one synchronized object by itself. Place each instance in its own region and let published state fill it.
  • Every control on the fourth screen submits the same command as its counterpart, and control appearance follows published state on all screens alike.

Work in this order: verify outputs and touch mapping, size the graphics path, stand up the controller's publish path with one screen, add the second and third as subscribers, and compose the fourth last. Done this way, the fourth screen is the cheapest one in the set — and the fifth costs only another subscription.

Questions asked

How many touchscreens can one PC run at once?

As many as its graphics outputs can drive simultaneously; the touch function does not change that number. The binding limits are the physical connectors and the aggregate pixel rate across all outputs. Check the specification for simultaneous multi-display operation at your resolution and refresh rate rather than the single-display figure, and treat an added display adapter as something to verify against those same limits, not a default.

Why does touching one screen move the pointer on another?

The touch digitizer and the display are separate devices, and the operating system has that digitizer mapped to the wrong output. Video reaching every screen proves nothing about touch routing. Re-run the built-in setup that asks you to touch each display in turn, then calibrate the screen again, because both the mapping and the calibration belong to one specific display.

Is a mirrored screen the same as a synchronized second view?

No. Duplicate or clone mode repeats one desktop image, so both screens show identical content and share a single pointer; you cannot run a different view or a combined screen that way. Use an extended desktop with a separate window on each screen, and keep the views synchronized through the controller's published state rather than through the image.

Does a fourth screen add load to the controller?

It adds a subscriber, not a second acquisition path. The controller's work grows with payload size times the number of screens receiving it, while acquisition still runs once. If points update slowly after a screen joins, shorten the payload, lower the update rate for views that do not need full speed, or split the update streams so no screen processes data it never shows.

Keep reading

  • Selection guide

    Choosing a Panel PC With PRP Network Redundancy Support

    A Panel PC joins a PRP network only through a documented PRP interface, normally an add-on card in a verified expansion slot, or by sitting behind a RedBox. Two onboard Ethernet ports prove nothing. Confirm the exact computer, slot, card, driver and operating-system combination in writing before ordering, or route the panel through a RedBox.

    Panel PCs and displays

  • Troubleshooting

    Fixing startup splash screen errors on legacy panel PCs

    Corrupted splash screens at power-up on a legacy panel PC come from two graphics-heavy programs initializing in the same boot window. Keep the HMI runtime shortcut in the Startup folder, move the remote-access utility to the desktop, and launch it by hand once the runtime has painted. Then verify flash-disk free space and RAM headroom before trusting the unit in production.

    Panel PCs and displays

  • Troubleshooting

    Why HDMI Video Works but USB Touch Does Not on a Panel

    A stable HDMI image with dead touch is a USB-path fault. Power the panel from its own supply or an externally powered hub, confirm the host enumerates a supported touch controller family, set the visualization to TargetVisu, and treat misplaced touches as a coordinate-mapping error rather than a touch failure.

    Panel PCs and displays