diff --git a/README.md b/README.md index 2de0c3c..8467381 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,39 @@ [![Platform IO CI](https://github.com/rzeldent/esp32-smartdisplay/actions/workflows/main.yml/badge.svg)](https://github.com/rzeldent/esp32-smartdisplay/actions/workflows/main.yml) [![PlatformIO Registry](https://badges.registry.platformio.org/packages/rzeldent/library/esp32_smartdisplay.svg)](https://registry.platformio.org/libraries/rzeldent/esp32_smartdisplay) +## Table of Contents + +- [LVGL drivers for Chinese Sunton Smart display boards, aka CYD (Cheap Yellow Display)](#lvgl-drivers-for-chinese-sunton-smart-display-boards-aka-cyd-cheap-yellow-display) + - [Table of Contents](#table-of-contents) + - [Supported boards](#supported-boards) + - [Why this library](#why-this-library) + - [Dependencies](#dependencies) + - [How to use](#how-to-use) + - [Step 1: Download (or open) PlatformIO](#step-1-download-or-open-platformio) + - [Step 2: Boards definitions](#step-2-boards-definitions) + - [Step 3: Create a new project](#step-3-create-a-new-project) + - [Step 4: Add this library to your project](#step-4-add-this-library-to-your-project) + - [Step 5: Create a settings file for LVGL](#step-5-create-a-settings-file-for-lvgl) + - [Step 6: Copy the build flags below in your project](#step-6-copy-the-build-flags-below-in-your-project) + - [Step 7: Initialize the display (and touch) in your project](#step-7-initialize-the-display-and-touch-in-your-project) + - [Step 8 (Optional): Create your LVGL file or use SquareLine Studio to make a design](#step-8-optional-create-your-lvgl-file-or-use-squareline-studio-to-make-a-design) + - [Step 9: Compile, upload and enjoy](#step-9-compile-upload-and-enjoy) + - [Porting from LVGL 8.3.9](#porting-from-lvgl-839) + - [lv\_conf.h](#lv_confh) + - [Ticker](#ticker) + - [More on lv\_conf.h](#more-on-lv_confh) + - [LVGL initialization Functions](#lvgl-initialization-functions) + - [void smartdisplay\_init()](#void-smartdisplay_init) + - [void smartdisplay\_lcd\_set\_backlight(float duty)](#void-smartdisplay_lcd_set_backlightfloat-duty) + - [void smartdisplay\_lcd\_set\_brightness\_cb(smartdisplay\_lcd\_adaptive\_brightness\_cb\_t cb, uint interval)](#void-smartdisplay_lcd_set_brightness_cbsmartdisplay_lcd_adaptive_brightness_cb_t-cb-uint-interval) + - [void smartdisplay\_led\_set\_rgb(bool r, bool g, bool b)](#void-smartdisplay_led_set_rgbbool-r-bool-g-bool-b) + - [touch\_calibration\_data\_t touch\_calibration\_data](#touch_calibration_data_t-touch_calibration_data) + - [touch\_calibration\_data\_t smartdisplay\_compute\_touch\_calibration(const lv\_point\_t screen\[3\], const lv\_point\_t touch\[3\])](#touch_calibration_data_t-smartdisplay_compute_touch_calibrationconst-lv_point_t-screen3-const-lv_point_t-touch3) + - [Rotation of the display and touch](#rotation-of-the-display-and-touch) + - [Appendix: Template to support ALL the boards](#appendix-template-to-support-all-the-boards) + - [Appendix: External dependencies](#appendix-external-dependencies) + - [Version history](#version-history) + ## Supported boards These Sunton boards have an LCD display and most of them have a touch interface. @@ -51,7 +84,7 @@ This library depends on: - [platformio-espressif32-sunton](https://github.com/rzeldent/platformio-espressif32-sunton) > [!NOTE] -> This library uses the newly introduced esp_lcd_panel interfaces. This should provide some support in the future for updates and new boards. These drivers are provided by Espressid and have already been copied and included to this library. +> This library uses the newly introduced esp_lcd_panel interfaces. This should provide some support in the future for updates and new boards. These drivers are provided by Espressif and have already been copied and included to this library. ## How to use @@ -84,7 +117,14 @@ Make sure you have PlatformIO installed and functional. Follow the documentation The board definitions required for this library are defined in the boards library [platformio-espressif32-sunton](https://github.com/rzeldent/platformio-espressif32-sunton). This library must reside in the `/boards` directory so PlatformIo will automatically recognize these boards. -**It is recommended to use `git submodule` to include these board definitions automatically.** +**It is recommended to use `git clone --recurse-submodules` to include these board definitions automatically.** + +In case the repository was opened without the submodules, the submodules need to be initialized and updated. To do this type at the command prompt: + +```bash +git submodule init +git submodule update +``` > [!TIP] > If you already have a project, clone it with the `git clone --recurse-submodules`. If creating a new project, use `git submodule add https://github.com/rzeldent/platformio-espressif32-sunton.git boards` to add them to your project as a submodule. @@ -352,7 +392,7 @@ This function can be called to periodically call a user defined function to set The callback function must have the following format: ```cpp -float smartdisplay_lcd_adaptive_brightness_function)() +float smartdisplay_lcd_adaptive_brightness_function() { ... return @@ -600,6 +640,10 @@ The following libraries are used from the [Espressif component registry](https:/ ## Version history +- June 2025 + - Version 2.1.1 + - Updated documentation + - Renamed IO pins - November 2024 - Version 2.1.0 - LVGL 9.2.2 diff --git a/boards b/boards index ff4ef01..8d9e1ef 160000 --- a/boards +++ b/boards @@ -1 +1 @@ -Subproject commit ff4ef01c23cdb6ffe1e0033c2c62fd76a8a1b0c0 +Subproject commit 8d9e1efaf5854c964c0c4fb16f7f95ed403ff20b diff --git a/include/esp_panel_axs15231b.h b/include/esp_panel_axs15231b.h new file mode 100644 index 0000000..145cb43 --- /dev/null +++ b/include/esp_panel_axs15231b.h @@ -0,0 +1,22 @@ +#pragma once + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct + { + const lcd_init_cmd_t *init_cmds; + uint16_t init_cmds_size; + } axs15231b_vendor_config_t; + + esp_err_t esp_lcd_new_panel_axs15231b(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *config, esp_lcd_panel_handle_t *handle); + +#ifdef __cplusplus +} +#endif diff --git a/library.json b/library.json index b7f777f..fb97581 100644 --- a/library.json +++ b/library.json @@ -1,7 +1,7 @@ { "$schema": "https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/schema/library.json", "name": "esp32_smartdisplay", - "version": "2.1.0", + "version": "2.1.1", "description": "LVGL v9.2.2 driver for Sunton ESP32 Cheap Yellow Display display boards", "keywords": "LVGL Sunton CYD LCD TFT Touch", "repository": { diff --git a/platformio.ini b/platformio.ini index 870b320..54ec993 100644 --- a/platformio.ini +++ b/platformio.ini @@ -36,13 +36,17 @@ #default_envs = esp32-8048S043R #default_envs = esp32-8048S050C #default_envs = esp32-8048S050N -#default_envs = esp32-8048S050R +#default_envs = esp32-8048S050R #default_envs = esp32-8048S070C #default_envs = esp32-8048S070N #default_envs = esp32-8048S070R -#default_envs = esp32-s3touchlcd7 -#default_envs = esp32-2432W328C #default_envs = esp32-8048S550C +#default_envs = esp32-s3touchlcd7 +#default_envs = esp32-s3touchlcd4p3 +#default_envs = JC2432W328C +#default_envs = JC3248W535N +#default_envs = JC8048W550C + [env] platform = espressif32 @@ -53,7 +57,7 @@ build_flags = -Wall '-D CORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_VERBOSE' # LVGL settings - '-D LV_CONF_PATH=${platformio.test_dir}/lv_conf.h' + '-D LV_CONF_PATH="${platformio.test_dir}/lv_conf.h"' '-D ESP_LCD_PANEL_IO_ADDITIONS_VER_MAJOR=1' '-D ESP_LCD_PANEL_IO_ADDITIONS_VER_MINOR=0' '-D ESP_LCD_PANEL_IO_ADDITIONS_VER_PATCH=1' @@ -157,11 +161,20 @@ board = esp32-8048S070N [env:esp32-8048S070R] board = esp32-8048S070R +[env:esp32-8048S550C] +board = esp32-8048S550C + [env:esp32-s3touchlcd7] board = esp32-s3touchlcd7 -[env:esp32-2432W328C] -board = esp32-2432W328C +[env:esp32-s3touchlcd4p3] +board = esp32-s3touchlcd4p3 -[env:esp32-8048S550C] -board = esp32-8048S550C \ No newline at end of file +[env:JC2432W328C] +board = JC2432W328C + +[env:JC3248W535N] +board = JC3248W535N + +[env:JC8048W550C] +board = JC8048W550C \ No newline at end of file diff --git a/src/esp32_smartdisplay.c b/src/esp32_smartdisplay.c index b7f46ea..e4308bb 100644 --- a/src/esp32_smartdisplay.c +++ b/src/esp32_smartdisplay.c @@ -56,7 +56,7 @@ void smartdisplay_lcd_set_backlight(float duty) if (duty < 0.0f) duty = 0.0f; #if ESP_ARDUINO_VERSION_MAJOR >= 3 - ledcWrite(GPIO_BCKL, duty * PWM_MAX_BCKL); + ledcWrite(DISPLAY_BCKL, duty * PWM_MAX_BCKL); #else ledcWrite(PWM_CHANNEL_BCKL, duty * PWM_MAX_BCKL); #endif @@ -183,13 +183,13 @@ void smartdisplay_init() lv_init(); // Setup backlight - pinMode(GPIO_BCKL, OUTPUT); - digitalWrite(GPIO_BCKL, LOW); + pinMode(DISPLAY_BCKL, OUTPUT); + digitalWrite(DISPLAY_BCKL, LOW); #if ESP_ARDUINO_VERSION_MAJOR >= 3 - ledcAttach(GPIO_BCKL, PWM_FREQ_BCKL, PWM_BITS_BCKL); + ledcAttach(DISPLAY_BCKL, PWM_FREQ_BCKL, PWM_BITS_BCKL); #else ledcSetup(PWM_CHANNEL_BCKL, PWM_FREQ_BCKL, PWM_BITS_BCKL); - ledcAttachPin(GPIO_BCKL, PWM_CHANNEL_BCKL); + ledcAttachPin(DISPLAY_BCKL, PWM_CHANNEL_BCKL); #endif // Setup TFT display display = lvgl_lcd_init(); diff --git a/src/esp_panel_axs15231b.c b/src/esp_panel_axs15231b.c new file mode 100644 index 0000000..a0f054a --- /dev/null +++ b/src/esp_panel_axs15231b.c @@ -0,0 +1,410 @@ +#ifdef DISPLAY_AXS15231B_QSPI + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct +{ + esp_lcd_panel_t base; + esp_lcd_panel_io_handle_t panel_io_handle; + esp_lcd_panel_dev_config_t panel_dev_config; + // Data + int x_gap; + int y_gap; + uint8_t madctl; +} axs15231b_panel_t; + +const lcd_init_cmd_t axs15231b_vendor_specific_init_default[] = { + {0xBB, (uint8_t[]){0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0xA5}, 8, 0}, + {0xA0, (uint8_t[]){0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x64, 0x3F, 0x20, 0x05, 0x3F, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00}, 17, 0}, + {0xA2, (uint8_t[]){0x30, 0x04, 0x0A, 0x3C, 0xEC, 0x54, 0xC4, 0x30, 0xAC, 0x28, 0x7F, 0x7F, 0x7F, 0x20, 0xF8, 0x10, 0x02, 0xFF, 0xFF, 0xF0, 0x90, 0x01, 0x32, 0xA0, 0x91, 0xC0, 0x20, 0x7F, 0xFF, 0x00, 0x54}, 31, 0}, + {0xD0, (uint8_t[]){0x30, 0xAC, 0x21, 0x24, 0x08, 0x09, 0x10, 0x01, 0xAA, 0x14, 0xC2, 0x00, 0x22, 0x22, 0xAA, 0x03, 0x10, 0x12, 0x40, 0x14, 0x1E, 0x51, 0x15, 0x00, 0x40, 0x10, 0x00, 0x03, 0x3D, 0x12}, 30, 0}, + {0xA3, (uint8_t[]){0xA0, 0x06, 0xAA, 0x08, 0x08, 0x02, 0x0A, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x55, 0x55}, 22, 0}, + {0xC1, (uint8_t[]){0x33, 0x04, 0x02, 0x02, 0x71, 0x05, 0x24, 0x55, 0x02, 0x00, 0x41, 0x00, 0x53, 0xFF, 0xFF, 0xFF, 0x4F, 0x52, 0x00, 0x4F, 0x52, 0x00, 0x45, 0x3B, 0x0B, 0x02, 0x0D, 0x00, 0xFF, 0x40}, 30, 0}, + {0xC3, (uint8_t[]){0x00, 0x00, 0x00, 0x50, 0x03, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01}, 11, 0}, + {0xC4, (uint8_t[]){0x00, 0x24, 0x33, 0x90, 0x50, 0xea, 0x64, 0x32, 0xC8, 0x64, 0xC8, 0x32, 0x90, 0x90, 0x11, 0x06, 0xDC, 0xFA, 0x04, 0x03, 0x80, 0xFE, 0x10, 0x10, 0x00, 0x0A, 0x0A, 0x44, 0x50}, 29, 0}, + {0xC5, (uint8_t[]){0x18, 0x00, 0x00, 0x03, 0xFE, 0x78, 0x33, 0x20, 0x30, 0x10, 0x88, 0xDE, 0x0D, 0x08, 0x0F, 0x0F, 0x01, 0x78, 0x33, 0x20, 0x10, 0x10, 0x80}, 23, 0}, + {0xC6, (uint8_t[]){0x05, 0x0A, 0x05, 0x0A, 0x00, 0xE0, 0x2E, 0x0B, 0x12, 0x22, 0x12, 0x22, 0x01, 0x00, 0x00, 0x3F, 0x6A, 0x18, 0xC8, 0x22}, 20, 0}, + {0xC7, (uint8_t[]){0x50, 0x32, 0x28, 0x00, 0xa2, 0x80, 0x8f, 0x00, 0x80, 0xff, 0x07, 0x11, 0x9F, 0x6f, 0xff, 0x26, 0x0c, 0x0d, 0x0e, 0x0f}, 20, 0}, + {0xC9, (uint8_t[]){0x33, 0x44, 0x44, 0x01}, 4, 0}, + {0xCF, (uint8_t[]){0x34, 0x1E, 0x88, 0x58, 0x13, 0x18, 0x56, 0x18, 0x1E, 0x68, 0xF7, 0x00, 0x65, 0x0C, 0x22, 0xC4, 0x0C, 0x77, 0x22, 0x44, 0xAA, 0x55, 0x04, 0x04, 0x12, 0xA0, 0x08}, 27, 0}, + {0xD5, (uint8_t[]){0x3E, 0x3E, 0x88, 0x00, 0x44, 0x04, 0x78, 0x33, 0x20, 0x78, 0x33, 0x20, 0x04, 0x28, 0xD3, 0x47, 0x03, 0x03, 0x03, 0x03, 0x86, 0x00, 0x00, 0x00, 0x30, 0x52, 0x3f, 0x40, 0x40, 0x96}, 30, 0}, + {0xD6, (uint8_t[]){0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE, 0x95, 0x00, 0x01, 0x83, 0x75, 0x36, 0x20, 0x75, 0x36, 0x20, 0x3F, 0x03, 0x03, 0x03, 0x10, 0x10, 0x00, 0x04, 0x51, 0x20, 0x01, 0x00}, 30, 0}, + {0xD7, (uint8_t[]){0x0a, 0x08, 0x0e, 0x0c, 0x1E, 0x18, 0x19, 0x1F, 0x00, 0x1F, 0x1A, 0x1F, 0x3E, 0x3E, 0x04, 0x00, 0x1F, 0x1F, 0x1F}, 19, 0}, + {0xD8, (uint8_t[]){0x0B, 0x09, 0x0F, 0x0D, 0x1E, 0x18, 0x19, 0x1F, 0x01, 0x1F, 0x1A, 0x1F}, 12, 0}, + {0xD9, (uint8_t[]){0x00, 0x0D, 0x0F, 0x09, 0x0B, 0x1F, 0x18, 0x19, 0x1F, 0x01, 0x1E, 0x1A, 0x1F}, 13, 0}, + {0xDD, (uint8_t[]){0x0C, 0x0E, 0x08, 0x0A, 0x1F, 0x18, 0x19, 0x1F, 0x00, 0x1E, 0x1A, 0x1F}, 12, 0}, + {0xDF, (uint8_t[]){0x44, 0x73, 0x4B, 0x69, 0x00, 0x0A, 0x02, 0x90}, 8, 0}, + {0xE0, (uint8_t[]){0x19, 0x20, 0x0A, 0x13, 0x0E, 0x09, 0x12, 0x28, 0xD4, 0x24, 0x0C, 0x35, 0x13, 0x31, 0x36, 0x2f, 0x03}, 17, 0}, + {0xE1, (uint8_t[]){0x38, 0x20, 0x09, 0x12, 0x0E, 0x08, 0x12, 0x28, 0xC5, 0x24, 0x0C, 0x34, 0x12, 0x31, 0x36, 0x2f, 0x27}, 17, 0}, + {0xE2, (uint8_t[]){0x19, 0x20, 0x0A, 0x11, 0x09, 0x06, 0x11, 0x25, 0xD4, 0x22, 0x0B, 0x33, 0x12, 0x2D, 0x32, 0x2f, 0x03}, 17, 0}, + {0xE3, (uint8_t[]){0x38, 0x20, 0x0A, 0x11, 0x09, 0x06, 0x11, 0x25, 0xC4, 0x21, 0x0A, 0x32, 0x11, 0x2C, 0x32, 0x2f, 0x27}, 17, 0}, + {0xE4, (uint8_t[]){0x19, 0x20, 0x0D, 0x14, 0x0D, 0x08, 0x12, 0x2A, 0xD4, 0x26, 0x0E, 0x35, 0x13, 0x34, 0x39, 0x2f, 0x03}, 17, 0}, + {0xE5, (uint8_t[]){0x38, 0x20, 0x0D, 0x13, 0x0D, 0x07, 0x12, 0x29, 0xC4, 0x25, 0x0D, 0x35, 0x12, 0x33, 0x39, 0x2f, 0x27}, 17, 0}, + {0xBB, (uint8_t[]){0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 8, 0}, + {0x13, (uint8_t[]){0x00}, 0, 0}, + {0x11, (uint8_t[]){0x00}, 0, 200}, + {0x29, (uint8_t[]){0x00}, 0, 200}, + {0x2C, (uint8_t[]){0x00, 0x00, 0x00, 0x00}, 4, 0}, + // All Pixels off + {0x22, (uint8_t[]){0x00}, 0, 200}}; + +esp_err_t axs15231b_reset(esp_lcd_panel_t *panel) +{ + log_v("panel:0x%08x", panel); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + const axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + esp_err_t res; + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_SWRESET, NULL, 0)) != ESP_OK) + { + log_e("Sending LCD_CMD_SWRESET failed"); + return res; + } + + vTaskDelay(pdMS_TO_TICKS(100)); + + uint8_t colmod; + switch (ph->panel_dev_config.bits_per_pixel) + { + case 16: // RGB565 + colmod = 0x55; + break; + case 18: // RGB666 + colmod = 0x66; + break; + default: + log_e("Invalid bits per pixel: %d. Only RGB565 and RGB666 are supported", ph->panel_dev_config.bits_per_pixel); + return ESP_ERR_INVALID_ARG; + } + + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_MADCTL, &ph->madctl, 1)) != ESP_OK || + (res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_COLMOD, &colmod, 1)) != ESP_OK) + { + log_e("Sending MADCTL/COLMOD failed"); + return res; + } + + const lcd_init_cmd_t *cmd = axs15231b_vendor_specific_init_default; + uint16_t cmds_size = sizeof(axs15231b_vendor_specific_init_default) / sizeof(lcd_init_cmd_t); + if (ph->panel_dev_config.vendor_config != NULL) + { + cmd = ((axs15231b_vendor_config_t *)ph->panel_dev_config.vendor_config)->init_cmds; + cmds_size = ((axs15231b_vendor_config_t *)ph->panel_dev_config.vendor_config)->init_cmds_size; + } + + while (cmds_size-- > 0) + { + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, cmd->cmd, cmd->data, cmd->bytes)) != ESP_OK) + { + log_e("Sending command: 0x%02x failed", cmd->cmd); + return res; + } + + vTaskDelay(pdMS_TO_TICKS(cmd->delay_ms)); + cmd++; + } + + return ESP_OK; +} + +esp_err_t axs15231b_init(esp_lcd_panel_t *panel) +{ + log_v("panel:0x%08x", panel); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + const axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + esp_err_t res; + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_SLPOUT, NULL, 0)) != ESP_OK) + { + log_e("Sending SLPOUT failed"); + return res; + } + + vTaskDelay(pdMS_TO_TICKS(100)); + + uint8_t colmod; + switch (ph->panel_dev_config.bits_per_pixel) + { + case 16: // RGB565 + colmod = 0x55; + break; + case 18: // RGB666 + colmod = 0x66; + break; + default: + log_e("Invalid bits per pixel: %d. Only RGB565 and RGB666 are supported", ph->panel_dev_config.bits_per_pixel); + return ESP_ERR_INVALID_ARG; + } + + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_MADCTL, &ph->madctl, 1)) != ESP_OK || + (res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_COLMOD, &colmod, 1)) != ESP_OK) + { + log_e("Sending MADCTL/COLMOD failed"); + return res; + } + + const lcd_init_cmd_t *cmd = axs15231b_vendor_specific_init_default; + uint16_t cmds_size = sizeof(axs15231b_vendor_specific_init_default) / sizeof(lcd_init_cmd_t); + if (ph->panel_dev_config.vendor_config != NULL) + { + cmd = ((axs15231b_vendor_config_t *)ph->panel_dev_config.vendor_config)->init_cmds; + cmds_size = ((axs15231b_vendor_config_t *)ph->panel_dev_config.vendor_config)->init_cmds_size; + } + + while (cmds_size-- > 0) + { + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, cmd->cmd, cmd->data, cmd->bytes)) != ESP_OK) + { + log_e("Sending command: 0x%02x failed", cmd->cmd); + return res; + } + + vTaskDelay(pdMS_TO_TICKS(cmd->delay_ms)); + cmd++; + } + + return ESP_OK; +} + +esp_err_t axs15231b_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data) +{ + log_v("panel:0x%08x, x_start:%d, y_start:%d, x_end:%d, y_end:%d, color_data:0x%08x", panel, x_start, y_start, x_end, y_end, color_data); + if (panel == NULL || color_data == NULL) + return ESP_ERR_INVALID_ARG; + + const axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + if (x_start >= x_end) + { + log_w("X-start greater than the x-end"); + return ESP_ERR_INVALID_ARG; + } + + if (y_start >= y_end) + { + log_w("Y-start greater than the y-end"); + return ESP_ERR_INVALID_ARG; + } + + // Correct for gap + x_start += ph->x_gap; + x_end += ph->x_gap; + y_start += ph->y_gap; + y_end += ph->y_gap; + + esp_err_t res; + const uint8_t caset[4] = {x_start >> 8, x_start, (x_end - 1) >> 8, x_end - 1}; + const uint8_t raset[4] = {y_start >> 8, y_start, (y_end - 1) >> 8, y_end - 1}; + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_CASET, caset, sizeof(caset))) != ESP_OK || + (res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_RASET, raset, sizeof(raset))) != ESP_OK) + { + log_e("Sending CASET/RASET failed"); + return res; + } + + uint8_t bytes_per_pixel = (ph->panel_dev_config.bits_per_pixel + 0x7) >> 3; + size_t len = (x_end - x_start) * (y_end - y_start) * bytes_per_pixel; + if ((res = esp_lcd_panel_io_tx_color(ph->panel_io_handle, LCD_CMD_RAMWR, color_data, len)) != ESP_OK) + { + log_e("Sending RAMWR failed"); + return res; + } + + return ESP_OK; +} + +esp_err_t axs15231b_invert_color(esp_lcd_panel_t *panel, bool invert) +{ + log_v("panel:0x%08x, invert:%d", panel, invert); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + const axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + esp_err_t res; + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, invert ? LCD_CMD_INVON : LCD_CMD_INVOFF, NULL, 0)) != ESP_OK) + { + log_e("Sending LCD_CMD_INVON/LCD_CMD_INVOFF failed"); + return res; + } + + return ESP_OK; +} + +esp_err_t axs15231b_update_madctl(axs15231b_panel_t *ph) +{ + esp_err_t res; + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, LCD_CMD_MADCTL, &ph->madctl, 1)) != ESP_OK) + { + log_e("Sending LCD_CMD_MADCTL failed"); + return res; + } + + return ESP_OK; +} + +esp_err_t axs15231b_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y) +{ + log_v("panel:0x%08x, mirror_x:%d, mirror_y:%d", panel, mirror_x, mirror_y); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + if (mirror_x) + ph->madctl |= LCD_CMD_MX_BIT; + else + ph->madctl &= ~LCD_CMD_MX_BIT; + + if (mirror_y) + ph->madctl |= LCD_CMD_MY_BIT; + else + ph->madctl &= ~LCD_CMD_MY_BIT; + + return axs15231b_update_madctl(ph); +} + +esp_err_t axs15231b_swap_xy(esp_lcd_panel_t *panel, bool swap_xy) +{ + log_v("panel:0x%08x, swap_xy:%d", panel, swap_xy); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + if (swap_xy) + ph->madctl |= LCD_CMD_MV_BIT; + else + ph->madctl &= ~LCD_CMD_MV_BIT; + + return axs15231b_update_madctl(ph); +} + +esp_err_t axs15231b_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap) +{ + log_v("panel:0x%08x, x_gap:%d, y_gap:%d", panel, x_gap, y_gap); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + ph->x_gap = x_gap; + ph->y_gap = y_gap; + + return ESP_OK; +} + +esp_err_t axs15231b_disp_off(esp_lcd_panel_t *panel, bool off) +{ + log_v("panel:0x%08x, off:%d", panel, off); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + const axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + esp_err_t res; + if ((res = esp_lcd_panel_io_tx_param(ph->panel_io_handle, off ? LCD_CMD_DISPOFF : LCD_CMD_DISPON, NULL, 0)) != ESP_OK) + { + log_e("Sending LCD_CMD_DISPOFF/LCD_CMD_DISPON failed"); + return res; + } + + return ESP_OK; +} + +esp_err_t axs15231b_del(esp_lcd_panel_t *panel) +{ + log_v("panel:0x%08x", panel); + if (panel == NULL) + return ESP_ERR_INVALID_ARG; + + axs15231b_panel_t *ph = (axs15231b_panel_t *)panel; + + // Reset RESET + if (ph->panel_dev_config.reset_gpio_num != GPIO_NUM_NC) + gpio_reset_pin(ph->panel_dev_config.reset_gpio_num); + + free(ph); + + return ESP_OK; +} + +esp_err_t esp_lcd_new_panel_axs15231b(const esp_lcd_panel_io_handle_t panel_io_handle, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *panel_handle) +{ + log_v("panel_io_handle:0x%08x, panel_dev_config:0x%08x, panel_handle:0x%08x", panel_io_handle, panel_dev_config, panel_handle); + if (panel_io_handle == NULL || panel_dev_config == NULL || panel_handle == NULL) + return ESP_ERR_INVALID_ARG; + + if (panel_dev_config->reset_gpio_num != GPIO_NUM_NC && !GPIO_IS_VALID_GPIO(panel_dev_config->reset_gpio_num)) + { + log_e("Invalid GPIO RST pin: %d", panel_dev_config->reset_gpio_num); + return ESP_ERR_INVALID_ARG; + } + + uint8_t madctl; + switch (panel_dev_config->color_space) + { + case ESP_LCD_COLOR_SPACE_RGB: + madctl = 0; + break; + case ESP_LCD_COLOR_SPACE_BGR: + madctl = LCD_CMD_BGR_BIT; + break; + default: + log_e("Invalid color space: %d. Only RGB and BGR are supported", panel_dev_config->color_space); + return ESP_ERR_INVALID_ARG; + } + + if (panel_dev_config->reset_gpio_num != GPIO_NUM_NC) + { + esp_err_t res; + const gpio_config_t cfg = { + .pin_bit_mask = BIT64(panel_dev_config->reset_gpio_num), + .mode = GPIO_MODE_OUTPUT}; + if ((res = gpio_config(&cfg)) != ESP_OK) + { + log_e("Configuring GPIO for RST failed"); + return res; + } + } + + axs15231b_panel_t *ph = heap_caps_calloc(1, sizeof(axs15231b_panel_t), MALLOC_CAP_DEFAULT); + if (ph == NULL) + { + log_e("No memory available for axs15231b_panel_t"); + return ESP_ERR_NO_MEM; + } + + ph->panel_io_handle = panel_io_handle; + memcpy(&ph->panel_dev_config, panel_dev_config, sizeof(esp_lcd_panel_dev_config_t)); + ph->madctl = madctl; + + ph->base.del = axs15231b_del; + ph->base.reset = axs15231b_reset; + ph->base.init = axs15231b_init; + ph->base.draw_bitmap = axs15231b_draw_bitmap; + ph->base.invert_color = axs15231b_invert_color; + ph->base.mirror = axs15231b_mirror; + ph->base.swap_xy = axs15231b_swap_xy; + ph->base.set_gap = axs15231b_set_gap; + ph->base.disp_off = axs15231b_disp_off; + + log_d("panel_handle: 0x%08x", ph); + *panel_handle = (esp_lcd_panel_handle_t)ph; + + return ESP_OK; +} + +#endif \ No newline at end of file diff --git a/src/lvgl_panel_axa15231b_qspi.c b/src/lvgl_panel_axa15231b_qspi.c new file mode 100644 index 0000000..ce69cef --- /dev/null +++ b/src/lvgl_panel_axa15231b_qspi.c @@ -0,0 +1,133 @@ +#ifdef DISPLAY_AXS15231B_QSPI + +#include +#include +#include +#include +#include + +bool axs15231b_color_trans_done(esp_lcd_panel_io_handle_t panel_io_handle, esp_lcd_panel_io_event_data_t *panel_io_event_data, void *user_ctx) +{ + log_v("panel_io_handle:0x%08x, panel_io_event_data:%0x%08x, user_ctx:0x%08x", panel_io_handle, panel_io_event_data, user_ctx); + + lv_display_t *display = user_ctx; + lv_display_flush_ready(display); + return false; +} + +void axs15231b_lv_flush(lv_display_t *display, const lv_area_t *area, uint8_t *px_map) +{ + // Hardware rotation is supported + log_v("display:0x%08x, area:%0x%08x, color_map:0x%08x", display, area, px_map); + + esp_lcd_panel_handle_t panel_handle = display->user_data; + uint32_t pixels = lv_area_get_size(area); + uint16_t *p = (uint16_t *)px_map; + while (pixels--) + { + *p = (uint16_t)((*p >> 8) | (*p << 8)); + p++; + } + + ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(panel_handle, area->x1, area->y1, area->x2 + 1, area->y2 + 1, px_map)); +} + +lv_display_t *lvgl_lcd_init() +{ + lv_display_t *display = lv_display_create(DISPLAY_WIDTH, DISPLAY_HEIGHT); + log_v("display:0x%08x", display); + // Create drawBuffer + uint32_t drawBufferSize = sizeof(lv_color_t) * LVGL_BUFFER_PIXELS; + void *drawBuffer = heap_caps_malloc(drawBufferSize, LVGL_BUFFER_MALLOC_FLAGS); + lv_display_set_buffers(display, drawBuffer, NULL, drawBufferSize, LV_DISPLAY_RENDER_MODE_PARTIAL); + + // Create QSPI bus + const spi_bus_config_t spi_bus_config = { + .sclk_io_num = AXS15231B_SPI_BUS_PCLK, + .data0_io_num = AXS15231B_SPI_BUS_DATA0, + .data1_io_num = AXS15231B_SPI_BUS_DATA1, + .data2_io_num = AXS15231B_SPI_BUS_DATA2, + .data3_io_num = AXS15231B_SPI_BUS_DATA3, + .max_transfer_sz = AXS15231B_SPI_BUS_MAX_TRANSFER_SZ, + .flags = AXS15231B_SPI_BUS_FLAGS, + .intr_flags = AXS15231B_SPI_BUS_INTR_FLAGS}; + log_d("spi_bus_config: sclk_io_num:%d, data0_io_num:%d, data1_io_num:%d, data2_io_num:%d, data3_io_num:%d, max_transfer_sz:%d, flags:0x%08x, intr_flags:0x%04x", spi_bus_config.sclk_io_num, spi_bus_config.data0_io_num, spi_bus_config.data1_io_num, spi_bus_config.data2_io_num, spi_bus_config.data3_io_num, spi_bus_config.max_transfer_sz, spi_bus_config.flags, spi_bus_config.intr_flags); + ESP_ERROR_CHECK_WITHOUT_ABORT(spi_bus_initialize(AXS15231B_SPI_HOST, &spi_bus_config, AXS15231B_SPI_DMA_CHANNEL)); + + // Attach the LCD controller to the SPI bus + const esp_lcd_panel_io_spi_config_t io_spi_config = { + .cs_gpio_num = AXS15231B_SPI_CONFIG_CS, + .dc_gpio_num = AXS15231B_SPI_CONFIG_DC, + .spi_mode = SPI_MODE0, // AXS15231B_SPI_CONFIG_SPI_MODE - QSPI not yet supported + .pclk_hz = AXS15231B_SPI_CONFIG_PCLK_HZ, + .trans_queue_depth = AXS15231B_SPI_CONFIG_TRANS_QUEUE_DEPTH, + .user_ctx = display, + .on_color_trans_done = axs15231b_color_trans_done, + .lcd_cmd_bits = 8, // AXS15231B_SPI_CONFIG_LCD_CMD_BITS - QSPI not yet supported + .lcd_param_bits = AXS15231B_SPI_CONFIG_LCD_PARAM_BITS, + .flags = { + .dc_as_cmd_phase = AXS15231B_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE, + .dc_low_on_data = AXS15231B_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA, + .octal_mode = AXS15231B_SPI_CONFIG_FLAGS_OCTAL_MODE, + .lsb_first = AXS15231B_SPI_CONFIG_FLAGS_LSB_FIRST}}; + log_d("io_spi_config: cs_gpio_num:%d, dc_gpio_num:%d, spi_mode:%d, pclk_hz:%d, trans_queue_depth:%d, user_ctx:0x%08x, on_color_trans_done:0x%08x, lcd_cmd_bits:%d, lcd_param_bits:%d, flags:{dc_as_cmd_phase:%d, dc_low_on_data:%d, octal_mode:%d, lsb_first:%d}", io_spi_config.cs_gpio_num, io_spi_config.dc_gpio_num, io_spi_config.spi_mode, io_spi_config.pclk_hz, io_spi_config.trans_queue_depth, io_spi_config.user_ctx, io_spi_config.on_color_trans_done, io_spi_config.lcd_cmd_bits, io_spi_config.lcd_param_bits, io_spi_config.flags.dc_as_cmd_phase, io_spi_config.flags.dc_low_on_data, io_spi_config.flags.octal_mode, io_spi_config.flags.lsb_first); + + // Attach the LCD controller to the QSPI bus + // const esp_lcd_panel_io_spi_config_t io_spi_config = { + // .cs_gpio_num = AXS15231B_SPI_CONFIG_CS, + // .dc_gpio_num = AXS15231B_SPI_CONFIG_DC, + // .spi_mode = AXS15231B_SPI_CONFIG_SPI_MODE, + // .pclk_hz = AXS15231B_SPI_CONFIG_PCLK_HZ, + // .trans_queue_depth = AXS15231B_SPI_CONFIG_TRANS_QUEUE_DEPTH, + // .user_ctx = display, + // .on_color_trans_done = axs15231b_color_trans_done, + // .lcd_cmd_bits = AXS15231B_SPI_CONFIG_LCD_CMD_BITS, + // .lcd_param_bits = AXS15231B_SPI_CONFIG_LCD_PARAM_BITS, + // .flags = { + // .dc_as_cmd_phase = AXS15231B_SPI_CONFIG_FLAGS_DC_AS_CMD_PHASE, + // .dc_low_on_data = AXS15231B_SPI_CONFIG_FLAGS_DC_LOW_ON_DATA, + // .octal_mode = AXS15231B_SPI_CONFIG_FLAGS_OCTAL_MODE, + // .quad_mode = AXS15231B_SPI_CONFIG_FLAGS_QUAD_MODE, + // .sio_mode = AXS15231B_SPI_CONFIG_FLAGS_SIO_MODE, + // .lsb_first = AXS15231B_SPI_CONFIG_FLAGS_LSB_FIRST}}; + // //log_d("io_spi_config: cs_gpio_num:%d, dc_gpio_num:%d, spi_mode:%d, pclk_hz:%d, trans_queue_depth:%d, user_ctx:0x%08x, on_color_trans_done:0x%08x, lcd_cmd_bits:%d, lcd_param_bits:%d, flags:{dc_as_cmd_phase:%d, dc_low_on_data:%d, octal_mode:%d, quad_mode:%d, sio_mode:%d, lsb_first:%d}", io_spi_config.cs_gpio_num, io_spi_config.dc_gpio_num, io_spi_config.spi_mode, io_spi_config.pclk_hz, io_spi_config.trans_queue_depth, io_spi_config.user_ctx, io_spi_config.on_color_trans_done, io_spi_config.lcd_cmd_bits, io_spi_config.lcd_param_bits, io_spi_config.flags.dc_as_cmd_phase, io_spi_config.flags.dc_low_on_data, io_spi_config.flags.octal_mode, io_spi_config.quad_mode, io_spi_config.sio_mode, io_spi_config.flags.lsb_first); + + esp_lcd_panel_io_handle_t io_handle; + ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)AXS15231B_SPI_HOST, &io_spi_config, &io_handle)); + + // Create axs15231b panel handle + const esp_lcd_panel_dev_config_t panel_dev_config = { + .reset_gpio_num = AXS15231B_DEV_CONFIG_RESET, + .color_space = AXS15231B_DEV_CONFIG_COLOR_SPACE, + .bits_per_pixel = AXS15231B_DEV_CONFIG_BITS_PER_PIXEL, + .flags = { + .reset_active_high = AXS15231B_DEV_CONFIG_FLAGS_RESET_ACTIVE_HIGH}, + .vendor_config = AXS15231B_DEV_CONFIG_VENDOR_CONFIG}; + log_d("panel_dev_config: reset_gpio_num:%d, color_space:%d, bits_per_pixel:%d, flags:{reset_active_high:%d}, vendor_config: 0x%08x", panel_dev_config.reset_gpio_num, panel_dev_config.color_space, panel_dev_config.bits_per_pixel, panel_dev_config.flags.reset_active_high, panel_dev_config.vendor_config); + esp_lcd_panel_handle_t panel_handle; + ESP_ERROR_CHECK(esp_lcd_new_panel_axs15231b(io_handle, &panel_dev_config, &panel_handle)); + ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle)); + ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle)); +#ifdef DISPLAY_IPS + // If LCD is IPS invert the colors + ESP_ERROR_CHECK(esp_lcd_panel_invert_color(panel_handle, true)); +#endif +#if (DISPLAY_SWAP_XY) + ESP_ERROR_CHECK(esp_lcd_panel_swap_xy(panel_handle, DISPLAY_SWAP_XY)); +#endif +#if (DISPLAY_MIRROR_X || DISPLAY_MIRROR_Y) + ESP_ERROR_CHECK(esp_lcd_panel_mirror(panel_handle, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y)); +#endif +#if (DISPLAY_GAP_X || DISPLAY_GAP_Y) + ESP_ERROR_CHECK(esp_lcd_panel_set_gap(panel_handle, DISPLAY_GAP_X, DISPLAY_GAP_Y)); +#endif + // Turn display on + ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true)); + + display->user_data = panel_handle; + display->flush_cb = axs15231b_lv_flush; + + return display; +} + +#endif \ No newline at end of file diff --git a/src/lvgl_panel_gc9a01_spi.c b/src/lvgl_panel_gc9a01_spi.c index b6c0b85..4f291f8 100644 --- a/src/lvgl_panel_gc9a01_spi.c +++ b/src/lvgl_panel_gc9a01_spi.c @@ -43,11 +43,11 @@ lv_display_t *lvgl_lcd_init() // Create SPI bus const spi_bus_config_t spi_bus_config = { - .mosi_io_num = GC9A01_SPI_BUS_MOSI_IO_NUM, - .miso_io_num = GC9A01_SPI_BUS_MISO_IO_NUM, - .sclk_io_num = GC9A01_SPI_BUS_SCLK_IO_NUM, - .quadwp_io_num = GC9A01_SPI_BUS_QUADWP_IO_NUM, - .quadhd_io_num = GC9A01_SPI_BUS_QUADHD_IO_NUM, + .mosi_io_num = GC9A01_SPI_BUS_MOSI, + .miso_io_num = GC9A01_SPI_BUS_MISO, + .sclk_io_num = GC9A01_SPI_BUS_SCLK, + .quadwp_io_num = GC9A01_SPI_BUS_QUADWP, + .quadhd_io_num = GC9A01_SPI_BUS_QUADHD, .max_transfer_sz = GC9A01_SPI_BUS_MAX_TRANSFER_SZ, .flags = GC9A01_SPI_BUS_FLAGS, .intr_flags = GC9A01_SPI_BUS_INTR_FLAGS}; @@ -56,8 +56,8 @@ lv_display_t *lvgl_lcd_init() // Attach the LCD controller to the SPI bus const esp_lcd_panel_io_spi_config_t io_spi_config = { - .cs_gpio_num = GC9A01_SPI_CONFIG_CS_GPIO_NUM, - .dc_gpio_num = GC9A01_SPI_CONFIG_DC_GPIO_NUM, + .cs_gpio_num = GC9A01_SPI_CONFIG_CS, + .dc_gpio_num = GC9A01_SPI_CONFIG_DC, .spi_mode = GC9A01_SPI_CONFIG_SPI_MODE, .pclk_hz = GC9A01_SPI_CONFIG_PCLK_HZ, .trans_queue_depth = GC9A01_SPI_CONFIG_TRANS_QUEUE_DEPTH, @@ -76,7 +76,7 @@ lv_display_t *lvgl_lcd_init() // Create gc9a01 panel handle const esp_lcd_panel_dev_config_t panel_dev_config = { - .reset_gpio_num = GC9A01_DEV_CONFIG_RESET_GPIO_NUM, + .reset_gpio_num = GC9A01_DEV_CONFIG_RESET, .color_space = GC9A01_DEV_CONFIG_COLOR_SPACE, .bits_per_pixel = GC9A01_DEV_CONFIG_BITS_PER_PIXEL, .flags = { diff --git a/src/lvgl_panel_ili9341_spi.c b/src/lvgl_panel_ili9341_spi.c index a36d53e..b44d0a5 100644 --- a/src/lvgl_panel_ili9341_spi.c +++ b/src/lvgl_panel_ili9341_spi.c @@ -39,11 +39,11 @@ lv_display_t *lvgl_lcd_init() // Create SPI bus const spi_bus_config_t spi_bus_config = { - .mosi_io_num = ILI9341_SPI_BUS_MOSI_IO_NUM, - .miso_io_num = ILI9341_SPI_BUS_MISO_IO_NUM, - .sclk_io_num = ILI9341_SPI_BUS_SCLK_IO_NUM, - .quadwp_io_num = ILI9341_SPI_BUS_QUADWP_IO_NUM, - .quadhd_io_num = ILI9341_SPI_BUS_QUADHD_IO_NUM, + .mosi_io_num = ILI9341_SPI_BUS_MOSI, + .miso_io_num = ILI9341_SPI_BUS_MISO, + .sclk_io_num = ILI9341_SPI_BUS_SCLK, + .quadwp_io_num = ILI9341_SPI_BUS_QUADWP, + .quadhd_io_num = ILI9341_SPI_BUS_QUADHD, .max_transfer_sz = ILI9341_SPI_BUS_MAX_TRANSFER_SZ, .flags = ILI9341_SPI_BUS_FLAGS, .intr_flags = ILI9341_SPI_BUS_INTR_FLAGS}; @@ -52,8 +52,8 @@ lv_display_t *lvgl_lcd_init() // Attach the LCD controller to the SPI bus const esp_lcd_panel_io_spi_config_t io_spi_config = { - .cs_gpio_num = ILI9341_SPI_CONFIG_CS_GPIO_NUM, - .dc_gpio_num = ILI9341_SPI_CONFIG_DC_GPIO_NUM, + .cs_gpio_num = ILI9341_SPI_CONFIG_CS, + .dc_gpio_num = ILI9341_SPI_CONFIG_DC, .spi_mode = ILI9341_SPI_CONFIG_SPI_MODE, .pclk_hz = ILI9341_SPI_CONFIG_PCLK_HZ, .trans_queue_depth = ILI9341_SPI_CONFIG_TRANS_QUEUE_DEPTH, @@ -72,7 +72,7 @@ lv_display_t *lvgl_lcd_init() // Create ili9341 panel handle const esp_lcd_panel_dev_config_t panel_dev_config = { - .reset_gpio_num = ILI9341_DEV_CONFIG_RESET_GPIO_NUM, + .reset_gpio_num = ILI9341_DEV_CONFIG_RESET, .color_space = ILI9341_DEV_CONFIG_COLOR_SPACE, .bits_per_pixel = ILI9341_DEV_CONFIG_BITS_PER_PIXEL, .flags = { diff --git a/src/lvgl_panel_st7262_par.c b/src/lvgl_panel_st7262_par.c index 81025d7..8e447cc 100644 --- a/src/lvgl_panel_st7262_par.c +++ b/src/lvgl_panel_st7262_par.c @@ -91,13 +91,13 @@ lv_display_t *lvgl_lcd_init() .data_width = ST7262_PANEL_CONFIG_DATA_WIDTH, .sram_trans_align = ST7262_PANEL_CONFIG_SRAM_TRANS_ALIGN, .psram_trans_align = ST7262_PANEL_CONFIG_PSRAM_TRANS_ALIGN, - .hsync_gpio_num = ST7262_PANEL_CONFIG_HSYNC_GPIO_NUM, - .vsync_gpio_num = ST7262_PANEL_CONFIG_VSYNC_GPIO_NUM, - .de_gpio_num = ST7262_PANEL_CONFIG_DE_GPIO_NUM, - .pclk_gpio_num = ST7262_PANEL_CONFIG_PCLK_GPIO_NUM, + .hsync_gpio_num = ST7262_PANEL_CONFIG_HSYNC, + .vsync_gpio_num = ST7262_PANEL_CONFIG_VSYNC, + .de_gpio_num = ST7262_PANEL_CONFIG_DE, + .pclk_gpio_num = ST7262_PANEL_CONFIG_PCLK, // LV_COLOR_16_SWAP is handled by mapping of the data - .data_gpio_nums = {ST7262_PANEL_CONFIG_DATA_GPIO_R0, ST7262_PANEL_CONFIG_DATA_GPIO_R1, ST7262_PANEL_CONFIG_DATA_GPIO_R2, ST7262_PANEL_CONFIG_DATA_GPIO_R3, ST7262_PANEL_CONFIG_DATA_GPIO_R4, ST7262_PANEL_CONFIG_DATA_GPIO_G0, ST7262_PANEL_CONFIG_DATA_GPIO_G1, ST7262_PANEL_CONFIG_DATA_GPIO_G2, ST7262_PANEL_CONFIG_DATA_GPIO_G3, ST7262_PANEL_CONFIG_DATA_GPIO_G4, ST7262_PANEL_CONFIG_DATA_GPIO_G5, ST7262_PANEL_CONFIG_DATA_GPIO_B0, ST7262_PANEL_CONFIG_DATA_GPIO_B1, ST7262_PANEL_CONFIG_DATA_GPIO_B2, ST7262_PANEL_CONFIG_DATA_GPIO_B3, ST7262_PANEL_CONFIG_DATA_GPIO_B4}, - .disp_gpio_num = ST7262_PANEL_CONFIG_DISP_GPIO_NUM, + .data_gpio_nums = {ST7262_PANEL_CONFIG_DATA_R0, ST7262_PANEL_CONFIG_DATA_R1, ST7262_PANEL_CONFIG_DATA_R2, ST7262_PANEL_CONFIG_DATA_R3, ST7262_PANEL_CONFIG_DATA_R4, ST7262_PANEL_CONFIG_DATA_G0, ST7262_PANEL_CONFIG_DATA_G1, ST7262_PANEL_CONFIG_DATA_G2, ST7262_PANEL_CONFIG_DATA_G3, ST7262_PANEL_CONFIG_DATA_G4, ST7262_PANEL_CONFIG_DATA_G5, ST7262_PANEL_CONFIG_DATA_B0, ST7262_PANEL_CONFIG_DATA_B1, ST7262_PANEL_CONFIG_DATA_B2, ST7262_PANEL_CONFIG_DATA_B3, ST7262_PANEL_CONFIG_DATA_B4}, + .disp_gpio_num = ST7262_PANEL_CONFIG_DISP, .on_frame_trans_done = direct_io_frame_trans_done, .user_ctx = display, .flags = {.disp_active_low = ST7262_PANEL_CONFIG_FLAGS_DISP_ACTIVE_LOW, .relax_on_idle = ST7262_PANEL_CONFIG_FLAGS_RELAX_ON_IDLE, .fb_in_psram = ST7262_PANEL_CONFIG_FLAGS_FB_IN_PSRAM}}; diff --git a/src/lvgl_panel_st7701_par.c b/src/lvgl_panel_st7701_par.c index d2861c3..8b0f5b6 100644 --- a/src/lvgl_panel_st7701_par.c +++ b/src/lvgl_panel_st7701_par.c @@ -73,11 +73,11 @@ lv_display_t *lvgl_lcd_init() esp_lcd_panel_io_3wire_spi_config_t io_3wire_spi_config = { .line_config = { .cs_io_type = IO_TYPE_GPIO, - .cs_gpio_num = ST7701_IO_3WIRE_SPI_LINE_CONFIG_CS_GPIO_NUM, + .cs_gpio_num = ST7701_IO_3WIRE_SPI_LINE_CONFIG_CS, .scl_io_type = IO_TYPE_GPIO, - .scl_gpio_num = ST7701_IO_3WIRE_SPI_LINE_CONFIG_SCL_GPIO_NUM, + .scl_gpio_num = ST7701_IO_3WIRE_SPI_LINE_CONFIG_SCL, .sda_io_type = IO_TYPE_GPIO, - .sda_gpio_num = ST7701_IO_3WIRE_SPI_LINE_CONFIG_SDA_GPIO_NUM}, + .sda_gpio_num = ST7701_IO_3WIRE_SPI_LINE_CONFIG_SDA}, .expect_clk_speed = ST7701_IO_3WIRE_SPI_EXPECT_CLK_SPEED, .spi_mode = ST7701_IO_3WIRE_SPI_SPI_MODE, .lcd_cmd_bytes = ST7701_IO_3WIRE_SPI_LCD_CMD_BYTES, @@ -109,19 +109,19 @@ lv_display_t *lvgl_lcd_init() .data_width = ST7701_PANEL_CONFIG_DATA_WIDTH, .sram_trans_align = ST7701_PANEL_CONFIG_SRAM_TRANS_ALIGN, .psram_trans_align = ST7701_PANEL_CONFIG_PSRAM_TRANS_ALIGN, - .hsync_gpio_num = ST7701_PANEL_CONFIG_HSYNC_GPIO_NUM, - .vsync_gpio_num = ST7701_PANEL_CONFIG_VSYNC_GPIO_NUM, - .de_gpio_num = ST7701_PANEL_CONFIG_DE_GPIO_NUM, - .pclk_gpio_num = ST7701_PANEL_CONFIG_PCLK_GPIO_NUM, - .data_gpio_nums = {ST7701_PANEL_CONFIG_DATA_GPIO_R0, ST7701_PANEL_CONFIG_DATA_GPIO_R1, ST7701_PANEL_CONFIG_DATA_GPIO_R2, ST7701_PANEL_CONFIG_DATA_GPIO_R3, ST7701_PANEL_CONFIG_DATA_GPIO_R4, ST7701_PANEL_CONFIG_DATA_GPIO_G0, ST7701_PANEL_CONFIG_DATA_GPIO_G1, ST7701_PANEL_CONFIG_DATA_GPIO_G2, ST7701_PANEL_CONFIG_DATA_GPIO_G3, ST7701_PANEL_CONFIG_DATA_GPIO_G4, ST7701_PANEL_CONFIG_DATA_GPIO_G5, ST7701_PANEL_CONFIG_DATA_GPIO_B0, ST7701_PANEL_CONFIG_DATA_GPIO_B1, ST7701_PANEL_CONFIG_DATA_GPIO_B2, ST7701_PANEL_CONFIG_DATA_GPIO_B3, ST7701_PANEL_CONFIG_DATA_GPIO_B4}, - .disp_gpio_num = ST7701_PANEL_CONFIG_DISP_GPIO_NUM, + .hsync_gpio_num = ST7701_PANEL_CONFIG_HSYNC, + .vsync_gpio_num = ST7701_PANEL_CONFIG_VSYNC, + .de_gpio_num = ST7701_PANEL_CONFIG_DE, + .pclk_gpio_num = ST7701_PANEL_CONFIG_PCLK, + .data_gpio_nums = {ST7701_PANEL_CONFIG_DATA_R0, ST7701_PANEL_CONFIG_DATA_R1, ST7701_PANEL_CONFIG_DATA_R2, ST7701_PANEL_CONFIG_DATA_R3, ST7701_PANEL_CONFIG_DATA_R4, ST7701_PANEL_CONFIG_DATA_G0, ST7701_PANEL_CONFIG_DATA_G1, ST7701_PANEL_CONFIG_DATA_G2, ST7701_PANEL_CONFIG_DATA_G3, ST7701_PANEL_CONFIG_DATA_G4, ST7701_PANEL_CONFIG_DATA_G5, ST7701_PANEL_CONFIG_DATA_B0, ST7701_PANEL_CONFIG_DATA_B1, ST7701_PANEL_CONFIG_DATA_B2, ST7701_PANEL_CONFIG_DATA_B3, ST7701_PANEL_CONFIG_DATA_B4}, + .disp_gpio_num = ST7701_PANEL_CONFIG_DISP, .on_frame_trans_done = direct_io_frame_trans_done, .user_ctx = display, .flags = {.disp_active_low = ST7701_PANEL_CONFIG_FLAGS_DISP_ACTIVE_LOW, .relax_on_idle = ST7701_PANEL_CONFIG_FLAGS_RELAX_ON_IDLE, .fb_in_psram = ST7701_PANEL_CONFIG_FLAGS_FB_IN_PSRAM}}; log_d("rgb_panel_config: clk_src:%d, timings:{pclk_hz:%d, h_res:%d, v_res:%d, hsync_pulse_width:%d, hsync_back_porch:%d, hsync_front_porch:%d, vsync_pulse_width:%d, vsync_back_porch:%d, vsync_front_porch:%d, flags:{hsync_idle_low:%d, vsync_idle_low:%d, de_idle_high:%d, pclk_active_neg:%d, pclk_idle_high:%d}}, data_width:%d, sram_trans_align:%d, psram_trans_align:%d, hsync_gpio_num:%d, vsync_gpio_num:%d, de_gpio_num:%d, pclk_gpio_num:%d, data_gpio_nums:[%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d], disp_gpio_num:%d, on_frame_trans_done:0x%08x, user_ctx:0x%08x, flags:{disp_active_low:%d, relax_on_idle:%d, fb_in_psram:%d}", rgb_panel_config.clk_src, rgb_panel_config.timings.pclk_hz, rgb_panel_config.timings.h_res, rgb_panel_config.timings.v_res, rgb_panel_config.timings.hsync_pulse_width, rgb_panel_config.timings.hsync_back_porch, rgb_panel_config.timings.hsync_front_porch, rgb_panel_config.timings.vsync_pulse_width, rgb_panel_config.timings.vsync_back_porch, rgb_panel_config.timings.vsync_front_porch, rgb_panel_config.timings.flags.hsync_idle_low, rgb_panel_config.timings.flags.vsync_idle_low, rgb_panel_config.timings.flags.de_idle_high, rgb_panel_config.timings.flags.pclk_active_neg, rgb_panel_config.timings.flags.pclk_idle_high, rgb_panel_config.data_width, rgb_panel_config.sram_trans_align, rgb_panel_config.psram_trans_align, rgb_panel_config.hsync_gpio_num, rgb_panel_config.vsync_gpio_num, rgb_panel_config.de_gpio_num, rgb_panel_config.pclk_gpio_num, rgb_panel_config.data_gpio_nums[0], rgb_panel_config.data_gpio_nums[1], rgb_panel_config.data_gpio_nums[2], rgb_panel_config.data_gpio_nums[3], rgb_panel_config.data_gpio_nums[4], rgb_panel_config.data_gpio_nums[5], rgb_panel_config.data_gpio_nums[6], rgb_panel_config.data_gpio_nums[7], rgb_panel_config.data_gpio_nums[8], rgb_panel_config.data_gpio_nums[9], rgb_panel_config.data_gpio_nums[10], rgb_panel_config.data_gpio_nums[11], rgb_panel_config.data_gpio_nums[12], rgb_panel_config.data_gpio_nums[13], rgb_panel_config.data_gpio_nums[14], rgb_panel_config.data_gpio_nums[15], rgb_panel_config.disp_gpio_num, rgb_panel_config.on_frame_trans_done, rgb_panel_config.user_ctx, rgb_panel_config.flags.disp_active_low, rgb_panel_config.flags.relax_on_idle, rgb_panel_config.flags.fb_in_psram); log_d("refresh rate: %d Hz", (ST7701_PANEL_CONFIG_TIMINGS_PCLK_HZ * ST7701_PANEL_CONFIG_DATA_WIDTH) / (ST7701_PANEL_CONFIG_TIMINGS_H_RES + ST7701_PANEL_CONFIG_TIMINGS_HSYNC_PULSE_WIDTH + ST7701_PANEL_CONFIG_TIMINGS_HSYNC_BACK_PORCH + ST7701_PANEL_CONFIG_TIMINGS_HSYNC_FRONT_PORCH) / (ST7701_PANEL_CONFIG_TIMINGS_V_RES + ST7701_PANEL_CONFIG_TIMINGS_VSYNC_PULSE_WIDTH + ST7701_PANEL_CONFIG_TIMINGS_VSYNC_BACK_PORCH + ST7701_PANEL_CONFIG_TIMINGS_VSYNC_FRONT_PORCH) / SOC_LCD_RGB_DATA_WIDTH); const esp_lcd_panel_dev_config_t panel_dev_config = { - .reset_gpio_num = ST7701_DEV_CONFIG_RESET_GPIO_NUM, + .reset_gpio_num = ST7701_DEV_CONFIG_RESET, .color_space = ST7701_DEV_CONFIG_COLOR_SPACE, .bits_per_pixel = ST7701_DEV_CONFIG_BITS_PER_PIXEL, .flags = { diff --git a/src/lvgl_panel_st7789_i80.c b/src/lvgl_panel_st7789_i80.c index 19cbef5..338d49e 100644 --- a/src/lvgl_panel_st7789_i80.c +++ b/src/lvgl_panel_st7789_i80.c @@ -36,8 +36,8 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) void *drawBuffer = heap_caps_malloc(drawBufferSize, LVGL_BUFFER_MALLOC_FLAGS); lv_display_set_buffers(display, drawBuffer, NULL, drawBufferSize, LV_DISPLAY_RENDER_MODE_PARTIAL); - pinMode(ST7789_RD_GPIO, OUTPUT); - digitalWrite(ST7789_RD_GPIO, HIGH); + pinMode(ST7789_RD, OUTPUT); + digitalWrite(ST7789_RD, HIGH); const esp_lcd_i80_bus_config_t i80_bus_config = { .clk_src = ST7789_I80_BUS_CONFIG_CLK_SRC, @@ -63,7 +63,7 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Create direct_io panel handle esp_lcd_panel_io_i80_config_t io_i80_config = { - .cs_gpio_num = ST7789_IO_I80_CONFIG_CS_GPIO_NUM, + .cs_gpio_num = ST7789_IO_I80_CONFIG_CS, .pclk_hz = ST7789_IO_I80_CONFIG_PCLK_HZ, .on_color_trans_done = st7789_color_trans_done, .user_ctx = display, @@ -82,7 +82,7 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Create ST7789 panel handle const esp_lcd_panel_dev_config_t panel_dev_config = { - .reset_gpio_num = ST7789_DEV_CONFIG_RESET_GPIO_NUM, + .reset_gpio_num = ST7789_DEV_CONFIG_RESET, .color_space = ST7789_DEV_CONFIG_COLOR_SPACE, .bits_per_pixel = ST7789_DEV_CONFIG_BITS_PER_PIXEL, .flags = { diff --git a/src/lvgl_panel_st7789_spi.c b/src/lvgl_panel_st7789_spi.c index 24ab2cd..4a3bf82 100644 --- a/src/lvgl_panel_st7789_spi.c +++ b/src/lvgl_panel_st7789_spi.c @@ -39,11 +39,11 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Create SPI bus const spi_bus_config_t spi_bus_config = { - .mosi_io_num = ST7789_SPI_BUS_MOSI_IO_NUM, - .miso_io_num = ST7789_SPI_BUS_MISO_IO_NUM, - .sclk_io_num = ST7789_SPI_BUS_SCLK_IO_NUM, - .quadwp_io_num = ST7789_SPI_BUS_QUADWP_IO_NUM, - .quadhd_io_num = ST7789_SPI_BUS_QUADHD_IO_NUM, + .mosi_io_num = ST7789_SPI_BUS_MOSI, + .miso_io_num = ST7789_SPI_BUS_MISO, + .sclk_io_num = ST7789_SPI_BUS_SCLK, + .quadwp_io_num = ST7789_SPI_BUS_QUADWP, + .quadhd_io_num = ST7789_SPI_BUS_QUADHD, .max_transfer_sz = ST7789_SPI_BUS_MAX_TRANSFER_SZ, .flags = ST7789_SPI_BUS_FLAGS, .intr_flags = ST7789_SPI_BUS_INTR_FLAGS}; @@ -52,8 +52,8 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Attach the LCD controller to the SPI bus const esp_lcd_panel_io_spi_config_t io_spi_config = { - .cs_gpio_num = ST7789_SPI_CONFIG_CS_GPIO_NUM, - .dc_gpio_num = ST7789_SPI_CONFIG_DC_GPIO_NUM, + .cs_gpio_num = ST7789_SPI_CONFIG_CS, + .dc_gpio_num = ST7789_SPI_CONFIG_DC, .spi_mode = ST7789_SPI_CONFIG_SPI_MODE, .pclk_hz = ST7789_SPI_CONFIG_PCLK_HZ, .on_color_trans_done = st7789_color_trans_done, @@ -72,7 +72,7 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Create st7789 panel handle const esp_lcd_panel_dev_config_t panel_dev_config = { - .reset_gpio_num = ST7789_DEV_CONFIG_RESET_GPIO_NUM, + .reset_gpio_num = ST7789_DEV_CONFIG_RESET, .color_space = ST7789_DEV_CONFIG_COLOR_SPACE, .bits_per_pixel = ST7789_DEV_CONFIG_BITS_PER_PIXEL, .flags = { diff --git a/src/lvgl_panel_st7796_spi.c b/src/lvgl_panel_st7796_spi.c index 5e55a48..063c981 100644 --- a/src/lvgl_panel_st7796_spi.c +++ b/src/lvgl_panel_st7796_spi.c @@ -40,11 +40,11 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Create SPI bus const spi_bus_config_t spi_bus_config = { - .mosi_io_num = ST7796_SPI_BUS_MOSI_IO_NUM, - .miso_io_num = ST7796_SPI_BUS_MISO_IO_NUM, - .sclk_io_num = ST7796_SPI_BUS_SCLK_IO_NUM, - .quadwp_io_num = ST7796_SPI_BUS_QUADWP_IO_NUM, - .quadhd_io_num = ST7796_SPI_BUS_QUADHD_IO_NUM, + .mosi_io_num = ST7796_SPI_BUS_MOSI, + .miso_io_num = ST7796_SPI_BUS_MISO, + .sclk_io_num = ST7796_SPI_BUS_SCLK, + .quadwp_io_num = ST7796_SPI_BUS_QUADWP, + .quadhd_io_num = ST7796_SPI_BUS_QUADHD, .max_transfer_sz = ST7796_SPI_BUS_MAX_TRANSFER_SZ, .flags = ST7796_SPI_BUS_FLAGS, .intr_flags = ST7796_SPI_BUS_INTR_FLAGS}; @@ -53,8 +53,8 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Attach the LCD controller to the SPI bus const esp_lcd_panel_io_spi_config_t io_spi_config = { - .cs_gpio_num = ST7796_SPI_CONFIG_CS_GPIO_NUM, - .dc_gpio_num = ST7796_SPI_CONFIG_DC_GPIO_NUM, + .cs_gpio_num = ST7796_SPI_CONFIG_CS, + .dc_gpio_num = ST7796_SPI_CONFIG_DC, .spi_mode = ST7796_SPI_CONFIG_SPI_MODE, .pclk_hz = ST7796_SPI_CONFIG_PCLK_HZ, .on_color_trans_done = st7796_color_trans_done, @@ -73,7 +73,7 @@ lv_display_t *lvgl_lcd_init(uint32_t hor_res, uint32_t ver_res) // Create st7796 panel handle const esp_lcd_panel_dev_config_t panel_dev_config = { - .reset_gpio_num = ST7796_DEV_CONFIG_RESET_GPIO_NUM, + .reset_gpio_num = ST7796_DEV_CONFIG_RESET, .color_space = ST7796_DEV_CONFIG_COLOR_SPACE, .bits_per_pixel = ST7796_DEV_CONFIG_BITS_PER_PIXEL, .flags = { diff --git a/src/lvgl_touch_cst816s_i2c.c b/src/lvgl_touch_cst816s_i2c.c index efb83cd..d6e06f8 100644 --- a/src/lvgl_touch_cst816s_i2c.c +++ b/src/lvgl_touch_cst816s_i2c.c @@ -35,8 +35,8 @@ lv_indev_t *lvgl_touch_init() // Create I2C bus const i2c_config_t i2c_config = { .mode = I2C_MODE_MASTER, - .sda_io_num = CST816S_I2C_CONFIG_SDA_IO_NUM, - .scl_io_num = CST816S_I2C_CONFIG_SCL_IO_NUM, + .sda_io_num = CST816S_I2C_CONFIG_SDA, + .scl_io_num = CST816S_I2C_CONFIG_SCL, .sda_pullup_en = CST816S_I2C_CONFIG_SDA_PULLUP_EN, .scl_pullup_en = CST816S_I2C_CONFIG_SCL_PULLUP_EN, .master = { @@ -65,8 +65,8 @@ lv_indev_t *lvgl_touch_init() const esp_lcd_touch_config_t touch_config = { .x_max = CST816S_TOUCH_CONFIG_X_MAX, .y_max = CST816S_TOUCH_CONFIG_Y_MAX, - .rst_gpio_num = CST816S_TOUCH_CONFIG_RST_GPIO_NUM, - .int_gpio_num = CST816S_TOUCH_CONFIG_INT_GPIO_NUM, + .rst_gpio_num = CST816S_TOUCH_CONFIG_RST, + .int_gpio_num = CST816S_TOUCH_CONFIG_INT, .levels = { .reset = CST816S_TOUCH_CONFIG_LEVELS_RESET, .interrupt = CST816S_TOUCH_CONFIG_LEVELS_INTERRUPT}, diff --git a/src/lvgl_touch_gt911_i2c.c b/src/lvgl_touch_gt911_i2c.c index 41778b4..a604209 100644 --- a/src/lvgl_touch_gt911_i2c.c +++ b/src/lvgl_touch_gt911_i2c.c @@ -36,8 +36,8 @@ lv_indev_t* lvgl_touch_init() // Create I2C bus const i2c_config_t i2c_config = { .mode = I2C_MODE_MASTER, - .sda_io_num = GT911_I2C_CONFIG_SDA_IO_NUM, - .scl_io_num = GT911_I2C_CONFIG_SCL_IO_NUM, + .sda_io_num = GT911_I2C_CONFIG_SDA, + .scl_io_num = GT911_I2C_CONFIG_SCL, .sda_pullup_en = GT911_I2C_CONFIG_SDA_PULLUP_EN, .scl_pullup_en = GT911_I2C_CONFIG_SCL_PULLUP_EN, .master = { @@ -66,8 +66,8 @@ lv_indev_t* lvgl_touch_init() const esp_lcd_touch_config_t touch_config = { .x_max = GT911_TOUCH_CONFIG_X_MAX, .y_max = GT911_TOUCH_CONFIG_Y_MAX, - .rst_gpio_num = GT911_TOUCH_CONFIG_RST_GPIO_NUM, - .int_gpio_num = GT911_TOUCH_CONFIG_INT_GPIO_NUM, + .rst_gpio_num = GT911_TOUCH_CONFIG_RST, + .int_gpio_num = GT911_TOUCH_CONFIG_INT, .levels = { .reset = GT911_TOUCH_CONFIG_LEVELS_RESET, .interrupt = GT911_TOUCH_CONFIG_LEVELS_INTERRUPT}, diff --git a/src/lvgl_touch_xpt2046_spi.c b/src/lvgl_touch_xpt2046_spi.c index 9a8ab03..e0098f7 100644 --- a/src/lvgl_touch_xpt2046_spi.c +++ b/src/lvgl_touch_xpt2046_spi.c @@ -36,19 +36,19 @@ lv_indev_t *lvgl_touch_init() // Create SPI bus only if not already initialized (S035R shares the SPI bus) if(spi_bus_get_attr(XPT2046_SPI_HOST) == NULL) { const spi_bus_config_t spi_bus_config = { - .mosi_io_num = XPT2046_SPI_BUS_MOSI_IO_NUM, - .miso_io_num = XPT2046_SPI_BUS_MISO_IO_NUM, - .sclk_io_num = XPT2046_SPI_BUS_SCLK_IO_NUM, - .quadwp_io_num = XPT2046_SPI_BUS_QUADWP_IO_NUM, - .quadhd_io_num = XPT2046_SPI_BUS_QUADHD_IO_NUM}; + .mosi_io_num = XPT2046_SPI_BUS_MOSI, + .miso_io_num = XPT2046_SPI_BUS_MISO, + .sclk_io_num = XPT2046_SPI_BUS_SCLK, + .quadwp_io_num = XPT2046_SPI_BUS_QUADWP, + .quadhd_io_num = XPT2046_SPI_BUS_QUADHD}; log_d("spi_bus_config: mosi_io_num:%d, miso_io_num:%d, sclk_io_num:%d, quadwp_io_num:%d, quadhd_io_num:%d, max_transfer_sz:%d, flags:0x%08x, intr_flags:0x%04x", spi_bus_config.mosi_io_num, spi_bus_config.miso_io_num, spi_bus_config.sclk_io_num, spi_bus_config.quadwp_io_num, spi_bus_config.quadhd_io_num, spi_bus_config.max_transfer_sz, spi_bus_config.flags, spi_bus_config.intr_flags); ESP_ERROR_CHECK_WITHOUT_ABORT(spi_bus_initialize(XPT2046_SPI_HOST, &spi_bus_config, XPT2046_SPI_DMA_CHANNEL)); } // Attach the touch controller to the SPI bus const esp_lcd_panel_io_spi_config_t io_spi_config = { - .cs_gpio_num = XPT2046_SPI_CONFIG_CS_GPIO_NUM, - .dc_gpio_num = XPT2046_SPI_CONFIG_DC_GPIO_NUM, + .cs_gpio_num = XPT2046_SPI_CONFIG_CS, + .dc_gpio_num = XPT2046_SPI_CONFIG_DC, .spi_mode = XPT2046_SPI_CONFIG_SPI_MODE, .pclk_hz = XPT2046_SPI_CONFIG_PCLK_HZ, .user_ctx = indev, @@ -68,8 +68,8 @@ lv_indev_t *lvgl_touch_init() const esp_lcd_touch_config_t touch_config = { .x_max = XPT2046_TOUCH_CONFIG_X_MAX, .y_max = XPT2046_TOUCH_CONFIG_Y_MAX, - .rst_gpio_num = XPT2046_TOUCH_CONFIG_RST_GPIO_NUM, - .int_gpio_num = XPT2046_TOUCH_CONFIG_INT_GPIO_NUM, + .rst_gpio_num = XPT2046_TOUCH_CONFIG_RST, + .int_gpio_num = XPT2046_TOUCH_CONFIG_INT, .levels = { .reset = XPT2046_TOUCH_CONFIG_LEVELS_RESET, .interrupt = XPT2046_TOUCH_CONFIG_LEVELS_INTERRUPT},