Connect an HMI panel to a microcontroller over Modbus RTU

First check who starts the conversation

Modbus RTU allows exactly one master on the wire. The panel is the master: it starts every transaction. The microcontroller is the slave, at one address in the 1 to 247 range the specification defines. Two devices configured as masters sit waiting for a request that never arrives; two slaves never transmit first. Before writing code, open the panel project and confirm that the serial connection you plan to use is set to the RTU protocol in the master role, and note whether that port is RS-485 or RS-232. The panel-side settings are the same ones you enter when you connect a PC HMI to a PLC over a serial protocol or Ethernet.

Serial settings both ends must share

The RTU default in the Modbus over Serial Line specification is 19200 baud, 8 data bits, even parity, 1 stop bit. A character is 11 bits long: 1 start bit, 8 data bits, 1 parity bit, 1 stop bit. Program the microcontroller's UART for that same 11-bit format and set its slave address to match the panel project.

On RS-485, wire A to A and B to B, terminate both cable ends with 120 Ω resistors (the characteristic impedance of twisted-pair data cable) and fit bias resistors so the idle line rests at a defined level. RS-232 suits a point-to-point link at the common planning distance of about 15 m. If the panel reports no reply or address errors once wiring is done, the fault table in Modbus RTU master no reply and address errors lists the causes in the order to check them.

Frame timing: silence separates the frames

The Modbus over Serial Line specification separates RTU frames with silence: at least 3.5 character times of idle line between frames, and at most 1.5 character times between characters inside one frame. At the 19200 baud line rate one character takes 11 / 19200 = 0.573 ms, so the frame gap is 3.5 × 0.573 = 2.0 ms and the inter-character limit is 0.86 ms. Above that rate the specification fixes the two timers at 750 µs and 1.75 ms.

/* Illustrative constants at the line rate; pick values at or above the spec minima. */
static const uint32_t t1_5_us = 900u;  /* spec minimum 859 us */
static const uint32_t t3_5_us = 3000u; /* spec minimum 2005 us */

Restart the idle timer on every received byte and treat its expiry as the frame boundary; the margin above the 2005 µs minimum absorbs timer jitter. A frequent firmware bug is restarting the timer once per frame or servicing it in a slow main loop, which merges two frames into one; the notes on the t3.5 silent-interval timer restart issue describe that failure and the fix. Assemble the reply only after the gap confirms the request is complete.

Map the registers before writing code

Give every panel object one holding register and write down access and range. That table is the contract both ends follow:

Expose read-only registers first and check them on the bench; add writable registers only afterwards. Gate every write through the same validity and interlock checks the machine firmware applies locally; a panel write must never bypass them. Keep the table with the panel project so a later change updates both ends at once.

Implement the RTU slave in C

1. Configure the UART for the agreed 8E1 11-bit format at the line rate, and enable an idle-line interrupt or timestamp every received byte.
2. Collect bytes into a frame buffer of 256 bytes, the maximum frame the specification allows. If the buffer fills mid-frame, discard the whole frame, return to idle and wait for the next 3.5-character gap; never parse a partial frame.
3. When the idle gap fires, check the address byte against yours, verify the CRC-16 that RTU framing uses, then dispatch: function 03 reads holding registers, 06 writes one, 16 (hex 10) writes several.
4. Answer every valid request, and reject invalid ones with an exception frame: your address, the function code with the high bit set, an exception code such as 02 for an address outside the map, and a fresh CRC. A silent slave is exactly what the panel reports as a timeout.
5. Start from an existing open-source RTU slave library for framing and CRC and port its transport to your UART; the state machine is where most bench hours go.
6. Set the panel's response timeout explicitly; with a 100 ms poll cycle, a 500 ms timeout gives the microcontroller room.

Worked example: one poll cycle

Scenario: the panel reads measured speed and status bits (function 03, start address 1, quantity 2) from slave 1 every 100 ms, at the line rate with 8E1.

• Request frame: 1 address byte + 1 function byte + 2 start-address bytes + 2 quantity bytes + 2 CRC bytes = 8 bytes. At 11 bits per character: 8 × 11 = 88 bits; 88 / 19200 bps = 4.6 ms on the wire.
• Response frame: 1 address + 1 function + 1 byte-count byte (04 hex for 4 data bytes) + 2 × 2 data bytes + 2 CRC = 10 bytes; 110 bits; 110 / 19200 = 5.7 ms.
• Silence: 2.0 ms before the request and 2.0 ms after the response, since every frame needs the 3.5-character gap on both sides.
• Minimum cycle: 4.6 + 5.7 + 4.0 = 14.3 ms.

A 100 ms poll therefore occupies 14.3 / 100 = about 14 percent of the bus and leaves room for other slaves. For counters that move slowly, poll every 1000 ms and the load drops to 14.3 / 1000 = about 1.4 percent.

How to check it worked

1. Add holding register 5 as a test value, hold 12345 in it in the firmware, and confirm the panel screen shows 12345.
2. Write 7 to the speed setpoint from the panel keypad; confirm the firmware variable becomes 7 and reads back through register 0.
3. Set the panel's slave address to 2 and confirm it reports no reply; restore address 1.
4. Pull one RS-485 wire and confirm the panel raises a communication error instead of presenting stale numbers as current; reconnect.
5. Power-cycle the microcontroller and confirm the panel starts polling again on its own; the panel side of that recovery is the subject of make a Modbus master reconnect after a slave outage.
6. Only now connect real machine values: reads first, writes last, with the interlocks in place.

When a panel and controller both have a network port, the same slave pattern carries over on Ethernet; the register side of that arrangement is shown in Arduino Mega as a Modbus TCP slave with analog and PWM I/O.

Recommendation: run the panel as the only RTU master at the specification default rate of 19200 baud 8E1 over RS-485 with 120 Ω termination at both cable ends; give the microcontroller slave address 1 and implement functions 03, 06 and 16 only; poll every 100 ms while tuning and every 500 to 1000 ms once the values read back steadily. Add writable registers only after the bench test passes, with the firmware's own interlocks behind every write.

Questions