Modern Embedded Recipes · 41/152

UART 드라이버 구현 — polling·interrupt·DMA 3가지 방식 비교

2026년 4월 13일 · Hawk · 5분 읽기

#한 줄 요약

“Polling은 단순, interrupt는 균형, DMA는 throughput.” UART 드라이버 세 변종은 각각 다른 trade-off를 다룹니다.

#어떤 상황에서 쓰나

UART는 임베디드의 lingua franca입니다. printf 디버깅, sensor 통신, GPS 수신, BLE module 제어, console — 거의 모든 보드에 한 두 채널은 살아 있습니다. 같은 peripheral이라도 언제 어떻게 사용하느냐에 따라 polling, interrupt, DMA 세 방식을 선택합니다.

이 글은 STM32 USART를 기준으로 세 방식의 드라이버 코드를 모두 작성하고, 각각의 성능과 CPU 부담을 비교합니다.

#핵심 개념

#USART register (STM32F4)

Register	역할
`CR1`	enable (UE), word length (M), TE/RE, RXNEIE, TXEIE, TCIE
`CR2`	stop bits, clock polarity
`CR3`	flow control (CTS/RTS), DMA enable
`BRR`	baud rate divider
`SR`	RXNE, TXE, TC, ORE, FE, PE flags
`DR`	data register (read=RX, write=TX)

STM32F7/H7/G0/G4 등 신규는 register 이름이 약간 다릅니다 (ISR, RDR, TDR, ICR).

#Baud rate 계산

1
USARTDIV = f_pclk / (8 × (2 - OVER8) × baud)
2

3
OVER8 = 0 (16x oversample, default) → USARTDIV = f_pclk / (16 × baud)
4

5
예) PCLK1 = 42 MHz, baud = 115200
6
    USARTDIV = 42000000 / (16 × 115200) ≈ 22.7864
7

8
    Mantissa = 22 = 0x16
9
    Fraction = round(0.7864 × 16) = 13 = 0xD
10
    BRR = (0x16 << 4) | 0xD = 0x16D

대부분의 STM32 HAL은 family 규칙에 맞춰 자동 계산해 줍니다. 직접 작성할 때는 oversampling, clock tolerance, frame format과 상대편 수신기 허용 오차를 함께 계산해야 하며, ±2%는 모든 조건에 적용되는 보편적인 보장값이 아닙니다.

#세 방식의 trade-off

방식	CPU 사용량	latency	throughput	복잡도
Polling	매우 높음 (waste)	매우 빠름	낮음	단순
Interrupt	중간 (ISR overhead)	빠름	중간	보통
DMA	가장 낮음	약간 느림 (DMA setup)	가장 높음	복잡

DMA는 연속 바이트 처리량에서 압도적이지만, setup overhead 때문에 짧은 전송에는 오히려 손해입니다.

#코드 예제

#1. Polling UART

1
void uart_init_polling(uint32_t baud, uint32_t pclk) {
2
    RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
3
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
4

5
    // PA9 TX, PA10 RX (AF7)
6
    gpio_init(GPIOA, 9,  &(gpio_config_t){.mode=GPIO_MODE_AF, .speed=GPIO_SPEED_HIGH, .af=7});
7
    gpio_init(GPIOA, 10, &(gpio_config_t){.mode=GPIO_MODE_AF, .pull=GPIO_PULL_UP,     .af=7});
8

9
    USART1->BRR = (pclk + baud / 2) / baud;   // round
10
    USART1->CR1 = USART_CR1_UE | USART_CR1_TE | USART_CR1_RE;
11
}
12

13
void uart_putc(char c) {
14
    while (!(USART1->SR & USART_SR_TXE));   // wait TX buffer empty
15
    USART1->DR = c;
16
}
17

18
int uart_getc(void) {
19
    while (!(USART1->SR & USART_SR_RXNE));  // block until RX
20
    return USART1->DR;
21
}
22

23
void uart_puts(const char *s) {
24
    while (*s) uart_putc(*s++);
25
}

단순합니다. 단점은 TX/RX 동안 CPU를 묶는다는 점. printf 한 줄로 수 ms를 날립니다.

#2. Interrupt + ring buffer

1
#define RX_BUF_SIZE 256
2
#define TX_BUF_SIZE 256
3

4
static volatile uint8_t rx_buf[RX_BUF_SIZE];
5
static volatile uint16_t rx_head, rx_tail;
6
static volatile uint8_t tx_buf[TX_BUF_SIZE];
7
static volatile uint16_t tx_head, tx_tail;
8

9
void uart_init_int(uint32_t baud, uint32_t pclk) {
10
    // ... GPIO + clock 동일
11
    USART1->BRR = (pclk + baud / 2) / baud;
12
    USART1->CR1 = USART_CR1_UE | USART_CR1_TE | USART_CR1_RE
13
                | USART_CR1_RXNEIE;
14
    NVIC_SetPriority(USART1_IRQn, 8);
15
    NVIC_EnableIRQ(USART1_IRQn);
16
}
17

18
void USART1_IRQHandler(void) {
19
    uint32_t sr = USART1->SR;
20

21
    // RX
22
    if (sr & USART_SR_RXNE) {
23
        uint8_t c = USART1->DR;
24
        uint16_t next = (rx_head + 1) % RX_BUF_SIZE;
25
        if (next != rx_tail) {
26
            rx_buf[rx_head] = c;
27
            rx_head = next;
28
        }   // else overflow — drop
29
    }
30

31
    // TX
32
    if ((sr & USART_SR_TXE) && (USART1->CR1 & USART_CR1_TXEIE)) {
33
        if (tx_tail != tx_head) {
34
            USART1->DR = tx_buf[tx_tail];
35
            tx_tail = (tx_tail + 1) % TX_BUF_SIZE;
36
        } else {
37
            USART1->CR1 &= ~USART_CR1_TXEIE;   // empty — disable
38
        }
39
    }
40
}
41

42
int uart_putc_nb(char c) {
43
    uint16_t next = (tx_head + 1) % TX_BUF_SIZE;
44
    if (next == tx_tail) return -1;   // full
45
    tx_buf[tx_head] = c;
46
    tx_head = next;
47
    USART1->CR1 |= USART_CR1_TXEIE;
48
    return 0;
49
}
50

51
int uart_getc_nb(void) {
52
    if (rx_head == rx_tail) return -1;
53
    uint8_t c = rx_buf[rx_tail];
54
    rx_tail = (rx_tail + 1) % RX_BUF_SIZE;
55
    return c;
56
}

이제 main loop은 다른 일을 하면서도 UART RX를 놓치지 않습니다.

#3. DMA UART

1
static uint8_t dma_rx_buf[256];
2
static uint8_t dma_tx_buf[256];
3

4
void uart_init_dma(uint32_t baud, uint32_t pclk) {
5
    // GPIO + USART1 enable 동일
6
    USART1->BRR = (pclk + baud / 2) / baud;
7
    USART1->CR1 = USART_CR1_UE | USART_CR1_TE | USART_CR1_RE;
8
    USART1->CR3 = USART_CR3_DMAT | USART_CR3_DMAR;
9

10
    RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;
11

12
    // RX DMA — 아래 Stream/Channel은 특정 STM32F4 예시
13
    DMA2_Stream2->CR = 0;
14
    while (DMA2_Stream2->CR & DMA_SxCR_EN);
15
    DMA2_Stream2->PAR  = (uint32_t)&USART1->DR;
16
    DMA2_Stream2->M0AR = (uint32_t)dma_rx_buf;
17
    DMA2_Stream2->NDTR = sizeof(dma_rx_buf);
18
    DMA2_Stream2->CR   = (4u << 25)             // channel 4
19
                       | DMA_SxCR_CIRC          // circular
20
                       | DMA_SxCR_MINC          // memory inc
21
                       | DMA_SxCR_EN;
22

23
    // TX DMA — 아래 Stream/Channel은 특정 STM32F4 예시
24
    DMA2_Stream7->CR = 0;
25
    while (DMA2_Stream7->CR & DMA_SxCR_EN);
26
    DMA2_Stream7->PAR  = (uint32_t)&USART1->DR;
27
    DMA2_Stream7->CR   = (4u << 25)
28
                       | DMA_SxCR_DIR_0          // mem → peripheral
29
                       | DMA_SxCR_MINC
30
                       | DMA_SxCR_TCIE;
31
    NVIC_EnableIRQ(DMA2_Stream7_IRQn);
32
}
33

34
void uart_send_dma(const uint8_t *buf, uint16_t len) {
35
    while (DMA2_Stream7->CR & DMA_SxCR_EN);   // wait previous
36
    DMA2_Stream7->NDTR = len;
37
    DMA2_Stream7->M0AR = (uint32_t)buf;
38
    DMA2->HIFCR = 0x3F << 22;                 // clear flags
39
    DMA2_Stream7->CR |= DMA_SxCR_EN;
40
}

RX는 circular mode로 두면 DMA가 알아서 ring buffer처럼 돌립니다. main은 NDTR을 폴링해 얼마나 들어왔는지 파악합니다.

#측정 / 동작 확인

오실로스코프 + 로직 애널라이저로 TX 핀을 보면 byte 사이 gap이 명확합니다.

1
Polling 모드, 115200 baud (8N1, 87 µs per byte):
2
TX: byte | gap 0~5 µs | byte | gap 0~5 µs | ...   ← back-to-back
3

4
Interrupt 모드:
5
TX: byte | gap 3~10 µs (ISR overhead) | byte | ...
6

7
DMA 모드:
8
TX: byte | gap < 1 µs | byte | ...   ← 거의 perfect back-to-back

throughput 측정은 1KB 전송 시간을 비교합니다.

Mode	1 KB @ 115200	CPU 점유율
Polling	89.0 ms	100%
Interrupt	89.5 ms	~5%
DMA	89.0 ms	< 1%

baud rate가 한계를 정하므로 시간은 비슷하지만, CPU가 자유롭다는 점에서 DMA가 압도적입니다.

#자주 보는 함정

⚠️ Baud rate 오차를 고정 한계로 가정

허용 가능한 baud 오차는 oversampling과 frame, 양쪽 clock tolerance에 따라 달라집니다. HSI의 실제 오차와 온도 범위를 확인하고, 정확도가 필요한 경우 외부 clock 또는 보정된 source를 고려합니다.

⚠️ ORE (overrun) flag 무시

수신이 처리보다 빠르면 ORE가 set될 수 있습니다. flag clear 순서와 이후 RXNE 동작은 USART family마다 다르므로 reference manual을 따르고, STM32F4의 해당 구성에서는 SR read → DR read 순서를 확인합니다.

⚠️ Ring buffer head/tail이 atomic하지 않음

정렬된 native-width load/store는 일부 Cortex-M에서 atomic이지만, ring buffer의 producer/consumer 설계와 memory ordering까지 자동으로 해결하지는 않습니다. head/tail의 ownership을 분리하고 필요하면 critical section 또는 atomic primitive를 사용합니다.

⚠️ TXE와 TC 혼동

TXE = TX buffer empty (다음 데이터 넣어도 됨). TC = transmission complete (마지막 bit까지 나간 뒤). half-duplex나 RS-485 enable line 제어에는 TC를 봐야 합니다.

⚠️ DMA TX 끝나기 전에 다시 enable

while (DMA->CR & EN) 폴링을 빼먹으면 DMA가 중간에 끊깁니다. flush 또는 TC interrupt로 동기화합니다.

⚠️ Flow control이 없는 상태에서 high-speed

높은 baud에서 flow control 없이 운용할 수 있는지는 receiver service latency, buffer와 protocol에 따라 달라집니다. 손실을 허용하지 못하면 CTS/RTS나 software flow control, 충분한 buffering을 설계합니다.

#정리

Polling은 단순하고 latency가 낮지만 CPU를 묶습니다. 부트로더·디버그에 적합.
Interrupt + ring buffer는 일반 용도 표준. RX overflow 처리 필수.
DMA는 throughput 최고, CPU 부담 최소. circular RX + linear TX가 표준 패턴.
Flag clear 순서는 USART family/reference manual의 규칙을 따릅니다.
baud rate 정확도는 clock tolerance·oversampling·frame 조건을 포함해 검증합니다.

다음 편은 SPI 드라이버입니다. CPOL/CPHA, multi-slave CS, full-duplex DMA를 다룹니다.

#관련 항목

Modern Embedded Recipes · 42 of 152

SPI 드라이버 구현 — Master·Slave·CRC·DMA

Master/slave·CPOL/CPHA·DMA·multi-slave CS.

2026년 4월 13일 · recipes

같은 시리즈에서 이어 읽기

I2C 드라이버 구현 — Master·7-bit/10-bit·Clock Stretching 처리

Master·repeated start·NACK 처리·timeout.