ESP32-C3 시리얼 통신 4종 — UART·SPI·I2C·I2S 분석

1
#include "driver/uart.h"
2

3
#define UART_NUM    UART_NUM_1
4
#define TX_GPIO     7
5
#define RX_GPIO     8
6
#define BUF_SIZE    1024
7

8
void setup_uart(void) {
9
    uart_config_t cfg = {
10
        .baud_rate = 115200,
11
        .data_bits = UART_DATA_8_BITS,
12
        .parity = UART_PARITY_DISABLE,
13
        .stop_bits = UART_STOP_BITS_1,
14
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
15
        .source_clk = UART_SCLK_DEFAULT,
16
    };
17

18
    uart_driver_install(UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 0, NULL, 0);
19
    uart_param_config(UART_NUM, &cfg);
20
    uart_set_pin(UART_NUM, TX_GPIO, RX_GPIO,
21
                 UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
22
}
23

24
void uart_loopback_task(void *arg) {
25
    uint8_t buf[128];
26
    while (1) {
27
        int len = uart_read_bytes(UART_NUM, buf, sizeof(buf), pdMS_TO_TICKS(100));
28
        if (len > 0) {
29
            uart_write_bytes(UART_NUM, (const char *)buf, len);
30
        }
31
    }
32
}

1
uart_enable_pattern_det_baud_intr(UART_NUM, '\n', 1, 9, 0, 0);
2
uart_pattern_queue_reset(UART_NUM, 20);
3

4
// 이벤트 큐로 패턴 감지 알림
5
QueueHandle_t uart_queue;
6
uart_driver_install(UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2,
7
                    20, &uart_queue, 0);

1
#include "driver/spi_master.h"
2

3
#define PIN_NUM_MISO 2
4
#define PIN_NUM_MOSI 7
5
#define PIN_NUM_CLK  6
6
#define PIN_NUM_CS   10
7

8
spi_device_handle_t spi;
9

10
void setup_spi(void) {
11
    spi_bus_config_t bus_cfg = {
12
        .miso_io_num = PIN_NUM_MISO,
13
        .mosi_io_num = PIN_NUM_MOSI,
14
        .sclk_io_num = PIN_NUM_CLK,
15
        .quadwp_io_num = -1,
16
        .quadhd_io_num = -1,
17
        .max_transfer_sz = 4096,
18
    };
19
    spi_bus_initialize(SPI2_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
20

21
    spi_device_interface_config_t dev_cfg = {
22
        .clock_speed_hz = 10 * 1000 * 1000,    // 10 MHz
23
        .mode = 0,                              // CPOL=0, CPHA=0
24
        .spics_io_num = PIN_NUM_CS,
25
        .queue_size = 7,
26
    };
27
    spi_bus_add_device(SPI2_HOST, &dev_cfg, &spi);
28
}

1
// 1. Polling (가장 단순, 짧은 전송에 적합)
2
spi_transaction_t t = {
3
    .length = 8 * 4,             // 4 bytes = 32 bits
4
    .tx_buffer = data_out,
5
    .rx_buffer = data_in,
6
};
7
spi_device_polling_transmit(spi, &t);
8

9
// 2. Interrupt-based queued (큰 전송, async)
10
spi_device_queue_trans(spi, &t, portMAX_DELAY);
11
// ... 다른 작업 ...
12
spi_transaction_t *result;
13
spi_device_get_trans_result(spi, &result, portMAX_DELAY);
14

15
// 3. DMA (대용량, framebuffer 같은 것)
16
spi_transaction_t big_t = {
17
    .length = 8 * 4096,
18
    .tx_buffer = framebuffer,    // DMA-capable heap
19
    .rx_buffer = NULL,
20
};
21
spi_device_polling_transmit(spi, &big_t);

1
#include "esp_vfs_fat.h"
2
#include "driver/sdspi_host.h"
3

4
void mount_sd(void) {
5
    sdmmc_host_t host = SDSPI_HOST_DEFAULT();
6
    host.max_freq_khz = 20000;
7

8
    sdspi_device_config_t slot_cfg = SDSPI_DEVICE_CONFIG_DEFAULT();
9
    slot_cfg.gpio_cs = GPIO_NUM_10;
10
    slot_cfg.host_id = SPI2_HOST;
11

12
    esp_vfs_fat_sdmmc_mount_config_t mount_cfg = {
13
        .format_if_mount_failed = false,
14
        .max_files = 5,
15
    };
16

17
    sdmmc_card_t *card;
18
    esp_vfs_fat_sdspi_mount("/sdcard", &host, &slot_cfg,
19
                            &mount_cfg, &card);
20

21
    sdmmc_card_print_info(stdout, card);
22
}

1
#include "driver/i2c.h"
2

3
#define I2C_SDA  4
4
#define I2C_SCL  5
5
#define I2C_FREQ 400000     // 400 kHz fast mode
6

7
void setup_i2c(void) {
8
    i2c_config_t cfg = {
9
        .mode = I2C_MODE_MASTER,
10
        .sda_io_num = I2C_SDA,
11
        .scl_io_num = I2C_SCL,
12
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
13
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
14
        .master.clk_speed = I2C_FREQ,
15
    };
16
    i2c_param_config(I2C_NUM_0, &cfg);
17
    i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0);
18
}

1
// 단일 register write
2
uint8_t reg = 0x12;
3
uint8_t val = 0x34;
4
uint8_t buf[2] = {reg, val};
5
i2c_master_write_to_device(I2C_NUM_0, 0x68,    // 7-bit address
6
                            buf, 2,
7
                            pdMS_TO_TICKS(100));
8

9
// register read
10
uint8_t reg_addr = 0x12;
11
uint8_t data[6];
12
i2c_master_write_read_device(I2C_NUM_0, 0x68,
13
                              &reg_addr, 1,
14
                              data, 6,
15
                              pdMS_TO_TICKS(100));

1
#define SSD1306_ADDR 0x3C
2

3
void ssd1306_cmd(uint8_t cmd) {
4
    uint8_t buf[2] = {0x00, cmd};   // Co=0, D/C=0 (command)
5
    i2c_master_write_to_device(I2C_NUM_0, SSD1306_ADDR,
6
                                buf, 2, pdMS_TO_TICKS(50));
7
}
8

9
void ssd1306_init(void) {
10
    ssd1306_cmd(0xAE);   // display OFF
11
    ssd1306_cmd(0xD5); ssd1306_cmd(0x80);   // clock
12
    ssd1306_cmd(0xA8); ssd1306_cmd(0x3F);   // multiplex
13
    ssd1306_cmd(0xD3); ssd1306_cmd(0x00);   // offset
14
    ssd1306_cmd(0x40);                       // start line
15
    ssd1306_cmd(0x8D); ssd1306_cmd(0x14);   // charge pump
16
    ssd1306_cmd(0xAF);                       // display ON
17
}
18

19
void ssd1306_write_buffer(const uint8_t *buf, size_t len) {
20
    uint8_t *tx = malloc(len + 1);
21
    tx[0] = 0x40;                            // D/C=1 (data)
22
    memcpy(tx + 1, buf, len);
23
    i2c_master_write_to_device(I2C_NUM_0, SSD1306_ADDR,
24
                                tx, len + 1, pdMS_TO_TICKS(200));
25
    free(tx);
26
}

1
#include "driver/i2s_std.h"
2

3
#define BCK_PIN  4
4
#define WS_PIN   5
5
#define DATA_PIN 18
6

7
i2s_chan_handle_t tx_handle;
8

9
void setup_i2s(void) {
10
    i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);
11
    i2s_new_channel(&chan_cfg, &tx_handle, NULL);
12

13
    i2s_std_config_t std_cfg = {
14
        .clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(44100),
15
        .slot_cfg = I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(
16
            I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO),
17
        .gpio_cfg = {
18
            .mclk = I2S_GPIO_UNUSED,
19
            .bclk = BCK_PIN,
20
            .ws = WS_PIN,
21
            .dout = DATA_PIN,
22
            .din = I2S_GPIO_UNUSED,
23
        },
24
    };
25
    i2s_channel_init_std_mode(tx_handle, &std_cfg);
26
    i2s_channel_enable(tx_handle);
27
}
28

29
void play_sine(void) {
30
    int16_t sample;
31
    size_t written;
32
    static float phase = 0;
33
    float step = 2.0f * 3.14159f * 440.0f / 44100.0f;
34

35
    for (int i = 0; i < 44100; i++) {
36
        sample = (int16_t)(sinf(phase) * 8000);
37
        phase += step;
38
        i2s_channel_write(tx_handle, &sample, sizeof(sample),
39
                          &written, portMAX_DELAY);
40
    }
41
}

1
void i2c_scan(void) {
2
    for (uint8_t addr = 1; addr < 127; addr++) {
3
        uint8_t dummy = 0;
4
        if (i2c_master_write_to_device(I2C_NUM_0, addr, &dummy, 0,
5
                                        pdMS_TO_TICKS(50)) == ESP_OK) {
6
            printf("Found at 0x%02X\n", addr);
7
        }
8
    }
9
}