Arduino Serial to Serial Communication: Dual-Board UART Wiring & Debugging

To establish reliable Arduino serial to serial communication between two boards, you must cross the transmit and receive lines (TX1 to RX2, RX1 to TX2), connect a common ground (GND to GND), and configure both boards to the exact same baud rate (typically 115200). Never connect TX to TX, and never omit the common ground, as the voltage reference will float and corrupt the data.

This guide details a robust dual-board setup using an Arduino Mega 2560 Rev3 as a central hub and an Arduino Uno R4 Minima as a remote sensor node. We will bypass the CPU-blocking pitfalls of SoftwareSerial by utilizing dedicated hardware UART pins, and provide exact debugging steps for the most common serial errors.

UART Interface Specifications & Protocol Limits

Before wiring your boards, you must understand the hardware limits of the serial interfaces available on modern Arduino architectures. Beginners frequently default to SoftwareSerial out of habit, which causes buffer overflows and CPU lockups at high baud rates. Always prefer hardware UART when available.

Required Hardware & Pin Mapping

This build assumes you are using 5V logic boards. If you substitute the Uno R4 with a 3.3V board (like the Nano 33 IoT or ESP32), you must insert a bidirectional logic level shifter (e.g., BSS138-based) between the TX/RX lines to prevent frying the 3.3V microcontroller's GPIO pins.

Parts List (2026 Pricing)

• Central Hub: Arduino Mega 2560 Rev3 (Official) - ~$45.00
• Sensor Node: Arduino Uno R4 Minima (Official) - ~$20.00
• Wiring: 24 AWG Silicone jumper wires (Female-to-Female) - ~$6.00
• Power: 5V 2A USB-C power supply (to power the hub, which powers the node via 5V pin) - ~$10.00

Pin Mapping Table

Compilable Node and Hub Firmware

The following code implements a basic packet structure with a checksum. This prevents the hub from acting on corrupted bytes caused by electrical noise. The target board variants are explicitly defined in the headers.

Sensor Node Code (Arduino Uno R4 Minima)

Upload this to the Uno R4. It uses the primary hardware UART (Serial) on pins 0 and 1.

// Target Board: Arduino Uno R4 Minima
// Pin Definitions
#define NODE_TX_PIN 1
#define NODE_RX_PIN 0
#define BAUD_RATE 115200

void setup() {
  // Initialize hardware UART for board-to-board comms
  Serial.begin(BAUD_RATE);
  while (!Serial) { delay(10); } // Wait for UART to stabilize
}

void loop() {
  // Simulate sensor data
  float temperature = 24.5 + (random(-10, 10) / 10.0);
  int sensorID = 42;
  
  // Build packet: [Header][ID][Temp_Int][Temp_Dec][Checksum]
  uint8_t tempInt = (uint8_t)temperature;
  uint8_t tempDec = (uint8_t)((temperature - tempInt) * 10);
  uint8_t checksum = (0xAA + sensorID + tempInt + tempDec) & 0xFF;
  
  // Transmit packet
  Serial.write(0xAA); // Header byte
  Serial.write(sensorID);
  Serial.write(tempInt);
  Serial.write(tempDec);
  Serial.write(checksum);
  
  delay(1000); // 1Hz telemetry rate
}

Central Hub Code (Arduino Mega 2560 Rev3)

Upload this to the Mega. It reads from Serial1 (pins 18/19) and outputs debug info to Serial (USB).

// Target Board: Arduino Mega 2560 Rev3
// Pin Definitions
#define HUB_RX_PIN 19 // Serial1 RX
#define HUB_TX_PIN 18 // Serial1 TX
#define BAUD_RATE 115200
#define PACKET_SIZE 5
#define READ_TIMEOUT_MS 100

void setup() {
  // Serial for USB debugging to PC
  Serial.begin(BAUD_RATE);
  // Serial1 for Hardware UART to the Uno R4 Node
  Serial1.begin(BAUD_RATE);
  Serial.println("Hub initialized. Waiting for node telemetry...");
}

void loop() {
  if (Serial1.available() > 0) {
    // Look for header byte
    if (Serial1.read() == 0xAA) {
      uint8_t packet[PACKET_SIZE - 1];
      unsigned long startTime = millis();
      int bytesRead = 0;
      
      // Read remaining bytes with timeout error handling
      while (bytesRead < (PACKET_SIZE - 1)) {
        if (Serial1.available() > 0) {
          packet[bytesRead++] = Serial1.read();
        } else if (millis() - startTime > READ_TIMEOUT_MS) {
          Serial.println("[ERROR] Packet timeout: Incomplete data received.");
          return; // Abort this packet
        }
      }
      
      // Verify Checksum
      uint8_t calcChecksum = (0xAA + packet[0] + packet[1] + packet[2]) & 0xFF;
      if (calcChecksum == packet[3]) {
        float temp = packet[1] + (packet[2] / 10.0);
        Serial.print("[OK] Node ");
        Serial.print(packet[0]);
        Serial.print(" | Temp: ");
        Serial.println(temp);
      } else {
        Serial.println("[ERROR] Checksum mismatch. Data corrupted.");
      }
    }
  }
}

Debugging Serial Failures: Exact Errors & Ranked Causes

When your serial monitor outputs garbage or fails to upload, use this decision tree. These are the first three things to check when a serial link fails, ranked by probability.

1. Symptom: Gibberish Characters (e.g., ⸮⸮⸮⸮ or ÿÿ)

Root Cause: Baud rate mismatch or clock drift.

• Fix: Verify both Serial.begin() and Serial1.begin() are set to the exact same value (e.g., 115200). If using an older AVR board with an internal oscillator (like an ATtiny85), the clock drift may be too high for 115200 baud. Drop both boards to 9600 baud.
• Edge Case: Ensure your Serial Monitor software (IDE or PuTTY) is also set to the matching baud rate.

2. Symptom: Upload Fails with avrdude: stk500_getsync() attempt 10 of 10: not in sync

Root Cause: Hardware UART pins (0 and 1) are blocked by external wiring during compilation.

• Fix: On the Uno R4 (and older Uno R3), pins 0 and 1 are shared with the USB programming circuit. If you have a wire connected to Pin 0 (RX) or Pin 1 (TX) while clicking 'Upload', the external device will corrupt the bootloader handshake. Disconnect the TX/RX jumper wires before uploading code, then reconnect them.

3. Symptom: Hub Receives Nothing (Blank Serial Monitor)

Root Cause: Missing common ground or TX/RX swap.

• Fix A (Ground): Use a multimeter in continuity mode to verify the GND pin on the Mega is physically connected to the GND pin on the Uno. Without this, the voltage thresholds for logic HIGH/LOW are undefined.
• Fix B (Swap): Verify the cross-over. TX must go to RX. If you wired TX to TX, the boards are both driving the line high, resulting in a bus collision and zero data transfer.

Extending the Range or Simplifying the Bus

Standard UART over jumper wires is reliable up to about 50cm (20 inches) at 115200 baud. Beyond that, or in electrically noisy environments (like near AC motors or VFDs), the unshielded wires will act as antennas and induce bit errors.

How to Extend: RS-485 Transceivers

If you need to run serial communication over 10 meters or more, or daisy-chain multiple nodes, abandon direct UART and use RS-485. You will need a MAX485 or SP3485 breakout board for each Arduino. RS-485 uses differential signaling (A and B lines) which rejects common-mode noise. You can run RS-485 over standard Cat5e ethernet cable at 500 meters with near-zero packet loss. Note that RS-485 is half-duplex, so you must manage a Driver Enable (DE) pin in your code to switch between transmitting and receiving.

How to Simplify: Switch to I2C

If your boards are on the same PCB or within 30cm of each other, and you only need the Hub to poll the Node (no asynchronous node-to-hub alerts), switch to I2C (Wire library). I2C requires only two wires (SDA, SCL) plus ground, supports multiple nodes on the same bus without complex addressing logic, and handles clock stretching natively. However, I2C is strictly a master-slave (controller-target) architecture and cannot handle high-throughput streaming like UART can.

For further reading on hardware serial implementations, refer to the official Arduino Serial Reference and the Mega 2560 hardware documentation for exact pinout schematics.