Serial UART Communication Experiment

1. UART Communication Overview

UART (Universal Asynchronous Receiver/Transmitter) is a serial communication protocol that only needs two wires, TX (transmit) and RX (receive), to achieve bidirectional data transfer.

In this experiment, machine.UART is used to configure UART1 of the ESP32-S3, continuously sending a string at 115200 baud and performing loopback reception.

Typical application scenarios:

2. Core Concepts

2.1 What is UART

UART converts parallel data into a serial bit stream, transmitted bit by bit according to the frame format:

Start bit + Data bits (5~8) + Parity bit (optional) + Stop bit (1/1.5/2)
  │            │                  │                      │
  ▼            ▼                  ▼                      ▼
 1bit       8bit (LSB)         0/1bit                  1bit

The common format 8N1 = 8 data bits, no parity, 1 stop bit (MicroPython default).

2.2 UART Parameter Selection

ESP32-S3 has 3 UARTs: UART0 (occupied by REPL), UART1 and UART2 (available to users).

2.3 Core API

​x
from machine import UART, Pin
​
uart = UART(1, baudrate=115200, tx=Pin(10), rx=Pin(11, Pin.IN, Pin.PULL_UP))  # Create UART, RX pull-up
uart.write(b'hello\r\n')                          # Send byte string
buf = uart.read(255)                               # Read up to 255 bytes
data = buf.decode('utf-8').strip()                 # Decode into a string

3. Hardware Dependencies

Loopback test: Short GPIO10 (TX) and GPIO11 (RX) with a Dupont wire to transmit and receive on its own.

Wiring diagram:

4. Project Architecture and Flow

xxxxxxxxxx
Script execution (single-file .py)
  │
  ├─ UART(1, baudrate=115200, tx=10, rx=11)
  │
  └─ while True:
       ├─ print("Sent: ...")                       // Print sent data
       ├─ uart.write(...)                          // Send
       ├─ sleep_ms(50)                             // Wait for data to fully arrive
       ├─ uart.read(255) → decode('utf-8') → print("Received:")  // Receive and print
       └─ sleep_ms(2000)                           // 2s interval

5. Source Code Details

Complete source code: 5.Source Code → MicroPython → 3.Serial Communication and Storage System → 1. UART → 1. UART.py

5.1 UART Initialization

xxxxxxxxxx
from machine import UART, Pin   # UART and Pin classes
import time                     # delay
​
# Initialize UART1 (avoid REPL UART0)
# RX pull-up to avoid garbage when floating
uart = UART(1, baudrate=115200, tx=Pin(10), rx=Pin(11, Pin.IN, Pin.PULL_UP))

5.2 Transmit and Receive

xxxxxxxxxx
# TX function
def uart_tx(data):
    uart.write(data)
​
# RX function
def uart_rx():
    buf = uart.read(255)                    # Read serial buffer, max 255 bytes
    if buf:
        try:
            print("Received:", buf.decode('utf-8').strip())   # Normal text decode
        except UnicodeError:
            print("Received raw:", buf)     # Print raw bytes on failure

5.3 Main Loop

xxxxxxxxxx
# Main logic
print("UART Started, TX=GPIO10, RX=GPIO11")
while True:
    send_str = "GOOD GOOD STUDY,DAY DAY UP!!!!!!\r\n"
    print("Sent:", send_str.strip())       # Print what was sent
    uart_tx(send_str)
    time.sleep_ms(50)                      # Brief delay for RX to complete
    uart_rx()
    time.sleep_ms(2000)                    # 2s interval

6. Operation Procedure

6.1 Flashing and Running

Thonny IDE operation steps: See MicroPython → 1. Before Development → 3.Thonny IDE.

1. Loopback test: Short GPIO10 (TX) and GPIO11 (RX) with a Dupont wire
2. Open 1. UART.py with Thonny IDE and click Run

6.2 Serial Output Example

xxxxxxxxxx
UART Started, TX=GPIO10, RX=GPIO11
Sent: GOOD GOOD STUDY,DAY DAY UP!!!!!!
Received: GOOD GOOD STUDY,DAY DAY UP!!!!!!
Sent: GOOD GOOD STUDY,DAY DAY UP!!!!!!
Received: GOOD GOOD STUDY,DAY DAY UP!!!!!!
...

6.3 Expected Behavior

Prints the received string every 2 seconds. If TX/RX is shorted correctly, the Received content is identical to the sent content.

6.4 Verification Method

7. Common Issues