Files
iroBot/main/main.c
Neil Arora a61765430a Update logoIro image data
Refreshed the logoIro_map array in assets/logoIro.c with new image data. This may reflect a visual update or optimization to the logo asset.
2026-01-13 03:56:37 +05:30

536 lines
18 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 <stdint.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"
#include "src/extra/libs/gif/lv_gif.h"
#include "emotions/facetestLCD.h"
#include "esp_lcd_sh8601.h"
#include "esp_lcd_touch_ft5x06.h"
#include "esp_io_expander_tca9554.h"
#include "../assets/logoIro.c"
/* Re-enable input devices after splash timeout */
static void reenable_input_cb(lv_timer_t * t)
{
lv_indev_t *indev = lv_indev_get_next(NULL);
while (indev) {
lv_indev_enable(indev, true);
indev = lv_indev_get_next(indev);
}
lv_timer_del(t);
}
/* Helper to animate screen background color (exec callback for lv_anim) */
static void scr_bg_anim(void * var, int32_t v)
{
lv_obj_t *scr = (lv_obj_t *)var;
lv_color_t c = lv_color_hex((uint32_t)v);
lv_obj_set_style_bg_color(scr, c, LV_PART_MAIN);
}
/* Timer callback started after fade-in completes; starts fade-out and background animation */
static void fadeout_start_cb(lv_timer_t * t)
{
lv_obj_t *logo = (lv_obj_t *)t->user_data;
if (!logo) {
lv_timer_del(t);
return;
}
/* Start image fade-out (750 ms) */
lv_obj_fade_out(logo, 750, 0);
/* Animate screen background color from sampled bg to black over 750 ms */
lv_obj_t *scr = lv_obj_get_parent(logo);
uint32_t from_hex = 0x000000;
/* Try to sample from the image data if available */
if (logoIro_img.data && logoIro_img.data_size >= 2) {
const uint8_t *d = (const uint8_t *)logoIro_img.data;
uint16_t pix = (uint16_t)(d[0] | (d[1] << 8));
uint8_t r5 = (pix >> 11) & 0x1F;
uint8_t g6 = (pix >> 5) & 0x3F;
uint8_t b5 = pix & 0x1F;
uint8_t r8 = (r5 * 255) / 31;
uint8_t g8 = (g6 * 255) / 63;
uint8_t b8 = (b5 * 255) / 31;
from_hex = (r8 << 16) | (g8 << 8) | b8;
}
lv_anim_t a;
lv_anim_init(&a);
lv_anim_set_var(&a, scr);
lv_anim_set_exec_cb(&a, scr_bg_anim);
lv_anim_set_values(&a, (int)from_hex, 0x000000);
lv_anim_set_time(&a, 750);
lv_anim_start(&a);
lv_timer_del(t);
}
static const char *TAG __attribute__((unused)) = "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 __attribute__((unused)) = NULL;
static esp_lcd_panel_handle_t lcd_panel __attribute__((unused)) = NULL;
#if USE_TOUCH
static esp_lcd_touch_handle_t tp __attribute__((unused)) = NULL;
#endif
/* LVGL mutex for thread safety */
static SemaphoreHandle_t lvgl_mux = NULL;
static lv_obj_t *g_lvgl_gif __attribute__((unused)) = NULL;
static const lv_img_dsc_t g_lvgl_gif_src __attribute__((unused)) = {
.header.always_zero = 0,
.header.w = 240,
.header.h = 135,
.header.cf = LV_IMG_CF_RAW,
.data_size = sizeof(facetestLCD),
.data = facetestLCD,
};
/* 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 */
};
/* 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)
{
lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;
lv_disp_flush_ready(disp_driver);
return false;
}
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);
static lv_disp_draw_buf_t disp_buf;
/* 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));
/* 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);
/* 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);
/* Create a splash screen: sample the image background color, fit image inside
* the display (no cropping), disable interaction, and render pixel-perfect
* by using LVGL's zoom. */
if (lvgl_lock(-1)) {
lv_obj_t *scr = lv_scr_act();
/* Sample first pixel from embedded RGB565 image to use as background.
* Assume `logoIro_img.data` contains RGB565 (little-endian) bytes. */
uint32_t bg_hex = 0x848a5d; /* fallback */
if (logoIro_img.data && logoIro_img.data_size >= 2) {
const uint8_t *d = (const uint8_t *)logoIro_img.data;
uint16_t pix = (uint16_t)(d[0] | (d[1] << 8));
uint8_t r5 = (pix >> 11) & 0x1F;
uint8_t g6 = (pix >> 5) & 0x3F;
uint8_t b5 = pix & 0x1F;
uint8_t r8 = (r5 * 255) / 31;
uint8_t g8 = (g6 * 255) / 63;
uint8_t b8 = (b5 * 255) / 31;
bg_hex = (r8 << 16) | (g8 << 8) | b8;
}
lv_obj_set_style_bg_color(scr, lv_color_hex(bg_hex), LV_PART_MAIN);
lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, LV_PART_MAIN);
/* Create and display the logo image (scaled to fit screen, centered) */
lv_obj_t *logo_img = lv_img_create(scr);
lv_img_set_src(logo_img, &logoIro_img);
/* Fit the image inside the screen (no crop) using LVGL zoom (256 == 1.0×).
* Temporarily disable input devices to prevent scrolling during the splash. */
{
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 smaller scale so the image fits inside the screen (no 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);
/* Make the image and screen non-interactive / non-scrollable */
lv_obj_clear_flag(logo_img, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE);
lv_obj_clear_flag(scr, LV_OBJ_FLAG_SCROLLABLE | LV_OBJ_FLAG_CLICKABLE);
/* Center the image */
lv_obj_align(logo_img, LV_ALIGN_CENTER, 0, 0);
/* Disable all input devices temporarily to prevent user scroll/input */
lv_indev_t *indev = lv_indev_get_next(NULL);
while (indev) {
lv_indev_enable(indev, false);
indev = lv_indev_get_next(indev);
}
/* Re-enable inputs after 1500 ms */
lv_timer_create(reenable_input_cb, 1500, NULL);
}
lvgl_unlock();
}
ESP_LOGI(TAG, "LVGL AMOLED application running");
}