Raspberry Pi Pico and Arduino Micro UART Interfacing: Pinouts, Code, and Debugging

To interface a Raspberry Pi Pico (RP2040) and an Arduino Micro (ATmega32U4) via UART, you must use a bidirectional logic level converter (like the BSS138). The Pico operates strictly at 3.3V logic, while the standard Arduino Micro uses 5V logic. Connecting the Micro's 5V TX pin directly to the Pico's 3.3V RX pin will instantly destroy the RP2040 silicon through overvoltage latch-up. This guide walks through the exact pinouts, level-shifting wiring, and compilable C++ code to bridge these two distinct ecosystems safely.

Spec-Sheet Showdown: Raspberry Pi Pico and Arduino Micro

Before wiring them together, it is critical to understand the hardware asymmetry between these two boards. The Pico is a modern, high-clock-speed microcontroller with abundant memory, while the Micro is an older 8-bit AVR chip prized for its native USB HID capabilities. Below is the data-dense hardware comparison to inform your architecture decisions.

Parts List and UART Pin Mapping

Because of the voltage mismatch, a simple TX-to-RX crossover will not work. You need a dedicated logic level shifting module. Avoid resistor voltage dividers for UART; they lack the speed and edge sharpness required for reliable 115200 baud serial communication.

Required Components

• Master: Raspberry Pi Pico (RP2040, standard variant with pre-soldered headers) - Targeted in code below.
• Slave: Arduino Micro (ATmega32U4, 5V/16MHz variant) - Targeted in code below.
• Level Shifter: BSS138 Bidirectional Logic Level Converter (4-channel breakout board).
• Wiring: 22 AWG solid-core jumper wires and a half-size breadboard.

UART Pin Mapping Table

This table maps the physical connections through the BSS138 level shifter. The BSS138 has a Low Voltage (LV) side and a High Voltage (HV) side. Ensure the Pico connects only to the LV side, and the Micro connects only to the HV side.

Step-by-Step Wiring and Logic Level Shifting

1. Establish Common Ground: Connect a 22 AWG black wire from any Pico GND pin to the GND rail on your breadboard. Connect the Micro's GND pin to the same rail. Finally, jumper the breadboard GND rail to both the LV GND and HV GND pins on the BSS138 module.
2. Power the Level Shifter: Connect the Pico's 3V3(OUT) pin to the BSS138 'LV' pin. Connect the Micro's 5V pin to the BSS138 'HV' pin. Verify with a multimeter that you read exactly 3.3V across LV-GND and 5.0V across HV-GND before proceeding.
3. Wire the TX Line (Pico to Micro): Run a wire from Pico GP4 to BSS138 LV1. Run a second wire from BSS138 HV1 to Arduino Micro Pin 0 (RX).
4. Wire the RX Line (Micro to Pico): Run a wire from Pico GP5 to BSS138 LV2. Run a second wire from BSS138 HV2 to Arduino Micro Pin 1 (TX).
5. Verify Crossover: Visually trace the lines. The TX pin on the Master must ultimately hit the RX pin on the Slave, and vice versa. The level shifter handles the voltage translation, but it does not swap the data direction.

Complete Compilable UART Bridge Code

The following code targets the Raspberry Pi Pico (RP2040) using the Earle Philhower Arduino core, and the Arduino Micro (ATmega32U4) using the standard Arduino AVR core. Both must be compiled and uploaded via their respective USB connections before testing the UART bridge.

Pico Master Code (Sensor Polling and Transmission)

This code reads an analog sensor on GP26, formats a payload, and transmits it via UART1. It includes a timeout error handler to prevent the main loop from hanging if the serial buffer locks.

// Target: Raspberry Pi Pico (RP2040) via Earle Philhower Core
#include 

#define UART_TX_PIN 4
#define UART_RX_PIN 5
#define SENSOR_PIN 26
#define BAUD_RATE 115200

unsigned long lastSend = 0;
const unsigned long sendInterval = 500; // ms

void setup() {
  // Initialize USB Serial for debug monitor
  Serial.begin(115200);
  while (!Serial && millis() < 3000) { delay(10); }
  
  // Configure Hardware UART1
  Serial1.setTX(UART_TX_PIN);
  Serial1.setRX(UART_RX_PIN);
  Serial1.begin(BAUD_RATE);
  
  pinMode(SENSOR_PIN, INPUT);
  Serial.println("Pico Master Initialized.");
}

void loop() {
  if (millis() - lastSend >= sendInterval) {
    lastSend = millis();
    
    int rawSensor = analogRead(SENSOR_PIN);
    float voltage = rawSensor * (3.3 / 1023.0);
    
    // Format payload with start/stop markers for reliable parsing
    char payload[32];
    snprintf(payload, sizeof(payload), "\n", voltage);
    
    Serial1.print(payload);
    Serial.print("Sent: ");
    Serial.print(payload);
  }
  
  // Non-blocking read for any acknowledgments from Micro
  if (Serial1.available()) {
    String ack = Serial1.readStringUntil('\n');
    if (ack.length() > 0) {
      Serial.print("Micro ACK: ");
      Serial.println(ack);
    }
  }
}

Micro Slave Code (Receiving and HID Prep)

This code listens on Serial1, parses the payload, and includes strict buffer overflow protection. The ATmega32U4 only has 2.5 KB of SRAM, so unhandled serial buffers will quickly cause a memory crash.

// Target: Arduino Micro (ATmega32U4) via Standard AVR Core
#include 

#define UART_RX_PIN 0
#define UART_TX_PIN 1
#define BAUD_RATE 115200
#define MAX_BUFFER 64

char receiveBuffer[MAX_BUFFER];
int bufferIndex = 0;

void setup() {
  Serial.begin(115200); // USB Debug
  Serial1.begin(BAUD_RATE); // Hardware UART on pins 0/1
  
  // Clear any garbage in the hardware buffer on boot
  while (Serial1.available()) { Serial1.read(); }
}

void loop() {
  while (Serial1.available()) {
    char c = Serial1.read();
    
    // Error Handling: Prevent buffer overflow
    if (bufferIndex >= MAX_BUFFER - 1) {
      Serial.println("ERR: Buffer Overflow, flushing.");
      bufferIndex = 0;
      while (Serial1.available()) { Serial1.read(); }
      break;
    }
    
    if (c == '\n') {
      receiveBuffer[bufferIndex] = '\0'; // Null terminate
      processPayload(receiveBuffer);
      bufferIndex = 0; // Reset for next packet
    } else {
      receiveBuffer[bufferIndex++] = c;
    }
  }
}

void processPayload(char* data) {
  // Verify start and stop markers
  if (data[0] == '<' && data[strlen(data)-2] == 'E') {
    float voltage = atof(&data[3]); // Skip '