Chapter 182: RS-422 Full-Duplex Communication

Chapter Objectives

Upon completing this chapter, you will be able to:

• Understand the fundamental principles of RS-422 communication.
• Differentiate RS-422 from RS-485, particularly regarding duplex modes and network topology.
• Identify the key characteristics and advantages of RS-422.
• Select and connect an RS-422 transceiver to an ESP32 microcontroller.
• Configure the ESP32’s UART peripheral for full-duplex serial communication using ESP-IDF v5.x.
• Implement simultaneous data transmission and reception over an RS-422 link.
• Recognize common issues and troubleshoot RS-422 communication problems.
• Apply your knowledge to build simple RS-422-based projects.

Introduction

In the previous chapter, we explored RS-485, a robust half-duplex communication standard. While RS-485 is excellent for multi-drop networks where devices take turns speaking, some applications require simultaneous, bi-directional communication. This is where RS-422 (Recommended Standard 422), also known as EIA-422 or TIA-422, comes into play.

RS-422 is another differential serial communication standard widely used in industrial and instrumentation environments. Its primary advantage over RS-485 in certain scenarios is its inherent full-duplex capability, allowing data to be sent and received at the same time over separate wire pairs. This makes it suitable for applications like point-to-point links requiring high throughput or master-slave systems where the master needs to continuously send commands while receiving data.

This chapter will delve into the specifics of RS-422, highlighting its differences from RS-485. We will cover the necessary hardware interfacing with ESP32 microcontrollers, software configuration using the standard UART features of ESP-IDF, and practical examples to demonstrate full-duplex communication.

Theory

What is RS-422?

RS-422 defines the electrical characteristics of balanced voltage digital interface circuits. Like RS-485, it’s a physical layer specification, not a complete protocol. It’s designed for data transmission over longer distances and in environments with electrical noise.

Key Characteristics:

• Differential Signaling:
  • Similar to RS-485, RS-422 uses differential signaling for its data lines. This provides excellent noise immunity.
  • It uses two separate differential pairs: one for transmitting (TXA, TXB) and one for receiving (RXA, RXB).

• Full-Duplex Communication:
  • This is the hallmark of RS-422. Because it uses dedicated transmit and receive pairs, a device can send and receive data simultaneously. This eliminates the need for direction control logic that is essential in half-duplex RS-485.
• Network Topology:
  • Point-to-Point: RS-422 is commonly used for direct communication between two devices.
  • Multidrop (One Driver, Multiple Receivers): A single RS-422 driver (transmitter) can connect to multiple (typically up to 10) RS-422 receivers on a single bus segment. However, only that one driver can transmit on that pair. This is different from RS-485’s multi-master capability on a shared pair.

%%{
  init: {
    "theme": "base",
    "themeVariables": {
      "primaryColor": "#ffffff",
      "edgeLabelBackground": "#ffffff",
      "fontFamily": "Open Sans"
    }
  }
}%%
graph TD
    %% Class Definitions
    classDef master fill:#EDE9FE,stroke:#5B21B6,stroke-width:2px,color:#5B21B6
    classDef transceiver fill:#DBEAFE,stroke:#2563EB,stroke-width:1px,color:#1E40AF
    classDef termination fill:#FEF3C7,stroke:#D97706,stroke-width:1px,color:#92400E
    classDef busLine fill:#F3E8FF,stroke:#7C3AED,stroke-width:2px,color:#5B21B6

    %% Subgraph A: Full-Duplex Point-to-Point
    subgraph "A: Point-to-Point (Full-Duplex)"
        direction LR

        subgraph DeviceA["Device A"]
            T1{{Transceiver A}}
        end

        subgraph DeviceB["Device B"]
            T2{{Transceiver B}}
        end

        %% TX pairs
        T1 -- "TX Pair (A_TX+, A_TX-)" --> T2
        T2 -- "TX Pair (B_TX+, B_TX-)" --> T1

        %% Terminations
        subgraph R1 [Termination]
            Term1("<b>120Ω</b>")
        end
        subgraph R2 [Termination]
            Term2("<b>120Ω</b>")
        end

        %% Termination links (dashed)
        T2 -.-> R1
        R1 -.-> T2
        T1 -.-> R2
        R2 -.-> T1
    end

    %% Subgraph B: Multidrop Bus
    subgraph "B: Multidrop (1 Master, N Receivers)"
        direction TB

        M[Master Driver]

        subgraph Bus
            direction LR
            BusLine(TX Pair Bus)
        end

        Rcv1[Receiver 1]
        Rcv2[Receiver 2]
        RcvN["... Receiver N"]

        %% Bus connections
        M --> BusLine
        BusLine --> Rcv1
        BusLine --> Rcv2
        BusLine --> RcvN

        %% Terminations
        subgraph TR1 [Termination]
            TermR1("<b>120Ω</b>")
        end
        subgraph TR2 [Termination]
            TermR2("<b>120Ω</b>")
        end
        subgraph TRN [Termination]
            TermRN("<b>120Ω</b>")
        end

        %% Termination links (dashed)
        Rcv1 -.-> TR1
        TR1 -.-> Rcv1
        Rcv2 -.-> TR2
        TR2 -.-> Rcv2
        RcvN -.-> TRN
        TRN -.-> RcvN
    end

    %% Apply Classes
    class M master
    class T1,T2,Rcv1,Rcv2,RcvN transceiver
    class Term1,Term2,TermR1,TermR2,TermRN termination
    class BusLine busLine

• Distance and Data Rate:
  • RS-422 supports communication distances up to 1200 meters (approximately 4000 feet), similar to RS-485.
  • Data rates can reach up to 10 Mbps over shorter distances, with the rate decreasing as cable length increases.
• Voltage Levels:
  • RS-422 drivers produce a differential voltage of ±2V to ±6V.
  • Receivers must detect a differential voltage of at least ±200mV. This provides good noise margin.
  • The common-mode voltage range is typically -7V to +7V.

RS-422 vs. RS-485

While RS-485 transceivers can sometimes be used in an RS-422-like full-duplex configuration if they have separate driver and receiver enable pins, dedicated RS-422 transceivers are designed for this purpose and often offer better performance for full-duplex links.

Hardware Components

1. RS-422 Transceivers:
   • These ICs convert the microcontroller’s single-ended TTL/CMOS logic levels to RS-422 differential signals and vice-versa.
   • Examples: SN75179B, MAX3490, SP3490.
   • Key pins typically include:
     • DI (Driver Input): Connects to UART TX of the microcontroller.
     • RO (Receiver Output): Connects to UART RX of the microcontroller.
     • TXA/Y, TXB/Z: Transmit differential pair outputs.
     • RXA/Y, RXB/Z: Receive differential pair inputs.
     • DE (Driver Enable, optional): Some RS-422 drivers have an enable pin, which is usually tied active (e.g., to VCC) for continuous transmission capability.
     • RE# (Receiver Enable, optional, active low): Some RS-422 receivers have an enable pin, usually tied active (e.g., to GND) for continuous reception.
     • VCC, GND: Power supply.
2. Termination Resistors:
   • Essential for preventing signal reflections, especially on longer cables or at higher data rates.
   • A termination resistor (typically 100-120 Ohms) should be placed across each receive pair (RXA and RXB) at the extreme ends of the cable.
   • Since RS-422 is often point-to-point, this means a termination resistor at the receiver input of each device. In a one-driver-to-multiple-receivers setup, each receiver at the end of a cable stub might need termination.
3. Twisted-Pair Cable:
   • Using two separate twisted-pair cables (one for TX, one for RX) is highly recommended to maintain signal integrity and noise immunity. Shielded twisted-pair (STP) cable can provide additional protection in very noisy environments.

Practical Examples

We’ll use an ESP32 with an external RS-422 transceiver. For simplicity, we assume a transceiver or module that provides direct access to TXA/B and RXA/B pairs.

Hardware Setup

You will need:

1. An ESP32 development board.
2. An RS-422 transceiver IC or module (e.g., based on MAX3490 or similar).
3. Jumper wires.
4. Another RS-422 device for testing (e.g., a USB-to-RS422 adapter, or a second ESP32 with an RS-422 transceiver).

Connections (Point-to-Point Example with two ESP32s):

ESP32 Device 1 (Master/Initiator):

• ESP32_1 UART TXD (e.g., GPIO17) -> RS422_Transceiver_1 DI (Driver Input)
• RS422_Transceiver_1 TXA/Y -> RS422_Transceiver_2 RXA/Y (on Device 2)
• RS422_Transceiver_1 TXB/Z -> RS422_Transceiver_2 RXB/Z (on Device 2)
• ESP32_1 UART RXD (e.g., GPIO16) -> RS422_Transceiver_1 RO (Receiver Output)
• RS422_Transceiver_1 RXA/Y <- RS422_Transceiver_2 TXA/Y (from Device 2)
• RS422_Transceiver_1 RXB/Z <- RS422_Transceiver_2 TXB/Z (from Device 2)
• ESP32_1 3.3V -> RS422_Transceiver_1 VCC
• ESP32_1 GND -> RS422_Transceiver_1 GND
• (If transceiver has DE/RE pins, tie them to enable transmit and receive constantly, e.g., DE to VCC, /RE to GND, as per transceiver datasheet).

ESP32 Device 2 (Slave/Responder):

• Connections will be complementary to Device 1.
• ESP32_2 UART TXD (e.g., GPIO17 on Device 2) -> RS422_Transceiver_2 DI
• RS422_Transceiver_2 TXA/Y -> RS422_Transceiver_1 RXA/Y (on Device 1)
• RS422_Transceiver_2 TXB/Z -> RS422_Transceiver_1 RXB/Z (on Device 1)
• ESP32_2 UART RXD (e.g., GPIO16 on Device 2) -> RS422_Transceiver_2 RO
• RS422_Transceiver_2 RXA/Y <- RS422_Transceiver_1 TXA/Y (from Device 1)
• RS422_Transceiver_2 RXB/Z <- RS422_Transceiver_1 TXB/Z (from Device 1)
• ESP32_2 3.3V -> RS422_Transceiver_2 VCC
• ESP32_2 GND -> RS422_Transceiver_2 GND

Termination:

• Place a 100-120 Ohm termination resistor across the RXA/RXB pins at each transceiver’s receiver input. (i.e., on Transceiver_1’s RXA/RXB and Transceiver_2’s RXA/RXB).

Tip: Always consult your RS-422 transceiver’s datasheet for specific pin names, enable logic, and termination recommendations.

Software Configuration (ESP-IDF v5.x)

For RS-422 full-duplex, we use the standard UART mode. No special RS-485 half-duplex mode or RTS pin for direction control is needed.

Include Headers:

#include "driver/uart.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

Define UART Parameters and Pins:

#define RS422_UART_PORT      (UART_NUM_1) // Or UART_NUM_2, etc.
#define RS422_TXD_PIN        (GPIO_NUM_17)
#define RS422_RXD_PIN        (GPIO_NUM_16)
// RTS and CTS are not typically used for RS422 flow control directly by the standard
// but can be used if the application layer implements software/hardware flow control.
// For basic RS422, they are not needed for direction control.
#define RS422_RTS_PIN        (UART_PIN_NO_CHANGE)
#define RS422_CTS_PIN        (UART_PIN_NO_CHANGE)

#define BAUD_RATE            (115200)
#define UART_BUF_SIZE        (1024)

static const char *TAG = "RS422_APP";

Initialize UART (Standard Mode):

void rs422_uart_init(void) {
    uart_config_t uart_config = {
        .baud_rate = BAUD_RATE,
        .data_bits = UART_DATA_8_BITS,
        .parity    = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, // Can be enabled if your setup uses it
        .source_clk = UART_SCLK_DEFAULT,
    };

    ESP_LOGI(TAG, "Configuring UART parameters for RS422");
    ESP_ERROR_CHECK(uart_param_config(RS422_UART_PORT, &uart_config));

    ESP_LOGI(TAG, "Setting UART pins (TX: %d, RX: %d)", RS422_TXD_PIN, RS422_RXD_PIN);
    ESP_ERROR_CHECK(uart_set_pin(RS422_UART_PORT, RS422_TXD_PIN, RS422_RXD_PIN,
                                 RS422_RTS_PIN, RS422_CTS_PIN));

    ESP_LOGI(TAG, "Installing UART driver");
    ESP_ERROR_CHECK(uart_driver_install(RS422_UART_PORT, UART_BUF_SIZE * 2, UART_BUF_SIZE * 2, 0, NULL, 0));

    // No special mode like UART_MODE_RS485_HALF_DUPLEX is needed for RS422.
    // Standard UART operation is full-duplex by nature if the physical layer supports it.

    ESP_LOGI(TAG, "RS422 UART Initialized (Port: %d, TX: %d, RX: %d)",
             RS422_UART_PORT, RS422_TXD_PIN, RS422_RXD_PIN);
}

Code Snippet: Full-Duplex Echo Application

This example demonstrates two tasks: one for sending data and one for receiving data concurrently. This could be run on a single ESP32 connected to a USB-to-RS422 adapter in loopback mode (TX pair connected to RX pair of the adapter, and adapter’s RX pair to ESP32’s TX pair), or on two ESP32s communicating with each other.

%%{
  init: {
    "theme": "base",
    "themeVariables": {
      "fontFamily": "Open Sans"
    }
  }
}%%
sequenceDiagram
    participant Device A
    participant Bus
    participant Device B
    
    loop Simultaneous Communication
        par 
            Device A->>Bus: TX_A: "Data packet 1"
            Bus->>Device B: RX_B: Receives "Data packet 1"
        and 
            Device B->>Bus: TX_B: "Status OK"
            Bus->>Device A: RX_A: Receives "Status OK"
        end
        
        par
            Device A->>Bus: TX_A: "Data packet 2"
            Bus->>Device B: RX_B: Receives "Data packet 2"
        and
            Device B->>Bus: TX_B: "Sensor value: 123"
            Bus->>Device A: RX_A: Receives "Sensor value: 123"
        end
    end
    Note over Device A, Device B: Data flows in both directions at the same time.<br>No direction control is needed.

Transmit Task:

void rs422_tx_task(void *pvParameters) {
    char tx_buffer[100];
    int counter = 0;

    while (1) {
        sprintf(tx_buffer, "Hello from ESP32 over RS422! Count: %d\r\n", counter++);
        int len = strlen(tx_buffer);

        int bytes_sent = uart_write_bytes(RS422_UART_PORT, tx_buffer, len);
        if (bytes_sent == len) {
            ESP_LOGI(TAG, "TX: Sent %d bytes: %s", bytes_sent, tx_buffer);
        } else {
            ESP_LOGE(TAG, "TX: Error sending data. Sent %d, expected %d", bytes_sent, len);
            uart_wait_tx_done(RS422_UART_PORT, pdMS_TO_TICKS(100));
        }
        vTaskDelay(pdMS_TO_TICKS(2000)); // Send every 2 seconds
    }
}

Receive Task:

void rs422_rx_task(void *pvParameters) {
    uint8_t *data = (uint8_t *) malloc(UART_BUF_SIZE);
    if (data == NULL) {
        ESP_LOGE(TAG, "RX: Failed to allocate memory for UART data buffer");
        vTaskDelete(NULL);
        return;
    }

    ESP_LOGI(TAG, "RX: Listening for data...");

    while (1) {
        int len = uart_read_bytes(RS422_UART_PORT, data, (UART_BUF_SIZE - 1), pdMS_TO_TICKS(200));

        if (len > 0) {
            data[len] = '\0'; // Null-terminate
            ESP_LOGI(TAG, "RX: Received %d bytes: '%s'", len, (char *)data);
            // Echo back the received data (optional, for testing)
            // char echo_prefix[] = "ECHO: ";
            // uart_write_bytes(RS422_UART_PORT, echo_prefix, strlen(echo_prefix));
            // uart_write_bytes(RS422_UART_PORT, (const char*)data, len);
            // uart_write_bytes(RS422_UART_PORT, "\r\n", 2);

        } else if (len == 0) {
            // Timeout
        } else {
            ESP_LOGE(TAG, "RX: UART read error");
        }
    }
    free(data);
}

Main Application (app_main):

void app_main(void) {
    ESP_LOGI(TAG, "RS422 Full-Duplex Example App Started");

    rs422_uart_init(); // Initialize UART

    // Create separate tasks for transmitting and receiving
    xTaskCreate(rs422_rx_task, "rs422_rx_task", 4096, NULL, 6, NULL);
    xTaskCreate(rs422_tx_task, "rs422_tx_task", 4096, NULL, 5, NULL);

    ESP_LOGI(TAG, "TX and RX tasks started for RS422 communication.");
}

Build Instructions

1. Save your code (e.g., main.c in the main directory of your ESP-IDF project).
2. Ensure CMakeLists.txt in main directory registers the source file:idf_component_register(SRCS "main.c" INCLUDE_DIRS ".")
3. Open ESP-IDF Terminal in VS Code.
4. Build: idf.py build

Run/Flash/Observe Steps

1. Connect ESP32 to computer.
2. Flash: idf.py -p (PORT) flash
3. Monitor: idf.py -p (PORT) monitor
4. Testing:
   • With USB-to-RS422 Adapter: Connect the ESP32’s RS-422 transceiver TX pair to the adapter’s RX pair, and the ESP32’s RX pair to the adapter’s TX pair. Use a serial terminal on your PC (e.g., PuTTY, CoolTerm) configured for the adapter’s COM port and the correct baud rate. You should see messages from the ESP32, and you can send messages from the PC to the ESP32.
   • With Two ESP32s: Program both ESP32s with the above code. Connect their RS-422 transceivers as described in the hardware setup (TX of one to RX of other, and vice-versa). You should see both ESP32s sending messages and logging received messages from each other.

Variant Notes

• ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C6, ESP32-H2: All these variants have UART peripherals suitable for RS-422 communication with an external transceiver. The standard UART driver functionality used here is common across these chips.
• Number of UART Controllers: (Same as listed in Chapter 181 for RS-485)
  • ESP32: 3 (UART0, UART1, UART2)
  • ESP32-S2: 2
  • ESP32-S3: 3
  • ESP32-C3: 2
  • ESP32-C6: 2-3 (check datasheet)
  • ESP32-H2: 2 (check datasheet)Usually, UART1 or UART2 are preferred for application use.
• Pin Mapping: Flexible GPIO mapping is available on all variants. Always check the specific chip datasheet for any pin limitations.
• Performance: For very high-speed RS-422 communication (Mbps range), ensure your task priorities, buffer sizes, and overall system load allow the UART driver and your application tasks to keep up. DMA usage by the UART driver (which is typical) helps significantly.

Common Mistakes & Troubleshooting Tips

Exercises

1. Bi-directional Counter:
   • Set up two ESP32 devices with RS-422 transceivers.
   • Device A sends an incrementing counter value to Device B every second.
   • Device B, upon receiving a value, adds 100 to it and sends it back to Device A.
   • Device A logs the original value sent and the modified value received from Device B. Both devices should log their TX and RX activity.
2. Remote Sensor Data Display:
   • Connect a simple sensor (e.g., a potentiometer read by ADC, or a DHT11/22) to ESP32 Device A.
   • Device A reads the sensor value periodically and transmits it over RS-422 to ESP32 Device B.
   • Device B receives the sensor data and displays it on the serial monitor (or an attached LCD if you have one from Chapter 148).
   • Simultaneously, Device B sends an acknowledgment or status message back to Device A after successfully receiving data.
3. Full-Duplex Chat Application:
   • Establish an RS-422 link between an ESP32 and a PC (using a USB-to-RS422 adapter and a serial terminal program).
   • Anything typed into the ESP32’s serial monitor (via uart_read_bytes from UART0, then sent over RS422) should appear on the PC’s terminal.
   • Anything typed into the PC’s serial terminal (sent over RS422) should appear on the ESP32’s monitor (received via RS422, then printed using ESP_LOGI).
   • This requires careful management of UART0 for console I/O and UARTx for RS-422.

Summary

• RS-422 is a differential serial communication standard enabling full-duplex data transmission using two separate wire pairs (one for transmit, one for receive).
• It offers excellent noise immunity and supports long distances (up to 1200m) and high data rates (up to 10 Mbps).
• RS-422 is typically used for point-to-point links or one-driver-to-multiple-receivers configurations.
• Unlike RS-485 half-duplex, RS-422 does not require direction control for transceivers.
• Termination resistors (100-120 Ohms) are needed across each receive pair at the ends of the line.
• ESP32 microcontrollers can use their standard UART peripherals for RS-422 communication with an external RS-422 transceiver. No special UART mode is required in ESP-IDF.
• Correct wiring of the four data lines (TXA/B, RXA/B) and proper grounding are critical.

Further Reading

• ESP-IDF UART Driver Documentation:
  • https://docs.espressif.com/projects/esp-idf/en/v5.4/esp32/api-reference/peripherals/uart.html (Adjust for your specific ESP32 variant if needed).
• TIA/EIA-422-B Standard Document: (Official standard, may require purchase).
• Application Notes from Transceiver Manufacturers:
  • Search for “RS-422 application note” from companies like Texas Instruments, Analog Devices, Renesas, etc.
  • Example: Texas Instruments “RS-422 and RS-485 Standards Overview and System Configurations” (SLLA070D or similar).