Files
iroBot/main/main.c
Neil Arora db70cbccaf Add SH8601 LCD driver and logo asset
Introduces the esp_lcd_sh8601 component with driver source, header, and configuration files. Adds a logo asset and updates project configuration and metadata to support the new display and branding.
2026-01-13 00:09:57 +05:30

469 lines
15 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* LVGL GIF display for ESP32-S3 Touch AMOLED 1.8" (SH8601)
* Ported from ST7789 to SH8601 QSPI AMOLED display
*/
#include <stdio.h>
#include "esp_err.h"
#include "esp_log.h"
#include "esp_check.h"
#include "driver/gpio.h"
#include "driver/i2c.h"
#include "driver/spi_master.h"
#include "esp_timer.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_ops.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_heap_caps.h"
#include "lvgl.h"
<<<<<<< Updated upstream
#include "src/extra/libs/gif/lv_gif.h"
#include "emotions/facetestLCD.h"
=======
#include "esp_lcd_sh8601.h"
#include "esp_lcd_touch_ft5x06.h"
>>>>>>> Stashed changes
#include "esp_io_expander_tca9554.h"
#include "../assets/logoIro.c"
static const char *TAG = "LVGL_AMOLED";
/* LCD Host */
#define LCD_HOST SPI2_HOST
#define TOUCH_HOST I2C_NUM_0
/* Color depth configuration */
#if CONFIG_LV_COLOR_DEPTH == 32
#define LCD_BIT_PER_PIXEL (24)
#elif CONFIG_LV_COLOR_DEPTH == 16
#define LCD_BIT_PER_PIXEL (16)
#else
#define LCD_BIT_PER_PIXEL (16)
#endif
/* LCD settings for ESP32-S3 Touch AMOLED 1.8" */
#define LCD_H_RES (368)
#define LCD_V_RES (448)
/* LCD QSPI pins */
#define PIN_NUM_LCD_CS (GPIO_NUM_12)
#define PIN_NUM_LCD_PCLK (GPIO_NUM_11)
#define PIN_NUM_LCD_DATA0 (GPIO_NUM_4)
#define PIN_NUM_LCD_DATA1 (GPIO_NUM_5)
#define PIN_NUM_LCD_DATA2 (GPIO_NUM_6)
#define PIN_NUM_LCD_DATA3 (GPIO_NUM_7)
#define PIN_NUM_LCD_RST (-1) /* Reset via IO expander */
#define PIN_NUM_BK_LIGHT (-1) /* Backlight via IO expander */
/* Touch I2C pins */
#define PIN_NUM_TOUCH_SCL (GPIO_NUM_14)
#define PIN_NUM_TOUCH_SDA (GPIO_NUM_15)
#define PIN_NUM_TOUCH_RST (-1) /* Reset via IO expander */
#define PIN_NUM_TOUCH_INT (GPIO_NUM_21)
/* Enable touch support */
#define USE_TOUCH 1
/* LVGL configuration */
#define LVGL_BUF_HEIGHT (LCD_V_RES / 4)
#define LVGL_TICK_PERIOD_MS 2
#define LVGL_TASK_MAX_DELAY_MS 500
#define LVGL_TASK_MIN_DELAY_MS 1
#define LVGL_TASK_STACK_SIZE (8 * 1024)
#define LVGL_TASK_PRIORITY 4
/* LCD IO and panel handles */
static esp_lcd_panel_io_handle_t lcd_io = NULL;
static esp_lcd_panel_handle_t lcd_panel = NULL;
#if USE_TOUCH
static esp_lcd_touch_handle_t tp = NULL;
#endif
<<<<<<< Updated upstream
static lv_obj_t *g_lvgl_gif = NULL;
static const lv_img_dsc_t g_lvgl_gif_src = {
.header.always_zero = 0,
.header.w = 240,
.header.h = 135,
.header.cf = LV_IMG_CF_RAW,
.data_size = sizeof(facetestLCD),
.data = facetestLCD,
=======
/* LVGL mutex for thread safety */
static SemaphoreHandle_t lvgl_mux = NULL;
/* LCD initialization commands for SH8601 */
static const sh8601_lcd_init_cmd_t lcd_init_cmds[] = {
{0x11, (uint8_t[]){0x00}, 0, 120},
{0x44, (uint8_t[]){0x01, 0xD1}, 2, 0},
{0x35, (uint8_t[]){0x00}, 1, 0},
{0x53, (uint8_t[]){0x20}, 1, 10},
{0x2A, (uint8_t[]){0x00, 0x00, 0x01, 0x6F}, 4, 0}, /* Column address: 0-367 */
{0x2B, (uint8_t[]){0x00, 0x00, 0x01, 0xBF}, 4, 0}, /* Row address: 0-447 */
{0x51, (uint8_t[]){0x00}, 1, 10},
{0x29, (uint8_t[]){0x00}, 0, 10},
{0x51, (uint8_t[]){0xFF}, 1, 0}, /* Max brightness */
>>>>>>> Stashed changes
};
/* LVGL display driver variable (for flush callback) */
static lv_disp_drv_t disp_drv;
static bool notify_lvgl_flush_ready(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
{
<<<<<<< Updated upstream
g_lvgl_gif = lv_gif_create(parent);
lv_gif_set_src(g_lvgl_gif, &g_lvgl_gif_src);
lv_obj_align(g_lvgl_gif, LV_ALIGN_CENTER, 0, 0);
return ESP_OK;
=======
lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;
lv_disp_flush_ready(disp_driver);
return false;
>>>>>>> Stashed changes
}
static void lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
const int offsetx1 = area->x1;
const int offsetx2 = area->x2;
const int offsety1 = area->y1;
const int offsety2 = area->y2;
#if LCD_BIT_PER_PIXEL == 24
/* Convert LVGL color format to RGB888 for 24-bit mode */
uint8_t *to = (uint8_t *)color_map;
uint8_t temp = 0;
uint16_t pixel_num = (offsetx2 - offsetx1 + 1) * (offsety2 - offsety1 + 1);
temp = color_map[0].ch.blue;
*to++ = color_map[0].ch.red;
*to++ = color_map[0].ch.green;
*to++ = temp;
for (int i = 1; i < pixel_num; i++) {
*to++ = color_map[i].ch.red;
*to++ = color_map[i].ch.green;
*to++ = color_map[i].ch.blue;
}
#endif
esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map);
}
static void lvgl_update_cb(lv_disp_drv_t *drv)
{
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
switch (drv->rotated) {
case LV_DISP_ROT_NONE:
esp_lcd_panel_swap_xy(panel_handle, false);
esp_lcd_panel_mirror(panel_handle, false, false);
break;
case LV_DISP_ROT_90:
esp_lcd_panel_swap_xy(panel_handle, true);
esp_lcd_panel_mirror(panel_handle, false, false);
break;
case LV_DISP_ROT_180:
esp_lcd_panel_swap_xy(panel_handle, false);
esp_lcd_panel_mirror(panel_handle, true, false);
break;
case LV_DISP_ROT_270:
esp_lcd_panel_swap_xy(panel_handle, true);
esp_lcd_panel_mirror(panel_handle, true, false);
break;
}
}
void lvgl_rounder_cb(struct _lv_disp_drv_t *disp_drv, lv_area_t *area)
{
/* Round coordinates to even numbers (required by SH8601) */
uint16_t x1 = area->x1;
uint16_t x2 = area->x2;
uint16_t y1 = area->y1;
uint16_t y2 = area->y2;
area->x1 = (x1 >> 1) << 1;
area->y1 = (y1 >> 1) << 1;
area->x2 = ((x2 >> 1) << 1) + 1;
area->y2 = ((y2 >> 1) << 1) + 1;
}
#if USE_TOUCH
static void lvgl_touch_cb(lv_indev_drv_t *drv, lv_indev_data_t *data)
{
esp_lcd_touch_handle_t touch_handle = (esp_lcd_touch_handle_t)drv->user_data;
assert(touch_handle);
uint16_t tp_x;
uint16_t tp_y;
uint8_t tp_cnt = 0;
esp_lcd_touch_read_data(touch_handle);
bool tp_pressed = esp_lcd_touch_get_coordinates(touch_handle, &tp_x, &tp_y, NULL, &tp_cnt, 1);
if (tp_pressed && tp_cnt > 0) {
data->point.x = tp_x;
data->point.y = tp_y;
data->state = LV_INDEV_STATE_PRESSED;
ESP_LOGD(TAG, "Touch position: %d,%d", tp_x, tp_y);
} else {
data->state = LV_INDEV_STATE_RELEASED;
}
}
#endif
static void increase_lvgl_tick(void *arg)
{
lv_tick_inc(LVGL_TICK_PERIOD_MS);
}
static bool lvgl_lock(int timeout_ms)
{
assert(lvgl_mux && "LVGL mutex not initialized");
const TickType_t timeout_ticks = (timeout_ms == -1) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms);
return xSemaphoreTake(lvgl_mux, timeout_ticks) == pdTRUE;
}
static void lvgl_unlock(void)
{
assert(lvgl_mux && "LVGL mutex not initialized");
xSemaphoreGive(lvgl_mux);
}
static void lvgl_port_task(void *arg)
{
ESP_LOGI(TAG, "Starting LVGL task");
uint32_t task_delay_ms = LVGL_TASK_MAX_DELAY_MS;
while (1) {
if (lvgl_lock(-1)) {
task_delay_ms = lv_timer_handler();
lvgl_unlock();
}
if (task_delay_ms > LVGL_TASK_MAX_DELAY_MS) {
task_delay_ms = LVGL_TASK_MAX_DELAY_MS;
} else if (task_delay_ms < LVGL_TASK_MIN_DELAY_MS) {
task_delay_ms = LVGL_TASK_MIN_DELAY_MS;
}
vTaskDelay(pdMS_TO_TICKS(task_delay_ms));
}
}
void app_main(void)
{
ESP_LOGI(TAG, "Starting LVGL AMOLED application");
/* Suppress some verbose logging */
esp_log_level_set("lcd_panel.io.i2c", ESP_LOG_NONE);
esp_log_level_set("FT5x06", ESP_LOG_NONE);
<<<<<<< Updated upstream
/* Background */
lv_obj_set_style_bg_color(scr, lv_color_hex(0xD6F6CD), LV_PART_MAIN);
lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, LV_PART_MAIN);
=======
static lv_disp_draw_buf_t disp_buf;
>>>>>>> Stashed changes
/* Initialize I2C bus for touch and IO expander */
ESP_LOGI(TAG, "Initialize I2C bus");
const i2c_config_t i2c_conf = {
.mode = I2C_MODE_MASTER,
.sda_io_num = PIN_NUM_TOUCH_SDA,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_io_num = PIN_NUM_TOUCH_SCL,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master.clk_speed = 200 * 1000,
};
ESP_ERROR_CHECK(i2c_param_config(TOUCH_HOST, &i2c_conf));
ESP_ERROR_CHECK(i2c_driver_install(TOUCH_HOST, i2c_conf.mode, 0, 0, 0));
<<<<<<< Updated upstream
ESP_ERROR_CHECK(app_gif_init_lvgl(scr));
=======
/* Initialize IO expander (TCA9554) for LCD/Touch reset and backlight */
ESP_LOGI(TAG, "Initialize IO expander");
esp_io_expander_handle_t io_expander = NULL;
ESP_ERROR_CHECK(esp_io_expander_new_i2c_tca9554(TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander));
/* Configure IO expander pins as outputs */
esp_io_expander_set_dir(io_expander, IO_EXPANDER_PIN_NUM_0 | IO_EXPANDER_PIN_NUM_1 | IO_EXPANDER_PIN_NUM_2, IO_EXPANDER_OUTPUT);
>>>>>>> Stashed changes
/* Reset sequence: pull low then high */
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 0);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 0);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 0);
vTaskDelay(pdMS_TO_TICKS(200));
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 1);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 1);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 1);
/* Initialize QSPI bus for LCD */
ESP_LOGI(TAG, "Initialize QSPI bus");
const spi_bus_config_t buscfg = SH8601_PANEL_BUS_QSPI_CONFIG(
PIN_NUM_LCD_PCLK,
PIN_NUM_LCD_DATA0,
PIN_NUM_LCD_DATA1,
PIN_NUM_LCD_DATA2,
PIN_NUM_LCD_DATA3,
LCD_H_RES * LCD_V_RES * LCD_BIT_PER_PIXEL / 8
);
ESP_ERROR_CHECK(spi_bus_initialize(LCD_HOST, &buscfg, SPI_DMA_CH_AUTO));
/* Install panel IO */
ESP_LOGI(TAG, "Install panel IO");
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG(
PIN_NUM_LCD_CS,
notify_lvgl_flush_ready,
&disp_drv
);
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST, &io_config, &lcd_io));
/* Configure vendor-specific settings */
sh8601_vendor_config_t vendor_config = {
.init_cmds = lcd_init_cmds,
.init_cmds_size = sizeof(lcd_init_cmds) / sizeof(lcd_init_cmds[0]),
.flags = {
.use_qspi_interface = 1,
},
};
/* Install SH8601 panel driver */
ESP_LOGI(TAG, "Install SH8601 panel driver");
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = LCD_BIT_PER_PIXEL,
.vendor_config = &vendor_config,
};
ESP_ERROR_CHECK(esp_lcd_new_panel_sh8601(lcd_io, &panel_config, &lcd_panel));
ESP_ERROR_CHECK(esp_lcd_panel_reset(lcd_panel));
ESP_ERROR_CHECK(esp_lcd_panel_init(lcd_panel));
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(lcd_panel, true));
#if USE_TOUCH
/* Initialize touch controller */
ESP_LOGI(TAG, "Initialize touch controller");
esp_lcd_panel_io_handle_t tp_io_handle = NULL;
const esp_lcd_panel_io_i2c_config_t tp_io_config = ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG();
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)TOUCH_HOST, &tp_io_config, &tp_io_handle));
const esp_lcd_touch_config_t tp_cfg = {
.x_max = LCD_H_RES,
.y_max = LCD_V_RES,
.rst_gpio_num = PIN_NUM_TOUCH_RST,
.int_gpio_num = PIN_NUM_TOUCH_INT,
.levels = {
.reset = 0,
.interrupt = 0,
},
.flags = {
.swap_xy = 0,
.mirror_x = 0,
.mirror_y = 0,
},
};
ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_ft5x06(tp_io_handle, &tp_cfg, &tp));
#endif
/* Initialize LVGL */
ESP_LOGI(TAG, "Initialize LVGL library");
lv_init();
/* Allocate draw buffers in DMA-capable memory */
lv_color_t *buf1 = heap_caps_malloc(LCD_H_RES * LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
assert(buf1);
lv_color_t *buf2 = heap_caps_malloc(LCD_H_RES * LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
assert(buf2);
lv_disp_draw_buf_init(&disp_buf, buf1, buf2, LCD_H_RES * LVGL_BUF_HEIGHT);
/* Register display driver */
ESP_LOGI(TAG, "Register display driver");
lv_disp_drv_init(&disp_drv);
disp_drv.hor_res = LCD_H_RES;
disp_drv.ver_res = LCD_V_RES;
disp_drv.flush_cb = lvgl_flush_cb;
disp_drv.rounder_cb = lvgl_rounder_cb;
disp_drv.drv_update_cb = lvgl_update_cb;
disp_drv.draw_buf = &disp_buf;
disp_drv.user_data = lcd_panel;
lv_disp_t *disp = lv_disp_drv_register(&disp_drv);
/* Install LVGL tick timer */
ESP_LOGI(TAG, "Install LVGL tick timer");
const esp_timer_create_args_t lvgl_tick_timer_args = {
.callback = &increase_lvgl_tick,
.name = "lvgl_tick"
};
esp_timer_handle_t lvgl_tick_timer = NULL;
ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));
ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer, LVGL_TICK_PERIOD_MS * 1000));
#if USE_TOUCH
/* Register touch input device */
ESP_LOGI(TAG, "Register touch input device");
static lv_indev_drv_t indev_drv;
lv_indev_drv_init(&indev_drv);
indev_drv.type = LV_INDEV_TYPE_POINTER;
indev_drv.disp = disp;
indev_drv.read_cb = lvgl_touch_cb;
indev_drv.user_data = tp;
lv_indev_drv_register(&indev_drv);
#endif
/* Create LVGL mutex and task */
lvgl_mux = xSemaphoreCreateMutex();
assert(lvgl_mux);
xTaskCreate(lvgl_port_task, "LVGL", LVGL_TASK_STACK_SIZE, NULL, LVGL_TASK_PRIORITY, NULL);
// Set full screen background color to #848a5d
if (lvgl_lock(-1)) {
lv_obj_t *scr = lv_scr_act();
lv_obj_set_style_bg_color(scr, lv_color_hex(0x848a5d), LV_PART_MAIN);
lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, LV_PART_MAIN);
// Create and display the logo image (scaled to cover full screen)
lv_obj_t *logo_img = lv_img_create(scr);
lv_img_set_src(logo_img, &logoIro_img);
/* Scale logo to cover the entire screen while keeping aspect ratio */
{
const lv_img_dsc_t *dsc = &logoIro_img;
int orig_w = dsc->header.w;
int orig_h = dsc->header.h;
int scr_w = lv_disp_get_hor_res(NULL);
int scr_h = lv_disp_get_ver_res(NULL);
/* Compute separate scale factors for width and height (256 == 1.0×) */
int scale_w = (scr_w * 256) / orig_w;
int scale_h = (scr_h * 256) / orig_h;
/* Use the larger scale so the image covers the whole screen (may crop) */
uint16_t zoom = (uint16_t)((scale_w > scale_h) ? scale_w : scale_h);
if (zoom == 0) zoom = 1;
lv_img_set_zoom(logo_img, zoom);
/* Center the image after zoom so it fills the display evenly */
lv_obj_align(logo_img, LV_ALIGN_CENTER, 0, 0);
}
lvgl_unlock();
}
ESP_LOGI(TAG, "LVGL AMOLED application running");
}