SPI OLED 제어 — SSD1306·Frame Buffer·Page 단위 갱신

1
OLED        역할
2
─────       ────
3
GND         GND
4
VCC         3.3V
5
SCL         SPI clock
6
SDA         SPI MOSI
7
RES         reset (active-low)
8
DC          0=command, 1=data
9
CS          chip select (active-low)

1
Page 0: rows 0-7   (1 byte vertical per col)
2
Page 1: rows 8-15
3
...
4
Page 7: rows 56-63
5

6
Total: 8 page × 128 col × 1 byte = 1024 bytes

1
Horizontal: col 증가 후 page wrap → 좌상부터 우하까지 일렬
2
Vertical:   page 증가 후 col wrap
3
Page:       한 page 안에서만, page는 수동 set

1
const uint8_t ssd1306_init[] = {
2
    0xAE,                   // display OFF
3
    0xD5, 0x80,             // clock divider
4
    0xA8, 0x3F,             // multiplex 1/64
5
    0xD3, 0x00,             // display offset 0
6
    0x40,                   // start line 0
7
    0x8D, 0x14,             // charge pump enable
8
    0x20, 0x00,             // horizontal addressing mode
9
    0xA1,                   // segment remap (mirror)
10
    0xC8,                   // COM scan dir (mirror)
11
    0xDA, 0x12,             // COM pins config
12
    0x81, 0xCF,             // contrast
13
    0xD9, 0xF1,             // pre-charge
14
    0xDB, 0x40,             // VCOMH deselect level
15
    0xA4,                   // output follows RAM
16
    0xA6,                   // normal display (not inverted)
17
    0xAF,                   // display ON
18
};

1
// CS=PA4, DC=PA3, RES=PA2 + SPI1 (PA5/6/7)
2
static void oled_send_cmd(uint8_t cmd) {
3
    GPIOA->BSRR = (1u << (3+16));   // DC=0 (command)
4
    GPIOA->BSRR = (1u << (4+16));   // CS=0
5
    spi_xfer8(cmd);
6
    while (SPI1->SR & SPI_SR_BSY);
7
    GPIOA->BSRR = (1u << 4);
8
}
9

10
static void oled_send_data(const uint8_t *data, uint16_t n) {
11
    GPIOA->BSRR = (1u << 3);        // DC=1 (data)
12
    GPIOA->BSRR = (1u << (4+16));   // CS=0
13
    for (uint16_t i = 0; i < n; i++) spi_xfer8(data[i]);
14
    while (SPI1->SR & SPI_SR_BSY);
15
    GPIOA->BSRR = (1u << 4);
16
}

1
void oled_init(void) {
2
    // GPIO setup
3
    gpio_init(GPIOA, 2, &(gpio_config_t){.mode=GPIO_MODE_OUTPUT});  // RES
4
    gpio_init(GPIOA, 3, &(gpio_config_t){.mode=GPIO_MODE_OUTPUT});  // DC
5
    gpio_init(GPIOA, 4, &(gpio_config_t){.mode=GPIO_MODE_OUTPUT});  // CS
6
    GPIOA->BSRR = (1u << 4);    // CS high (deselect)
7

8
    // Hardware reset
9
    GPIOA->BSRR = (1u << (2+16));
10
    delay_ms(10);
11
    GPIOA->BSRR = (1u << 2);
12
    delay_ms(10);
13

14
    // SPI is already initialized (e.g., 10 MHz, mode 0)
15
    for (size_t i = 0; i < sizeof(ssd1306_init); i++) {
16
        oled_send_cmd(ssd1306_init[i]);
17
    }
18
}

1
#define OLED_W 128
2
#define OLED_H 64
3

4
static uint8_t fb[OLED_W * OLED_H / 8];   // 1024 bytes
5

6
void oled_clear(void) {
7
    memset(fb, 0, sizeof(fb));
8
}
9

10
void oled_pixel(int16_t x, int16_t y, int on) {
11
    if (x < 0 || x >= OLED_W || y < 0 || y >= OLED_H) return;
12
    uint16_t idx = (y / 8) * OLED_W + x;
13
    uint8_t  bit = 1u << (y % 8);
14
    if (on) fb[idx] |= bit;
15
    else    fb[idx] &= ~bit;
16
}
17

18
void oled_flush(void) {
19
    oled_send_cmd(0x21); oled_send_cmd(0); oled_send_cmd(127);   // col range
20
    oled_send_cmd(0x22); oled_send_cmd(0); oled_send_cmd(7);     // page range
21
    oled_send_data(fb, sizeof(fb));
22
}

1
void oled_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1) {
2
    int16_t dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
3
    int16_t dy = -abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
4
    int16_t err = dx + dy;
5

6
    while (1) {
7
        oled_pixel(x0, y0, 1);
8
        if (x0 == x1 && y0 == y1) break;
9
        int16_t e2 = err * 2;
10
        if (e2 >= dy) { err += dy; x0 += sx; }
11
        if (e2 <= dx) { err += dx; y0 += sy; }
12
    }
13
}

1
#include "font5x7.h"   // 95 character × 5 byte each
2

3
void oled_char(int16_t x, int16_t y, char c) {
4
    if (c < 32 || c > 126) c = '?';
5
    const uint8_t *glyph = font5x7[c - 32];
6
    for (int col = 0; col < 5; col++) {
7
        uint8_t byte = glyph[col];
8
        for (int row = 0; row < 7; row++) {
9
            if (byte & (1 << row))
10
                oled_pixel(x + col, y + row, 1);
11
        }
12
    }
13
}
14

15
void oled_text(int16_t x, int16_t y, const char *s) {
16
    while (*s) {
17
        oled_char(x, y, *s++);
18
        x += 6;
19
    }
20
}

1
void oled_flush_dma(void) {
2
    oled_send_cmd(0x21); oled_send_cmd(0); oled_send_cmd(127);
3
    oled_send_cmd(0x22); oled_send_cmd(0); oled_send_cmd(7);
4

5
    GPIOA->BSRR = (1u << 3);              // DC=1
6
    GPIOA->BSRR = (1u << (4+16));         // CS=0
7

8
    DMA2_Stream3->M0AR = (uint32_t)fb;
9
    DMA2_Stream3->NDTR = sizeof(fb);
10
    DMA2_Stream3->CR  |= DMA_SxCR_EN;
11
}
12

13
void DMA2_Stream3_IRQHandler(void) {
14
    DMA2->LIFCR = DMA_LIFCR_CTCIF3;
15
    while (SPI1->SR & SPI_SR_BSY);
16
    GPIOA->BSRR = (1u << 4);              // CS high
17
}