ESP32 Bit Pirate

ESP32-S3 UART protocol debugging

Debug UART serial consoles and bridge devices

ESP32 Bit Pirate turns a compatible ESP32-S3 board into a UART serial console, bridge and traffic inspection workbench. Use it to detect baud rates, bridge target consoles, inspect raw bytes and debug half-duplex links.

Explore the ESP32 Bit Pirate site index Open the GitHub project
UART debugging visual with an ESP32 board and serial target modules

Quick UART workflow

Start by making the serial link observable. Once the target speaks, choose the recipe for bridging, sniffing, raw bytes, AT commands or half-duplex work.

  1. 01

    Connect GND first, then identify the target TX and RX pads.

  2. 02

    Confirm the target voltage level before connecting ESP32 GPIO.

  3. 03

    Start UART mode on ESP32 Bit Pirate.

  4. 04

    Use autobaud or configure baud rate, data bits, parity, stop bits and inversion.

  5. 05

    Read, sniff, bridge or continue with the recipe that matches the target behavior.

mode uart
autobaud
read
raw
bridge

Example CLI flow. See the UART wiki for exact syntax and firmware-specific options.

UART workflows covered by ESP32 Bit Pirate

Use this overview to choose the right serial workflow before opening a detailed recipe.

Baud

UART baud rate detection

Listen for target serial activity and use the detected rate as a starting point for readable logs or console bridging.

Bridge

UART console bridge

Interact with a target console once RX, TX, ground, voltage and serial format are known.

Sniff

Passive UART sniffing

Observe boot logs or device-to-device serial traffic without sending bytes onto the target link.

Raw

Raw hex byte view

Inspect binary frames, control bytes, packet headers and checksums when printable text is not enough.

AT

AT command shell

Work with modem-style serial modules where repeated commands, responses and line endings matter.

HDUART

Half-duplex UART debugging

Use the single-wire serial path when a device shares one line for transmit and receive.

When an ESP32-S3 UART workbench helps

UART debugging is often about discovering what a board is already saying. A small external tool can reveal speed, format, direction and timing before you integrate a target into your own firmware.

Unknown console

Before writing automation

Find the baud rate, confirm text output and decide whether the port is a read-only log or an interactive shell.

Repair bench

Before changing firmware

Use serial logs, boot messages and console bridges to understand a board before flashing, erasing or modifying it.

Passive debug

Before injecting bytes

Sniff first when two devices already talk to each other and you need to avoid disturbing the bus.

UART hardware reminders

These notes are intentionally short. The detailed command references live in the project documentation and firmware repository.

Ground first

UART needs a shared ground reference. Without it, readable text and reliable input are mostly luck.

Voltage levels

ESP32 GPIO is 3.3 V; choose level adaptation before UART tests on 1.8 V or 5 V hardware.

RX and TX direction

A target TX pin connects to the Bit Pirate RX GPIO. A target RX pin connects to the Bit Pirate TX GPIO.

Serial format

Baud rate is only one setting. Data bits, parity, stop bits and inverted signaling can all change what you see.

Half-duplex links

Single-wire buses need HDUART-style handling so the tool does not drive the line while the target is talking.

Safe probing

Start read-only, avoid powering unknown boards blindly and keep write, bridge or spam tests for devices you own or have permission to debug.

Common UART problems

Most UART failures come from wiring direction, missing ground, wrong format settings or target consoles that only speak during boot.

No text

Check common ground, target TX to Bit Pirate RX, target power and whether the console only emits data during reset.

Garbled output

Try autobaud, then check data bits, parity, stop bits, inversion and voltage-level mismatch.

No response

Check RX/TX crossing, line endings, console lock state and whether the target accepts input at that boot stage.

Binary-looking data

Switch to raw hex before assuming the link is broken; many serial protocols are not plain text.

Half-duplex contention

Use the HDUART workflow for shared-wire serial links and avoid driving while the target is transmitting.

Board choice for UART work

UART can be done from most supported boards, but the best choice depends on whether you want a portable console or a flexible bench wiring setup.

Portable console

Cardputer is the most natural choice when the built-in screen, keyboard and battery matter more than many exposed pins.

Bench wiring

ESP32-S3 DevKit is easier for RX/TX/GND wiring, level adapters and repeatable serial fixtures.

Detailed UART recipes

These pages are the task-level UART workflows. This overview keeps the protocol-level guidance here, while each recipe covers wiring, commands and troubleshooting in detail.

Useful UART references

This page is a protocol overview. Use the site index for the full web experience, or GitHub for source code, firmware documentation and the UART command reference.

Flash ESP32 Bit Pirate

Flash a supported ESP32-S3 board before testing UART mode from the browser.

Open Web Flasher

ESP32 Bit Pirate GitHub

Check firmware source, issues and releases that affect UART support.

Open GitHub repository

UART debugging FAQ

Short answers for common questions before moving into a detailed workflow.

Can ESP32 Bit Pirate detect an unknown UART baud rate?

Yes. ESP32 Bit Pirate can listen for serial activity with autobaud and use the detected rate as a starting point for reading or bridging a target console.

Can ESP32 Bit Pirate bridge a UART console?

Yes. After RX, TX, ground, voltage and serial format are known, bridge mode lets your terminal interact with the target UART.

Can ESP32 Bit Pirate sniff UART traffic passively?

Yes. Use a read-only sniffing workflow when you need to observe serial traffic between two boards without injecting bytes.