766  Modbus Modes and Timing Analysis

Comparing RTU, TCP, and ASCII modes with performance analysis and timing calculations

766.1 Learning Objectives

By the end of this chapter, you will be able to:

1. Compare the characteristics of Modbus RTU, TCP, and ASCII modes
2. Calculate timing parameters for serial communication (character time, T1.5, T3.5)
3. Estimate throughput and protocol efficiency for different configurations
4. Select the appropriate Modbus mode for specific industrial applications

766.2 Introduction

Modbus supports three transmission modes, each optimized for different physical layers and use cases. Understanding the timing characteristics and trade-offs of each mode is essential for designing reliable industrial communication systems. This chapter provides interactive tools for analyzing timing and comparing mode characteristics.

TipFor Beginners: Why Three Modes?

Think of the three modes like different ways to send a letter:

• RTU (Remote Terminal Unit): Like sending a telegram - fast, compact, but needs precise timing
• TCP/IP: Like sending an email - works over networks, reliable, but needs internet infrastructure
• ASCII: Like sending a letter with words spelled out - slower but human-readable

Each has its place depending on your “postal system” (physical network)!

766.3 Mode Comparison

colors = ({
  navy: "#2C3E50",
  teal: "#16A085",
  orange: "#E67E22",
  gray: "#7F8C8D",
  lightGray: "#ECF0F1",
  white: "#FFFFFF",
  red: "#E74C3C",
  green: "#27AE60",
  purple: "#9B59B6",
  darkTeal: "#1ABC9C",
  lightNavy: "#34495E",
  yellow: "#F39C12",
  blue: "#3498DB",
  darkGray: "#34495E"
})

viewof modbusMode = Inputs.radio(["RTU", "TCP", "ASCII"], {
  value: "RTU",
  label: "Active Mode"
})

modeComparisonViz = {
  const width = 900;
  const height = 400;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("width", "100%")
    .attr("height", height)
    .style("font-family", "system-ui, -apple-system, sans-serif")
    .style("background", "linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%)")
    .style("border-radius", "12px");

  // Title
  svg.append("text")
    .attr("x", width / 2)
    .attr("y", 30)
    .attr("text-anchor", "middle")
    .attr("font-size", "18px")
    .attr("font-weight", "bold")
    .attr("fill", colors.navy)
    .text("Modbus Mode Comparison");

  const modes = [
    {
      name: "RTU",
      color: colors.teal,
      transport: "RS-232/RS-485",
      framing: "Binary + CRC-16",
      speed: "9600-115200 bps",
      maxDevices: "32 (RS-485)",
      maxDistance: "1200m (RS-485)",
      pros: ["Compact frames", "Fast transmission", "CRC error detection"],
      cons: ["Character timing critical", "Binary not human-readable"],
      useCase: "Most common industrial"
    },
    {
      name: "TCP",
      color: colors.blue,
      transport: "Ethernet/TCP/IP",
      framing: "MBAP Header (7 bytes)",
      speed: "10/100/1000 Mbps",
      maxDevices: "Unlimited",
      maxDistance: "Unlimited (routable)",
      pros: ["High speed", "Scalable", "Routable", "Standard IT infrastructure"],
      cons: ["Higher overhead", "Network complexity"],
      useCase: "Enterprise/SCADA systems"
    },
    {
      name: "ASCII",
      color: colors.purple,
      transport: "RS-232/RS-485",
      framing: "':' + Hex ASCII + LRC",
      speed: "1200-19200 bps",
      maxDevices: "32 (RS-485)",
      maxDistance: "1200m (RS-485)",
      pros: ["Human readable", "Easy debugging", "Wider timing tolerance"],
      cons: ["Larger frames (2x RTU)", "Slower"],
      useCase: "Legacy/debugging"
    }
  ];

  const cardWidth = 280;
  const cardHeight = 320;
  const cardSpacing = 20;
  const startX = (width - (cardWidth * 3 + cardSpacing * 2)) / 2;

  modes.forEach((mode, i) => {
    const x = startX + i * (cardWidth + cardSpacing);
    const y = 55;
    const isActive = modbusMode === mode.name;

    // Card background
    svg.append("rect")
      .attr("x", x)
      .attr("y", y)
      .attr("width", cardWidth)
      .attr("height", cardHeight)
      .attr("rx", 12)
      .attr("fill", colors.white)
      .attr("stroke", isActive ? mode.color : colors.lightGray)
      .attr("stroke-width", isActive ? 4 : 2)
      .attr("filter", isActive ? "drop-shadow(0 4px 8px rgba(0,0,0,0.15))" : "none");

    // Header
    svg.append("rect")
      .attr("x", x)
      .attr("y", y)
      .attr("width", cardWidth)
      .attr("height", 45)
      .attr("rx", 12)
      .attr("fill", mode.color);

    // Fix rounded corners at bottom of header
    svg.append("rect")
      .attr("x", x)
      .attr("y", y + 33)
      .attr("width", cardWidth)
      .attr("height", 12)
      .attr("fill", mode.color);

    svg.append("text")
      .attr("x", x + cardWidth / 2)
      .attr("y", y + 28)
      .attr("text-anchor", "middle")
      .attr("font-size", "16px")
      .attr("font-weight", "bold")
      .attr("fill", colors.white)
      .text(`Modbus ${mode.name}`);

    // Content
    let contentY = y + 60;
    const lineHeight = 16;

    const specs = [
      { label: "Transport", value: mode.transport },
      { label: "Framing", value: mode.framing },
      { label: "Speed", value: mode.speed },
      { label: "Max Devices", value: mode.maxDevices },
      { label: "Distance", value: mode.maxDistance }
    ];

    specs.forEach(spec => {
      svg.append("text")
        .attr("x", x + 10)
        .attr("y", contentY)
        .attr("font-size", "9px")
        .attr("font-weight", "bold")
        .attr("fill", colors.darkGray)
        .text(spec.label + ":");

      svg.append("text")
        .attr("x", x + 80)
        .attr("y", contentY)
        .attr("font-size", "9px")
        .attr("fill", colors.navy)
        .text(spec.value);

      contentY += lineHeight;
    });

    contentY += 8;

    // Pros
    svg.append("text")
      .attr("x", x + 10)
      .attr("y", contentY)
      .attr("font-size", "9px")
      .attr("font-weight", "bold")
      .attr("fill", colors.green)
      .text("Advantages:");
    contentY += 12;

    mode.pros.forEach(pro => {
      svg.append("text")
        .attr("x", x + 15)
        .attr("y", contentY)
        .attr("font-size", "8px")
        .attr("fill", colors.darkGray)
        .text("+ " + pro);
      contentY += 11;
    });

    contentY += 5;

    // Cons
    svg.append("text")
      .attr("x", x + 10)
      .attr("y", contentY)
      .attr("font-size", "9px")
      .attr("font-weight", "bold")
      .attr("fill", colors.red)
      .text("Limitations:");
    contentY += 12;

    mode.cons.forEach(con => {
      svg.append("text")
        .attr("x", x + 15)
        .attr("y", contentY)
        .attr("font-size", "8px")
        .attr("fill", colors.darkGray)
        .text("- " + con);
      contentY += 11;
    });

    contentY += 8;

    // Use case
    svg.append("rect")
      .attr("x", x + 10)
      .attr("y", contentY - 3)
      .attr("width", cardWidth - 20)
      .attr("height", 20)
      .attr("rx", 4)
      .attr("fill", mode.color)
      .attr("opacity", 0.15);

    svg.append("text")
      .attr("x", x + cardWidth / 2)
      .attr("y", contentY + 11)
      .attr("text-anchor", "middle")
      .attr("font-size", "9px")
      .attr("font-weight", "bold")
      .attr("fill", mode.color)
      .text(mode.useCase);

    // Active indicator
    if (isActive) {
      svg.append("circle")
        .attr("cx", x + cardWidth - 15)
        .attr("cy", y + 22)
        .attr("r", 8)
        .attr("fill", colors.white);

      svg.append("text")
        .attr("x", x + cardWidth - 15)
        .attr("y", y + 26)
        .attr("text-anchor", "middle")
        .attr("font-size", "10px")
        .attr("fill", mode.color)
        .text("*");
    }
  });

  return svg.node();
}

766.4 Timing and Performance

viewof baudRate = Inputs.select([1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200], {
  value: 9600,
  label: "Baud Rate"
})

viewof dataLength = Inputs.range([1, 250], {
  value: 10,
  step: 1,
  label: "Data Bytes (registers)"
})

timingViz = {
  const width = 900;
  const height = 300;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("width", "100%")
    .attr("height", height)
    .style("font-family", "system-ui, -apple-system, sans-serif")
    .style("background", colors.white)
    .style("border", `1px solid ${colors.lightGray}`)
    .style("border-radius", "8px");

  // Calculate timing
  const charTime = (11 / baudRate) * 1000; // ms per character (11 bits: 1 start + 8 data + 1 parity + 1 stop)
  const t15 = charTime * 1.5; // Inter-character timeout
  const t35 = charTime * 3.5; // Inter-frame timeout

  // Frame sizes
  let reqSize, respSize;
  if (modbusMode === "RTU") {
    reqSize = 1 + 1 + 4 + 2; // slave + fc + data + crc
    respSize = 1 + 1 + 1 + dataLength * 2 + 2; // slave + fc + count + data + crc
  } else if (modbusMode === "ASCII") {
    reqSize = (1 + 1 + 4) * 2 + 3; // (slave + fc + data) * 2 for hex + : + LRC + CRLF
    respSize = (1 + 1 + 1 + dataLength * 2) * 2 + 4;
  } else {
    reqSize = 7 + 1 + 4; // MBAP + fc + data (no CRC in TCP)
    respSize = 7 + 1 + 1 + dataLength * 2;
  }

  const reqTime = reqSize * charTime;
  const respTime = respSize * charTime;
  const processingTime = 5; // Assume 5ms processing
  const turnaround = modbusMode === "RTU" ? t35 : 0;

  const totalTime = reqTime + turnaround + processingTime + respTime;

  // Title
  svg.append("text")
    .attr("x", width / 2)
    .attr("y", 25)
    .attr("text-anchor", "middle")
    .attr("font-size", "16px")
    .attr("font-weight", "bold")
    .attr("fill", colors.navy)
    .text(`Modbus ${modbusMode} Timing Analysis @ ${baudRate} baud`);

  // Timing bar
  const barY = 80;
  const barHeight = 40;
  const timelineWidth = width - 100;
  const scale = timelineWidth / (totalTime * 1.2);

  let x = 50;

  // Request transmission
  const reqWidth = reqTime * scale;
  svg.append("rect")
    .attr("x", x)
    .attr("y", barY)
    .attr("width", reqWidth)
    .attr("height", barHeight)
    .attr("rx", 4)
    .attr("fill", colors.teal);

  svg.append("text")
    .attr("x", x + reqWidth / 2)
    .attr("y", barY + barHeight / 2 + 4)
    .attr("text-anchor", "middle")
    .attr("font-size", "10px")
    .attr("font-weight", "bold")
    .attr("fill", colors.white)
    .text(`Request (${reqTime.toFixed(2)}ms)`);

  x += reqWidth;

  // Turnaround/gap
  if (turnaround > 0) {
    const gapWidth = turnaround * scale;
    svg.append("rect")
      .attr("x", x)
      .attr("y", barY)
      .attr("width", gapWidth)
      .attr("height", barHeight)
      .attr("fill", colors.lightGray)
      .attr("stroke", colors.gray)
      .attr("stroke-dasharray", "4,2");

    svg.append("text")
      .attr("x", x + gapWidth / 2)
      .attr("y", barY + barHeight / 2 + 4)
      .attr("text-anchor", "middle")
      .attr("font-size", "8px")
      .attr("fill", colors.gray)
      .text(`T3.5 (${turnaround.toFixed(2)}ms)`);

    x += gapWidth;
  }

  // Processing time
  const procWidth = processingTime * scale;
  svg.append("rect")
    .attr("x", x)
    .attr("y", barY)
    .attr("width", procWidth)
    .attr("height", barHeight)
    .attr("rx", 4)
    .attr("fill", colors.orange);

  svg.append("text")
    .attr("x", x + procWidth / 2)
    .attr("y", barY + barHeight / 2 + 4)
    .attr("text-anchor", "middle")
    .attr("font-size", "9px")
    .attr("font-weight", "bold")
    .attr("fill", colors.white)
    .text(`Proc`);

  x += procWidth;

  // Response transmission
  const respWidth = respTime * scale;
  svg.append("rect")
    .attr("x", x)
    .attr("y", barY)
    .attr("width", respWidth)
    .attr("height", barHeight)
    .attr("rx", 4)
    .attr("fill", colors.green);

  svg.append("text")
    .attr("x", x + respWidth / 2)
    .attr("y", barY + barHeight / 2 + 4)
    .attr("text-anchor", "middle")
    .attr("font-size", "10px")
    .attr("font-weight", "bold")
    .attr("fill", colors.white)
    .text(`Response (${respTime.toFixed(2)}ms)`);

  // Timing summary table
  const tableY = 150;
  const cols = [
    { label: "Character Time", value: `${(charTime * 1000).toFixed(1)} us` },
    { label: "T1.5 (inter-char)", value: `${(t15 * 1000).toFixed(1)} us` },
    { label: "T3.5 (inter-frame)", value: `${(t35 * 1000).toFixed(1)} us` },
    { label: "Request Size", value: `${reqSize} bytes` },
    { label: "Response Size", value: `${respSize} bytes` },
    { label: "Total Transaction", value: `${totalTime.toFixed(2)} ms` }
  ];

  cols.forEach((col, i) => {
    const cx = 50 + (i % 3) * 280;
    const cy = tableY + Math.floor(i / 3) * 40;

    svg.append("rect")
      .attr("x", cx)
      .attr("y", cy)
      .attr("width", 260)
      .attr("height", 32)
      .attr("rx", 6)
      .attr("fill", colors.lightGray)
      .attr("opacity", 0.5);

    svg.append("text")
      .attr("x", cx + 10)
      .attr("y", cy + 14)
      .attr("font-size", "10px")
      .attr("fill", colors.gray)
      .text(col.label);

    svg.append("text")
      .attr("x", cx + 10)
      .attr("y", cy + 26)
      .attr("font-size", "11px")
      .attr("font-weight", "bold")
      .attr("fill", colors.navy)
      .text(col.value);
  });

  // Throughput calculation
  const effectiveBps = (dataLength * 2 * 8) / (totalTime / 1000);
  const efficiency = (dataLength * 2) / (reqSize + respSize) * 100;

  svg.append("text")
    .attr("x", 50)
    .attr("y", height - 30)
    .attr("font-size", "11px")
    .attr("fill", colors.navy)
    .text(`Effective Throughput: ${effectiveBps.toFixed(0)} bps | Protocol Efficiency: ${efficiency.toFixed(1)}%`);

  svg.append("text")
    .attr("x", 50)
    .attr("y", height - 12)
    .attr("font-size", "10px")
    .attr("fill", colors.gray)
    .text(`Max Polls/sec: ${(1000 / totalTime).toFixed(1)} | Recommended Timeout: ${(totalTime * 3).toFixed(0)}ms`);

  return svg.node();
}

766.5 Key Timing Concepts

NoteRTU Timing Requirements

T1.5 (Inter-character timeout): Maximum gap between characters in a frame. If exceeded, the frame is considered incomplete.

T3.5 (Inter-frame timeout): Minimum silence before a new frame can start. This marks frame boundaries.

At 9600 baud with 11 bits per character: - Character time = 11/9600 = 1.146 ms - T1.5 = 1.719 ms - T3.5 = 4.010 ms

For baud rates > 19200, fixed times are used: T1.5 = 750 us, T3.5 = 1.75 ms

766.6 Mode Selection Guide

TipWhen to Use Each Mode

Use Modbus RTU when: - You need maximum efficiency on serial links - Equipment supports RS-485 multi-drop - Timing can be precisely controlled - Standard industrial automation applications

Use Modbus TCP when: - Connecting over Ethernet/IP networks - Long distances or multiple buildings - Integration with IT infrastructure - High-speed polling requirements

Use Modbus ASCII when: - Debugging serial communication issues - Equipment only supports ASCII mode - Timing tolerances are loose - Human-readable traffic is important

766.7 Key Takeaways

TipSummary

1. Modbus is the most widely used industrial protocol - Simple, robust, and well-supported by virtually all industrial equipment vendors.

2. Three modes for different needs:

   • RTU: Most efficient, binary format, requires precise timing
   • TCP: Modern networks, higher speed, easier integration with IT systems
   • ASCII: Human-readable, good for debugging, slower

3. Four register types cover all data:

   • Coils (bits, R/W) and Discrete Inputs (bits, R)
   • Holding Registers (16-bit, R/W) and Input Registers (16-bit, R)

4. Error handling is built-in: CRC-16/LRC checksums and exception responses provide reliable error detection.

5. Master-slave architecture is simple but requires polling - no event-driven notifications.

766.8 Knowledge Check

NoteQuick Quiz: Mode Selection

Question: You need to connect a SCADA system to 50 PLCs across 3 buildings with a maximum distance of 500 meters. Which Modbus mode is most appropriate?

1. Modbus RTU over RS-485
2. Modbus TCP over Ethernet
3. Modbus ASCII over RS-232
4. Any mode would work equally well

TipAnswer

b) Modbus TCP over Ethernet - For 50 devices across multiple buildings, Ethernet is the best choice because: - RS-485 is limited to 32 devices without repeaters - RS-485 has a 1200m maximum distance limit - TCP/IP can be routed between buildings - Ethernet switches can easily support 50+ devices

766.9 Summary

• RTU: Binary framing, CRC-16 checksum, most efficient, timing-critical
• TCP: MBAP header, no CRC (TCP provides reliability), routable, scalable
• ASCII: Hex-encoded, LRC checksum, human-readable, 2x frame size
• Timing formulas: Character time = 11/baud, T1.5 = 1.5 * char time, T3.5 = 3.5 * char time
• Protocol efficiency: Data bytes / total frame size (typically 40-80% depending on message size)

766.10 What’s Next

Continue exploring industrial protocols:

• Modbus Frame Structure - Understanding RTU/TCP/ASCII frame formats
• Modbus Registers and Communication - Register types and addressing
• Modbus Function Codes - Complete reference for all function codes
• WirelessHART TDMA - Industrial wireless with TDMA scheduling
• ISA100 DLMO - Another industrial wireless standard
• OPC UA - Modern industrial protocol with security

NoteTechnical Implementation Notes

This simulator is built with Observable JavaScript (OJS) and D3.js. Key features:

• Real CRC-16 calculation: Uses the Modbus polynomial (0xA001) with proper bit reflection
• LRC calculation: Two’s complement checksum for ASCII mode
• Frame generation: Dynamically builds correct request/response frames for all function codes
• MBAP header: Proper TCP framing with transaction ID and unit identifier
• Exception simulation: Demonstrates all common exception codes

The visualization updates reactively as you change parameters, providing immediate feedback on frame structure and timing.