Clawdia
405 lines
12 KiB
C
405 lines
12 KiB
C
/**
|
|
* ESP-IDF ST7735 Display Driver (basierend auf LilyGO T-Dongle-C5 Demo)
|
|
*
|
|
* GPIO-Pins für T-Dongle-C5:
|
|
* CS = GPIO10, DC = GPIO3, RST = GPIO1
|
|
* BL = GPIO0, MOSI = GPIO2, SCK = GPIO6
|
|
*
|
|
* Display: ST7735S, 80x160, Rotation 3 (invertiert), Offset x=26, y=1
|
|
*/
|
|
|
|
#include "st7735.h"
|
|
#include "esp_log.h"
|
|
#include "esp_rom_gpio.h"
|
|
#include "driver/gpio.h"
|
|
#include "driver/spi_master.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
static const char *TAG = "st7735";
|
|
|
|
/* ST7735 Register-Kommandos */
|
|
#define ST7735_NOP 0x00
|
|
#define ST7735_SWRESET 0x01
|
|
#define ST7735_RDDID 0x04
|
|
#define ST7735_RDDST 0x09
|
|
|
|
#define ST7735_SLPIN 0x10
|
|
#define ST7735_SLPOUT 0x11
|
|
#define ST7735_PTLON 0x12
|
|
#define ST7735_NORON 0x13
|
|
|
|
#define ST7735_INVOFF 0x20
|
|
#define ST7735_INVON 0x21
|
|
#define ST7735_DISPOFF 0x28
|
|
#define ST7735_DISPON 0x29
|
|
#define ST7735_CASET 0x2A
|
|
#define ST7735_RASET 0x2B
|
|
#define ST7735_RAMWR 0x2C
|
|
#define ST7735_RAMRD 0x2E
|
|
|
|
#define ST7735_PTLAR 0x30
|
|
#define ST7735_VSCRDEF 0x33
|
|
#define ST7735_COLMOD 0x3A
|
|
#define ST7735_MADCTL 0x36
|
|
#define ST7735_VSCRSADD 0x37
|
|
|
|
#define ST7735_FRMCTR1 0xB1
|
|
#define ST7735_FRMCTR2 0xB2
|
|
#define ST7735_FRMCTR3 0xB3
|
|
#define ST7735_INVCTR 0xB4
|
|
#define ST7735_DISSET5 0xB6
|
|
|
|
#define ST7735_PWCTR1 0xC0
|
|
#define ST7735_PWCTR2 0xC1
|
|
#define ST7735_PWCTR3 0xC2
|
|
#define ST7735_PWCTR4 0xC3
|
|
#define ST7735_PWCTR5 0xC4
|
|
#define ST7735_VMCTR1 0xC5
|
|
|
|
#define ST7735_PWCTR6 0xFC
|
|
|
|
#define ST7735_GMCTRP1 0xE0
|
|
#define ST7735_GMCTRN1 0xE1
|
|
|
|
/* Display Struktur */
|
|
typedef struct {
|
|
spi_device_handle_t spi;
|
|
void *display_handle;
|
|
uint8_t rotation;
|
|
uint16_t width;
|
|
uint16_t height;
|
|
int cs_gpio;
|
|
int dc_gpio;
|
|
int rst_gpio;
|
|
int bl_gpio;
|
|
int mosi_gpio;
|
|
int sck_gpio;
|
|
} st7735_dev_t;
|
|
|
|
/* Hilfsfunktion: SPI-Kommando senden */
|
|
static esp_err_t st7735_send_cmd(st7735_dev_t *dev, uint8_t cmd)
|
|
{
|
|
spi_transaction_t t;
|
|
memset(&t, 0, sizeof(t));
|
|
t.length = 8;
|
|
t.tx_buffer = &cmd;
|
|
t.user = (void *)0; // DC = LOW für Kommando
|
|
return spi_device_polling_transmit(dev->spi, &t);
|
|
}
|
|
|
|
/* Hilfsfunktion: SPI-Daten senden */
|
|
static esp_err_t st7735_send_data(st7735_dev_t *dev, const uint8_t *data, size_t len)
|
|
{
|
|
spi_transaction_t t;
|
|
memset(&t, 0, sizeof(t));
|
|
t.length = len * 8;
|
|
t.tx_buffer = data;
|
|
t.user = (void *)1; // DC = HIGH für Daten
|
|
return spi_device_polling_transmit(dev->spi, &t);
|
|
}
|
|
|
|
/* Hilfsfunktion: SPI-Array senden */
|
|
static esp_err_t st7735_send_array(st7735_dev_t *dev, const uint8_t *data, size_t len)
|
|
{
|
|
spi_transaction_t t;
|
|
memset(&t, 0, sizeof(t));
|
|
t.length = len * 8;
|
|
t.tx_buffer = data;
|
|
t.user = (void *)1;
|
|
return spi_device_polling_transmit(dev->spi, &t);
|
|
}
|
|
|
|
/* ST7735 Init-Sequenz (aus LilyGO Demo) */
|
|
static const struct {
|
|
uint8_t cmd;
|
|
const uint8_t *data;
|
|
uint8_t len;
|
|
uint32_t delay_ms;
|
|
} st7735_init_cmds[] = {
|
|
{ST7735_SWRESET, NULL, 0, 150},
|
|
{ST7735_SLPOUT, NULL, 0, 255},
|
|
{ST7735_FRMCTR1, (const uint8_t[]){0x01, 0x2C, 0x2D}, 3, 0},
|
|
{ST7735_FRMCTR2, (const uint8_t[]){0x01, 0x2C, 0x2D}, 3, 0},
|
|
{ST7735_FRMCTR3, (const uint8_t[]){0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D}, 6, 0},
|
|
{ST7735_INVCTR, (const uint8_t[]){0x07}, 1, 0},
|
|
{ST7735_PWCTR1, (const uint8_t[]){0xA2, 0x02, 0x84}, 3, 0},
|
|
{ST7735_PWCTR2, (const uint8_t[]){0xC5}, 1, 0},
|
|
{ST7735_PWCTR3, (const uint8_t[]){0x0A, 0x00}, 2, 0},
|
|
{ST7735_PWCTR4, (const uint8_t[]){0x8A, 0x2A}, 2, 0},
|
|
{ST7735_PWCTR5, (const uint8_t[]){0x8A, 0xEE}, 2, 0},
|
|
{ST7735_VMCTR1, (const uint8_t[]){0x0E}, 1, 0},
|
|
{ST7735_INVON, NULL, 0, 0},
|
|
{ST7735_COLMOD, (const uint8_t[]){0x05}, 1, 0}, // 16-bit RGB
|
|
{ST7735_GMCTRP1, (const uint8_t[]){
|
|
0x02, 0x1c, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2d,
|
|
0x29, 0x25, 0x2B, 0x39, 0x00, 0x01, 0x03, 0x10
|
|
}, 16, 0},
|
|
{ST7735_GMCTRN1, (const uint8_t[]){
|
|
0x03, 0x1d, 0x07, 0x06, 0x2E, 0x2C, 0x29, 0x2D,
|
|
0x2E, 0x2E, 0x37, 0x3F, 0x00, 0x00, 0x02, 0x10
|
|
}, 16, 0},
|
|
{ST7735_NORON, NULL, 0, 10},
|
|
{ST7735_DISPON, NULL, 0, 100},
|
|
{0x00, NULL, 0, 0}, // Ende
|
|
};
|
|
|
|
esp_err_t st7735_init(const st7735_gpio_config_t *gpio_cfg,
|
|
uint8_t rotation,
|
|
void **handle)
|
|
{
|
|
st7735_dev_t *dev = calloc(1, sizeof(st7735_dev_t));
|
|
if (!dev) {
|
|
ESP_LOGE(TAG, "Failed to allocate dev struct");
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
/* GPIO-Konfiguration (Default oder benutzerdefiniert) */
|
|
if (gpio_cfg) {
|
|
dev->cs_gpio = gpio_cfg->cs_gpio;
|
|
dev->dc_gpio = gpio_cfg->dc_gpio;
|
|
dev->rst_gpio = gpio_cfg->rst_gpio;
|
|
dev->bl_gpio = gpio_cfg->bl_gpio;
|
|
dev->mosi_gpio = gpio_cfg->mosi_gpio;
|
|
dev->sck_gpio = gpio_cfg->sck_gpio;
|
|
} else {
|
|
/* Default T-Dongle-C5 Pins */
|
|
dev->cs_gpio = 10;
|
|
dev->dc_gpio = 3;
|
|
dev->rst_gpio = 1;
|
|
dev->bl_gpio = 0;
|
|
dev->mosi_gpio = 2;
|
|
dev->sck_gpio = 6;
|
|
}
|
|
|
|
dev->rotation = rotation;
|
|
dev->width = (rotation == 1 || rotation == 3) ? 160 : 80;
|
|
dev->height = (rotation == 1 || rotation == 3) ? 80 : 160;
|
|
|
|
ESP_LOGI(TAG, "Initialisiere ST7735 (CS=%d, DC=%d, RST=%d, BL=%d)",
|
|
dev->cs_gpio, dev->dc_gpio, dev->rst_gpio, dev->bl_gpio);
|
|
|
|
/* GPIOs konfigurieren */
|
|
gpio_set_direction((gpio_num_t)dev->cs_gpio, GPIO_MODE_OUTPUT);
|
|
gpio_set_direction((gpio_num_t)dev->dc_gpio, GPIO_MODE_OUTPUT);
|
|
gpio_set_direction((gpio_num_t)dev->rst_gpio, GPIO_MODE_OUTPUT);
|
|
gpio_set_direction((gpio_num_t)dev->bl_gpio, GPIO_MODE_OUTPUT);
|
|
/* Hardware-Reset */
|
|
gpio_set_level(dev->rst_gpio, 1);
|
|
esp_rom_delay_us(100 * 1000);
|
|
gpio_set_level(dev->rst_gpio, 0);
|
|
esp_rom_delay_us(100 * 1000);
|
|
gpio_set_level(dev->rst_gpio, 1);
|
|
esp_rom_delay_us(120 * 1000);
|
|
|
|
/* Backlight aus (aktiv LOW) */
|
|
gpio_set_level(dev->bl_gpio, 1);
|
|
|
|
/* SPI initialisieren */
|
|
spi_bus_config_t bus_cfg = {
|
|
.mosi_io_num = dev->mosi_gpio,
|
|
.miso_io_num = -1,
|
|
.sclk_io_num = dev->sck_gpio,
|
|
.quadwp_io_num = -1,
|
|
.quadhd_io_num = -1,
|
|
.max_transfer_sz = 4096,
|
|
};
|
|
esp_err_t ret;
|
|
ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, 1);
|
|
if (ret != ESP_OK) {
|
|
ESP_LOGE(TAG, "SPI bus init failed: %s", esp_err_to_name(ret));
|
|
free(dev);
|
|
return ret;
|
|
}
|
|
|
|
/* SPI-Device konfigurieren */
|
|
spi_device_interface_config_t dev_cfg = {
|
|
.clock_speed_hz = 40 * 1000 * 1000, // 40 MHz
|
|
.mode = 0,
|
|
.spics_io_num = dev->cs_gpio,
|
|
.queue_size = 7,
|
|
.flags = SPI_DEVICE_NO_DUMMY,
|
|
};
|
|
ret = spi_bus_add_device(SPI2_HOST, &dev_cfg, &dev->spi);
|
|
if (ret != ESP_OK) {
|
|
ESP_LOGE(TAG, "SPI device add failed: %s", esp_err_to_name(ret));
|
|
free(dev);
|
|
return ret;
|
|
}
|
|
|
|
/* ST7735 Init-Sequenz senden */
|
|
for (int i = 0; st7735_init_cmds[i].cmd != 0x00; i++) {
|
|
st7735_send_cmd(dev, st7735_init_cmds[i].cmd);
|
|
if (st7735_init_cmds[i].data) {
|
|
st7735_send_array(dev, st7735_init_cmds[i].data, st7735_init_cmds[i].len);
|
|
}
|
|
if (st7735_init_cmds[i].delay_ms > 0) {
|
|
esp_rom_delay_us(st7735_init_cmds[i].delay_ms * 1000);
|
|
}
|
|
}
|
|
|
|
/* Rotation setzen (MADCTL) */
|
|
static const uint8_t rotation_config[4] = {
|
|
0x00, // 0°
|
|
0x60, // 90°
|
|
0xC0, // 180°
|
|
0xA0, // 270°
|
|
};
|
|
|
|
uint8_t madctl = (rotation_config[rotation] & 0xF7) | 0x08; // BGR-Mode
|
|
st7735_send_cmd(dev, ST7735_MADCTL);
|
|
st7735_send_data(dev, &madctl, 1);
|
|
|
|
ESP_LOGI(TAG, "ST7735 Display init erfolgreich (Rot=%d, %dx%d)",
|
|
rotation, dev->width, dev->height);
|
|
|
|
*handle = dev;
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t st7735_display_off(void *handle)
|
|
{
|
|
st7735_dev_t *dev = (st7735_dev_t *)handle;
|
|
st7735_send_cmd(dev, ST7735_DISPOFF);
|
|
esp_rom_delay_us(120 * 1000);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t st7735_display_on(void *handle)
|
|
{
|
|
st7735_dev_t *dev = (st7735_dev_t *)handle;
|
|
st7735_send_cmd(dev, ST7735_DISPON);
|
|
esp_rom_delay_us(100 * 1000);
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t st7735_set_addr_window(st7735_dev_t *dev, uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
|
|
{
|
|
/* Offset berücksichtigen */
|
|
if (dev->rotation == 1 || dev->rotation == 3) {
|
|
x0 += ST7735_ROW_OFFSET;
|
|
x1 += ST7735_ROW_OFFSET;
|
|
y0 += ST7735_COL_OFFSET;
|
|
y1 += ST7735_COL_OFFSET;
|
|
} else {
|
|
x0 += ST7735_COL_OFFSET;
|
|
x1 += ST7735_COL_OFFSET;
|
|
y0 += ST7735_ROW_OFFSET;
|
|
y1 += ST7735_ROW_OFFSET;
|
|
}
|
|
|
|
/* Column Address Set */
|
|
uint8_t col_data[4] = { x0 >> 8, x0 & 0xFF, x1 >> 8, x1 & 0xFF };
|
|
st7735_send_cmd(dev, ST7735_CASET);
|
|
st7735_send_array(dev, col_data, 4);
|
|
|
|
/* Row Address Set */
|
|
uint8_t row_data[4] = { y0 >> 8, y0 & 0xFF, y1 >> 8, y1 & 0xFF };
|
|
st7735_send_cmd(dev, ST7735_RASET);
|
|
st7735_send_array(dev, row_data, 4);
|
|
|
|
/* Memory Write */
|
|
st7735_send_cmd(dev, ST7735_RAMWR);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t st7735_fill_screen(void *handle, uint16_t color)
|
|
{
|
|
st7735_dev_t *dev = (st7735_dev_t *)handle;
|
|
|
|
st7735_set_addr_window(dev, 0, 0, dev->width - 1, dev->height - 1);
|
|
|
|
uint8_t color_data[2] = { color >> 8, color & 0xFF };
|
|
uint32_t total_pixels = dev->width * dev->height;
|
|
|
|
/* In Blöcken senden (max 4KB pro Transfer) */
|
|
const uint32_t block_size = 1024; // 512 pixels (2 bytes each)
|
|
uint16_t *block = malloc(block_size * sizeof(uint16_t));
|
|
if (!block) {
|
|
ESP_LOGE(TAG, "Failed to alloc block");
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < block_size; i++) {
|
|
block[i] = color;
|
|
}
|
|
|
|
while (total_pixels > 0) {
|
|
uint32_t send_count = (total_pixels > block_size) ? block_size : total_pixels;
|
|
spi_transaction_t t;
|
|
memset(&t, 0, sizeof(t));
|
|
t.length = send_count * 2 * 8;
|
|
t.tx_buffer = block;
|
|
t.user = (void *)1;
|
|
spi_device_polling_transmit(dev->spi, &t);
|
|
total_pixels -= send_count;
|
|
}
|
|
|
|
free(block);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t st7735_draw_pixel(void *handle, int16_t x, int16_t y, uint16_t color)
|
|
{
|
|
st7735_dev_t *dev = (st7735_dev_t *)handle;
|
|
|
|
if (x < 0 || x >= dev->width || y < 0 || y >= dev->height) {
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
st7735_set_addr_window(dev, x, y, x, y);
|
|
|
|
uint8_t color_data[2] = { color >> 8, color & 0xFF };
|
|
st7735_send_array(dev, color_data, 2);
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t st7735_draw_rect(void *handle, int16_t x, int16_t y,
|
|
uint16_t w, uint16_t h, uint16_t color)
|
|
{
|
|
st7735_dev_t *dev = (st7735_dev_t *)handle;
|
|
|
|
/* Rahmen zeichnen (nur Kanten) */
|
|
/* Oben */
|
|
st7735_draw_line(dev, x, y, x + w - 1, y, color);
|
|
/* Unten */
|
|
st7735_draw_line(dev, x, y + h - 1, x + w - 1, y + h - 1, color);
|
|
/* Links */
|
|
st7735_draw_line(dev, x, y, x, y + h - 1, color);
|
|
/* Rechts */
|
|
st7735_draw_line(dev, x + w - 1, y, x + w - 1, y + h - 1, color);
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t st7735_draw_line(void *handle, int16_t x0, int16_t y0,
|
|
int16_t x1, int16_t y1, uint16_t color)
|
|
{
|
|
st7735_dev_t *dev = (st7735_dev_t *)handle;
|
|
|
|
/* Bresenham's Line Algorithm */
|
|
int dx = abs(x1 - x0);
|
|
int dy = abs(y1 - y0);
|
|
int sx = (x0 < x1) ? 1 : -1;
|
|
int sy = (y0 < y1) ? 1 : -1;
|
|
int err = dx - dy;
|
|
|
|
while (1) {
|
|
st7735_draw_pixel(dev, x0, y0, color);
|
|
|
|
if (x0 == x1 && y0 == y1) break;
|
|
|
|
int e2 = 2 * err;
|
|
if (e2 > -dy) {
|
|
err -= dy;
|
|
x0 += sx;
|
|
}
|
|
if (e2 < dx) {
|
|
err += dx;
|
|
y0 += sy;
|
|
}
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|