HMI-Compatible Controllers: Connecting MPINO to Touch Panels via Modbus RTU and I²C

Modbus RTU: The Common Language Between MPINO and HMI

Virtually every industrial HMI and touch panel on the market speaks Modbus RTU, and MPINO controllers implement it natively through the ILIB library. The controller acts as a Modbus RTU server (slave): discrete inputs and coils carry digital I/O state, while input registers and holding registers carry analog readings, NTC temperatures, setpoints, and any process value your Arduino IDE program chooses to expose.

Because the mapping is defined in firmware, you decide exactly which internal variable lands at which register address. A tank level scaled from a 4-20mA input, a calculated flow rate, a run-hours counter, and an alarm word can all be placed at clean, documented addresses that the HMI screen designer references directly. This eliminates the bespoke serial protocols that often lock a controller to a single panel vendor; any Modbus-capable HMI can drive an MPINO.

RS-485 Multidrop and Model Communication Options

RS-485 is the physical backbone for HMI connectivity because it supports long cable runs and multidrop wiring. The MPINO-8A8R-S, MPINO-8A8T-S and MPINO-16A16R provide RS-485, ideal for connecting one or several controllers to a panel over a single twisted pair. The ATmega2560-based MPINO-8A8R, MPINO-16A8R and MPINO-16A8R8T go further with RS-232 + RS-485 + UART simultaneously, allowing, for example, an RS-485 link to the HMI while RS-232 or UART serves a local programming port, a printer, or a second device.

The RS-232-equipped MPINO-8A4R-S and MPINO-8A4T-S suit point-to-point connections to a single panel or PC-based HMI. Across all variants, the consistent ILIB Modbus implementation means the HMI integration effort you invest on one model carries directly to the others, and a multidrop RS-485 segment can host several MPINO controllers each answering on its own Modbus address.

I²C for Local Displays and Co-Processors

Not every operator interface needs a full touch panel. Every MPINO controller also exposes an I²C bus, well suited to a compact local display, a character or graphic LCD, or a co-processor that aggregates several boards. Over I²C the same live I/O and process values are available to nearby devices with minimal wiring, making it a practical choice for a small status display mounted directly on the machine.

Used together, the two interfaces cover the full span of operator interaction: RS-485 Modbus RTU links the controller to the main HMI or SCADA layer for full visualization and supervisory control, while I²C drives an at-the-machine indicator for local status. Both draw from the same firmware I/O image, so the value an operator sees on a local LCD always agrees with what the central HMI displays.

The I²C bus is also a clean path to expansion peripherals. A real-time clock for timestamping, an EEPROM for retentive recipe storage, or a port expander for extra indicator lamps can sit on the same two-wire bus the MPINO already drives, all addressed and serviced inside the Arduino IDE program. This keeps a local operator station self-contained on one controller without adding serial ports or external modules.

Designing a Reliable HMI Integration

A dependable HMI integration starts with a documented register map. Define your Modbus address layout in the Arduino IDE program, keep digital state in discrete/coil space and scaled analog values in register space, and record the engineering scaling so the HMI displays correct units. Group related tags into contiguous blocks so the panel can read them in efficient bulk polls rather than many single-register requests.

On the physical layer, terminate the RS-485 segment correctly, observe consistent A/B polarity, and assign each controller a unique Modbus slave address on a multidrop bus. Because the controller logic runs deterministically on the ATmega processor independent of the HMI poll, the machine keeps operating safely even if the panel disconnects: the HMI is a window onto the process, not a single point of failure for control. This separation of local control from visualization is a core strength of building the operator interface on the MPINO platform.