IMDHMIControls LibraryShop main store

Troubleshooting

Why Modbus RTU drive polling on one serial port is slow

Industrial networks Published 9 min read

Short answer

Modbus RTU carries one request-response transaction at a time, and at 19.2 kbit/s each drive transaction costs 40-60 ms, so 18 drives polled with a read and a write each need about 1.5-2.5 s per cycle no matter how the messages are chained. Cut the transaction count, schedule command writes ahead of status reads, set each drive's communication-loss timeout above the finished cycle, and change networks when the arithmetic cannot meet the update rate.

On this page
  1. Why does one Modbus RTU port poll 18 drives so slowly?
  2. How much time does one Modbus RTU transaction take at 19.2 kbit/s?
  3. How long is the full polling cycle for 36 drive messages?
  4. Why is the HMI screen still slow when the drive polling works?
  5. Which drive settings turn a missed poll into a stopped conveyor?
  6. What can I cut or reschedule to make the polling cycle fit?
  7. When is one serial port the wrong answer for 18 drives?
  8. Questions asked

Modbus RTU is slow to a rack of drives by design, not by fault: the protocol permits exactly one outstanding request-response transaction on the wire, and at 19.2 kbit/s a transaction with a drive costs 40-60 ms. Eighteen drives polled with one read and one write each — 36 transactions — therefore need about 1.5-2.5 s per cycle no matter how the messages are chained, cascaded or buffered. This article gives you the arithmetic to size that cycle, the checks that separate a wiring or configuration fault from plain capacity, and the decisions: what to cut, how to schedule, and when the serial port is simply the wrong network.

Why does one Modbus RTU port poll 18 drives so slowly? #

Because Modbus RTU completes one request-response transaction at a time: the master sends a request, the addressed drive answers it, and only then may the next request leave the port, so an eighteen-drive network runs at transaction speed, not bit rate.

The Modbus serial-line specification defines a single master and slaves that speak only when addressed, and a master that launches the next request before the current one completes or times out breaks that turn-taking — on a shared RS-485 segment the overlapping frames corrupt each other. The message-buffer count inside the controller never changes throughput: buffers decide how many requests may wait, and the wire serves them one at a time, whether the 36 messages run as four cascading groups or as one completion-driven chain.

RTU framing wastes as little as serial framing can: each data byte rides in one 8-bit character, about twice the payload rate of Modbus ASCII, which sends every byte as two characters plus frame markers. That is why RTU is the default on drive ports, and why no framing change rescues a transaction-limited cycle — the arithmetic in the next section fixes the pace.

How much time does one Modbus RTU transaction take at 19.2 kbit/s? #

Budget 40-60 ms per drive transaction at 19.2 kbit/s: about 16 ms of that is wire time for a typical four-register exchange, and the remainder is drive turnaround, converter processing and master overhead in the path.

The wire-time half follows from the Modbus serial-line framing rules. RTU sends frames as 8-bit characters, and the specification's default character format — one start bit, eight data bits, even parity, one stop bit — makes 11 bits per character. At 19.2 kbit/s that is 11 / 19,200 = 0.573 ms per character.

The same specification requires a silent gap of at least 3.5 character times before and after every frame, so each transaction carries 2 x 3.5 x 0.573 = 4.01 ms of forced silence.

A read of four holding registers (function 03) is 8 bytes out and 13 bytes back: 21 x 0.573 = 12.03 ms, plus the 4.01 ms of silence, for 16.04 ms of wire time. A four-register write (function 16) is the same 21 characters in the other direction — 13 out, 8 back — so 16 ms is the wire floor either way.

Everything above the floor is device time. A drive samples its serial port between drive-control cycles, and a converter in the path adds its own store-and-forward: one documented unit, the 22-SCM-232, performs both RS-232-to-RS-485 electrical conversion and DF1-to-Modbus RTU protocol conversion per its manual (22COMM-UM002), so it queues and processes frames in both directions like the small protocol computer it is. Drive turnaround, converter delay and master overhead together turn the 16 ms wire floor into that planning budget, and any retry bills its full cost a second time.

How long is the full polling cycle for 36 drive messages? #

Multiply, and the answer is fixed: thirty-six transactions at the per-transaction budget take 1.44-2.16 s of serial time, so one full pass over eighteen drives lands near 1.5-2.5 s per cycle once gaps and retries are added.

Worked example — planning arithmetic, not a measurement:

  • 18 drives x (1 status read + 1 command-and-reference write) = 36 transactions per cycle.
  • At the light end of the budget: 36 x 40 ms = 1,440 ms = 1.44 s.
  • At the heavy end: 36 x 60 ms = 2,160 ms = 2.16 s.
  • With scheduler gaps and the occasional retry, plan on 1.5-2.5 s per cycle.

Two consequences follow. Each drive's data is at most one cycle old, so a status value on any screen can be 1.5-2.5 s stale while the network works perfectly. And no arrangement of the 36 messages — four cascading groups, one long chain, half the buffers — moves either total, because the total is transaction count times per-transaction cost.

Benchmark a measurement against the floor. A cycle timing 4.0 s for 36 transactions works out at 4,000 ms / 36 = 111 ms per transaction, about 9 completed exchanges per second — nearly double the heavy budget — which points at converter turnaround, retries or a competing poller, not at the bit rate. Time one cycle by timestamping the first request and the last completion; that number, not the screen, is the drive cycle.

Why is the HMI screen still slow when the drive polling works? #

Treat screen refresh and the drive cycle as two separate delays: the HMI competes for the same controller's communication handling over its own link, so a four-second screen update and a two-second drive cycle can coexist and must be timed separately.

Both paths land in one controller: separate serial ports do not bring separate communication processors, and the message buffers, the scan and the communication service are shared. The HMI's poll list, update intervals and link speed set the screen time; the 36-transaction queue sets the drive time. Split the two on the bench:

  • Time one full drive cycle, first request to last completion, with the HMI polling normally.
  • Pause the HMI's polling and time the cycle again; the difference is the HMI's share.
  • Check for any other direct poller on the same serial network — a data logger, a second client — because every direct poll joins the same single queue.

Stale screens, partial updates and question-mark values are one disease seen from the operator's chair; the timeout mechanics behind them are covered in why HMI values show question marks.

Which drive settings turn a missed poll into a stopped conveyor? #

Two settings decide it: the parameter that assigns the serial port as the command source, and the communication-loss timeout, which must sit above your finished cycle time or a healthy drive trips while it waits its turn in the queue.

Configuration faults mimic congestion and survive every polling optimization, so clear them first:

  • Command source. A drive whose command source still points at its terminals ignores every serial write. On the PowerFlex 4 family the manual (22A-UM001L) specifies P036 = 5 for RS-485 command control; check the speed-reference source separately, so a drive that starts from the network is not still taking its reference from a potentiometer.
  • Register addressing. The same manual's appendix lists Logic Command at 8192 or 8193 depending on zero-based or one-based addressing. Enter the address in the convention your message instruction expects, or the drive reads correctly and silently drops commands.
  • Communication loss. Every drive defines an action for stopped updates — stop, hold last state, or trip — under a timeout. Set that timeout above twice the worst-case cycle: with a 2.16 s heavy-case cycle, a 5 s class timeout, where the drive's documented range allows it, keeps one skipped or retried write from tripping a healthy drive.

A communication-loss stop is a protective function: keep it enabled and inside the drive's documented settings, and repair an unreliable network instead of loosening the safeguard that masks it.

Then verify the physical layer once: unique node addresses, identical serial format on every node, RS-485 termination at both cable ends, correct polarity, and communication error counters at or near zero. Retries quietly absorb a marginal network while eating the cycle's useful capacity — fix the wire before tuning the schedule.

What can I cut or reschedule to make the polling cycle fit? #

Cut transactions before touching hardware: remove reads nobody acts on, write changed commands ahead of status reads, and keep one outstanding transaction per port, because buffer counts limit what waits in the controller, not what the wire carries.

In priority order:

  1. List every transaction — destination drive, read or write, register count, and the update interval the process actually needs.
  2. Delete cyclic reads that no logic and no screen act on, and make diagnostics reads on-demand. Dropping 6 of 36 transactions returns 240-360 ms to every cycle.
  3. Schedule a pending operator command into the next open slot instead of behind a full pass of status reads; a transaction already on the wire finishes or times out first, because serial cannot be preempted.
  4. Keep command writes periodic even when nothing changed, at whatever interval each drive's communication-loss setting requires.
  5. Make the scheduler fail forward: bounded retries, then mark that drive's data stale with a timestamp and advance, so one dead node cannot stall the other seventeen.
  6. Batch where the register map allows — a multi-register write covering adjacent command and reference words replaces two writes, and each transaction removed returns its full per-transaction cost.
  7. Split drives across a second serial port if one exists, after checking the controller's documentation for message buffers shared between ports.

When is one serial port the wrong answer for 18 drives? #

Divide your required update interval by the per-transaction budget: needing every drive refreshed faster than about 1.4 s for 36 transactions defeats any sequencing on one 19.2 kbit/s port, because the wire alone needs 577 ms even with zero turnaround.

Run the division test, transactions allowed = required cycle / per-transaction budget:

  • A 1.0 s requirement: 1,000 ms / 40 ms = 25 transactions, fewer than the 36 needed — one port fails.
  • A 1.5 s requirement at a 50 ms midpoint: 1,500 ms / 50 ms = 30 transactions — trim to 30 or change the network.
  • A 2.5 s requirement at the heavy budget: 2,500 ms / 60 ms = 41 transactions — passes with margin.

The absolute floor seals the extremes: 36 x 16.04 ms = 577 ms of pure wire time at 19.2 kbit/s, so any requirement below roughly 0.6 s per cycle is unreachable on this port regardless of tuning.

The decisions, case by case:

  • Requirement 2.5 s or slower per full cycle: one 19.2 kbit/s RTU port is adequate — apply the cuts and scheduling above and measure the result.
  • Requirement between 1 and 2.5 s: serial holds only if the transaction count comes down to the division-test number; read status every other cycle per drive and write on change plus a loss-timeout refresh.
  • Requirement faster than 1 s across all 18: move the traffic. Splitting over two serial ports lands near 720 ms-1.08 s per port, still short of a sub-second target, so the drives belong on a native industrial network with cycle times in the tens of milliseconds; starting and stopping a PowerFlex 700 over EtherNet/IP from CompactLogix shows what that handoff looks like from the PLC side.

If the process tolerates 2.5 s, keep the serial port and spend nothing; if it needs half a second, no serial plan gets there.

Questions asked

Does raising the baud rate fix slow drive polling?

Baud cuts only the wire-time share. At 19.2 kbit/s a transaction carries about 16 ms of wire inside the 40-60 ms budget, and six times the baud rate removes roughly 13 ms of that while leaving turnaround, converter processing and master overhead untouched, so expect a 20-35 percent cut, not a sixfold one. Confirm every drive's documented maximum rate before changing the port, and note that above 19,200 bit/s the Modbus serial-line specification fixes the silent interval at 1.75 ms instead of 3.5 character times.

How many drives can one Modbus RTU serial port serve?

Addressing is not the limit; the protocol allows slave addresses up to 247. Throughput decides. Divide the cycle budget by the per-transaction cost: a 2 s cycle at 40-60 ms per transaction fits 33-50 transactions, which is 16-25 drives polled with a read and a write each. Read status every other cycle per drive and the same port serves more drives at the same latency.

Can I batch registers to cut the transaction count?

Batch wherever the drive's register map allows it. One multi-register read covering a block of adjacent status words replaces several single reads, and one multi-register write covering adjacent command and reference words replaces two writes; each transaction removed saves its full per-transaction cost. Modbus cannot span non-adjacent registers in one message, so separated command and reference registers stay as separate writes. Confirm adjacency in that drive's manual before reordering the cycle.

Does a second serial port double the polling speed?

It divides the queue, not the physics. Thirty-six transactions split 18 and 18 run at 720 ms to 1.08 s per port instead of 1.44-2.16 s on one port. Controllers commonly share message buffers and communication service across ports, so the measured gain usually lands short of a perfect half; check the controller's documentation for shared buffer counts before promising the halving.

What timeout should each Modbus transaction carry?

Set each transaction timeout well above the 40-60 ms expectation: 250-500 ms is a workable band, four to eight times the budget. That absorbs slow converter turnaround yet costs less than half a second when a node dies, after which the scheduler retries once or twice, marks the drive's data stale, and moves on. A completion-driven chain with no timeout stalls permanently on the first unanswered drive.

Keep reading

  • How-to

    How a PLC runs two Modbus networks at the same time

    Yes. Each serial port is its own independent link: the HMI polls the PLC on one port while the PLC acts as master, or slave, on a separate RS-485 Modbus RTU network. The two links share no settings — only their endpoints must match — and PLC copy logic moves any data between them.

    Industrial networks

  • Selection guide

    Choosing PLC to SCADA communication over long distances

    For PLC-to-SCADA communication over long distance, choose the transport by reach and connection behavior: fiber Ethernet for a continuous long link (one span rated 2 km), RS-485 where serial fits, extenders or radio on existing pairs, dial-up or leased-line modems on phone service. Direct copper Ethernet fails at 100 m per segment; the SCADA driver or OPC service, not the PLC's ASCII modem commands, carries the protocol.

    Industrial networks

  • How-to

    Control a PowerFlex 525 drive from two PLC controllers

    Yes — add the PowerFlex 525 to the Logix controller's Ethernet tree and its command tags appear, but a cyclic drive connection has exactly one owner. Give the Logix controller that ownership, read the MicroLogix machine's request into it, and let one rung select the command the drive follows. Never let two controllers write the speed reference.

    Drives and motion