devttl/xiaozhi-esp32
1
0
Fork 0
forked from xiaozhi/xiaozhi-esp32
Code Pull Requests Activity

Add LILYGO T-Display-P4 board adaptation (#1269)

Browse Source 
* Adapt for LilyGO-T-Circle-S3 device

* Adapt for LilyGO-T-Circle-S3 device

* Remove comments and modify the size of the lilygo-t-circle-s3 image

* Modify the code style and format to Google C++

* Modify the code style and format to Google C++

* Fixed bugs in the LILYGO T-Circle-S3 board and added support for two new boards: LILYGO T-Display-S3-Pro-MVSRLora and LILYGO T-Display-S3-Pro-MVSRLora_NO_BATTERY.

* Added support for two new boards: LILYGO T-Display-S3-Pro-MVSRLora and LILYGO T-Display-S3-Pro-MVSRLora_NO_BATTERY.

* Merge branch 'main' of https://github.com/Llgok/xiaozhi-esp32

* Added support for two new boards: LILYGO T-Display-S3-Pro-MVSRLora and LILYGO T-Display-S3-Pro-MVSRLora_NO_BATTERY.

* Added support for two new boards: LILYGO T-Display-S3-Pro-MVSRLora and LILYGO T-Display-S3-Pro-MVSRLora_NO_BATTERY.

* Added support for two new boards: LILYGO T-Display-S3-Pro-MVSRLora and LILYGO T-Display-S3-Pro-MVSRLora_NO_BATTERY.

* Added support for two new boards: LILYGO T-Display-S3-Pro-MVSRLora and LILYGO T-Display-S3-Pro-MVSRLora_NO_BATTERY.

* Fix the color display issue for T-Display-S3-Pro-MVSRLora and LILYGO T-Display-S3-Pro-MVSRLora_NO_BATTERY.

* Update T-CameraPlus-S3_V1.2 Version Xiaozhi Example

* Resolve the issue where the camera on the T-CameraPlus-S3_V1.2 board cannot be used normally.

* Enhance microphone reception volume

* fix the issue where voice wake-up is not working

* fix the issue where voice wake-up is not working

* Add LILYGO T-Display-P4 board adaptation
This commit is contained in:
LILYGO_L
2025-10-10 10:57:59 +08:00
committed by GitHub
parent 6a28a98c8b
commit 8373a26f85
11 changed files with 1696 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
main/CMakeLists.txt
View File

@@ -323,6 +323,11 @@ elseif(CONFIG_BOARD_TYPE_LILYGO_T_DISPLAY_S3_PRO_MVSRLORA)
set(BUILTIN_TEXT_FONT font_puhui_basic_20_4)
set(BUILTIN_ICON_FONT font_awesome_20_4)
set(DEFAULT_EMOJI_COLLECTION twemoji_64)
elseif(CONFIG_BOARD_TYPE_LILYGO_T_DISPLAY_P4)
set(BOARD_TYPE "lilygo-t-display-p4")
set(BUILTIN_TEXT_FONT font_puhui_basic_30_4)
set(BUILTIN_ICON_FONT font_awesome_30_4)
set(DEFAULT_EMOJI_COLLECTION twemoji_64)
elseif(CONFIG_BOARD_TYPE_MOVECALL_MOJI_ESP32S3)
set(BOARD_TYPE "movecall-moji-esp32s3")
set(BUILTIN_TEXT_FONT font_puhui_basic_20_4)

23
main/Kconfig.projbuild
View File

@@ -273,6 +273,9 @@ choice BOARD_TYPE
config BOARD_TYPE_LILYGO_T_DISPLAY_S3_PRO_MVSRLORA_NO_BATTERY
bool "LILYGO T-Display-S3-Pro-MVSRLora_No_Battery"
depends on IDF_TARGET_ESP32S3
config BOARD_TYPE_LILYGO_T_DISPLAY_P4
bool "LILYGO T-Display-P4"
depends on IDF_TARGET_ESP32P4
config BOARD_TYPE_MOVECALL_MOJI_ESP32S3
bool "Movecall Moji 小智AI衍生版"
depends on IDF_TARGET_ESP32S3
@@ -385,6 +388,26 @@ choice BOARD_TYPE
depends on IDF_TARGET_ESP32S3
endchoice
choice
depends on BOARD_TYPE_LILYGO_T_DISPLAY_P4
prompt "Select the screen type"
default SCREEN_TYPE_HI8561
config SCREEN_TYPE_HI8561
bool "HI8561"
config SCREEN_TYPE_RM69A10
bool "RM69A10"
endchoice
choice
depends on BOARD_TYPE_LILYGO_T_DISPLAY_P4
prompt "Select the color format of the screen"
default SCREEN_PIXEL_FORMAT_RGB565
config SCREEN_PIXEL_FORMAT_RGB565
bool "RGB565"
config SCREEN_PIXEL_FORMAT_RGB888
bool "RGB888"
endchoice
choice ESP_S3_LCD_EV_Board_Version_TYPE
depends on BOARD_TYPE_ESP_S3_LCD_EV_Board
prompt "EV_BOARD Type"

42
main/boards/lilygo-t-display-p4/README.md Normal file
View File

@@ -0,0 +1,42 @@
## LILYGO T-Display-P4
The T-Display-P4 is a versatile development board based on the ESP32-P4 core. Its features include:
1. **High Processing Power**: Equipped with the high-performance ESP32-P4 core processor, it can handle more complex graphics and video tasks, delivering smoother display performance.
2. **Low Power Design**: Offers multiple selectable power modes to effectively reduce energy consumption and extend battery life.
3. **High-Resolution Display**: Supports high resolution (default with a large MIPI interface screen at 540x1168px), providing sharp and clear visuals.
4. **Rich Peripheral Support**: Onboard peripherals include an HD MIPI touchscreen, ESP32-C6 module, speaker, microphone, LoRa module, GPS module, Ethernet, a linear vibration motor, an independent battery gauge for monitoring battery health and percentage, and an MIPI camera. Multiple GPIOs of both the ESP32-P4 and ESP32-C6 are exposed, enhancing the device's expandability.
Official github: [T-Display-P4](https://github.com/Xinyuan-LilyGO/T-Display-P4)
## Configuration
### ESP32P4 Configuration
* Set the compilation target to ESP32P4
idf.py set-target esp32p4
* Open menuconfig
idf.py menuconfig
* Select the board
Xiaozhi Assistant -> Board Type -> LILYGO T-Display-P4
* Select the screen type
Xiaozhi Assistant -> Select the screen type -> (Select the screen type you need to configure)
* Screen the screen pixel format
Xiaozhi Assistant -> Select the color format of the screen -> (Select the screen pixel format you need to configure)
* Build
idf.py build
### ESP32C6 Configuration
* Flash the slave example from the esp-hosted-mcu library for the target chip ESP32C6. The esp-hosted-mcu version must match the one used in the xiaozhi-esp32 library.

76
main/boards/lilygo-t-display-p4/config.h Normal file
View File

@@ -0,0 +1,76 @@
#ifndef _BOARD_CONFIG_H_
#define _BOARD_CONFIG_H_
#include <driver/gpio.h>
#include "t_display_p4_config.h"
#if defined CONFIG_SCREEN_PIXEL_FORMAT_RGB565
#define SCREEN_BITS_PER_PIXEL 16
#define SCREEN_COLOR_RGB_PIXEL_FORMAT LCD_COLOR_PIXEL_FORMAT_RGB565
#define LVGL_COLOR_FORMAT LV_COLOR_FORMAT_RGB565
#elif defined CONFIG_SCREEN_PIXEL_FORMAT_RGB888
#define SCREEN_BITS_PER_PIXEL 24
#define SCREEN_COLOR_RGB_PIXEL_FORMAT LCD_COLOR_PIXEL_FORMAT_RGB888
#define LVGL_COLOR_FORMAT LV_COLOR_FORMAT_RGB888
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
// SCREEN
#if defined CONFIG_SCREEN_TYPE_HI8561
#define SCREEN_WIDTH HI8561_SCREEN_WIDTH
#define SCREEN_HEIGHT HI8561_SCREEN_HEIGHT
#define SCREEN_MIPI_DSI_DPI_CLK_MHZ HI8561_SCREEN_MIPI_DSI_DPI_CLK_MHZ
#define SCREEN_MIPI_DSI_HSYNC HI8561_SCREEN_MIPI_DSI_HSYNC
#define SCREEN_MIPI_DSI_HBP HI8561_SCREEN_MIPI_DSI_HBP
#define SCREEN_MIPI_DSI_HFP HI8561_SCREEN_MIPI_DSI_HFP
#define SCREEN_MIPI_DSI_VSYNC HI8561_SCREEN_MIPI_DSI_VSYNC
#define SCREEN_MIPI_DSI_VBP HI8561_SCREEN_MIPI_DSI_VBP
#define SCREEN_MIPI_DSI_VFP HI8561_SCREEN_MIPI_DSI_VFP
#define SCREEN_DATA_LANE_NUM HI8561_SCREEN_DATA_LANE_NUM
#define SCREEN_LANE_BIT_RATE_MBPS HI8561_SCREEN_LANE_BIT_RATE_MBPS
#elif defined CONFIG_SCREEN_TYPE_RM69A10
#define SCREEN_WIDTH RM69A10_SCREEN_WIDTH
#define SCREEN_HEIGHT RM69A10_SCREEN_HEIGHT
#define SCREEN_MIPI_DSI_DPI_CLK_MHZ RM69A10_SCREEN_MIPI_DSI_DPI_CLK_MHZ
#define SCREEN_MIPI_DSI_HSYNC RM69A10_SCREEN_MIPI_DSI_HSYNC
#define SCREEN_MIPI_DSI_HBP RM69A10_SCREEN_MIPI_DSI_HBP
#define SCREEN_MIPI_DSI_HFP RM69A10_SCREEN_MIPI_DSI_HFP
#define SCREEN_MIPI_DSI_VSYNC RM69A10_SCREEN_MIPI_DSI_VSYNC
#define SCREEN_MIPI_DSI_VBP RM69A10_SCREEN_MIPI_DSI_VBP
#define SCREEN_MIPI_DSI_VFP RM69A10_SCREEN_MIPI_DSI_VFP
#define SCREEN_DATA_LANE_NUM RM69A10_SCREEN_DATA_LANE_NUM
#define SCREEN_LANE_BIT_RATE_MBPS RM69A10_SCREEN_LANE_BIT_RATE_MBPS
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
#define AUDIO_INPUT_SAMPLE_RATE 24000
#define AUDIO_OUTPUT_SAMPLE_RATE 24000
#define AUDIO_INPUT_REFERENCE true
#define AUDIO_I2S_GPIO_MCLK static_cast<gpio_num_t>(ES8311_MCLK)
#define AUDIO_I2S_GPIO_WS static_cast<gpio_num_t>(ES8311_WS_LRCK)
#define AUDIO_I2S_GPIO_BCLK static_cast<gpio_num_t>(ES8311_BCLK)
#define AUDIO_I2S_GPIO_DIN static_cast<gpio_num_t>(ES8311_ADC_DATA)
#define AUDIO_I2S_GPIO_DOUT static_cast<gpio_num_t>(ES8311_DAC_DATA)
#define AUDIO_CODEC_PA_PIN GPIO_NUM_NC
#define AUDIO_CODEC_I2C_SDA_PIN static_cast<gpio_num_t>(ES8311_SDA)
#define AUDIO_CODEC_I2C_SCL_PIN static_cast<gpio_num_t>(ES8311_SCL)
#define AUDIO_CODEC_ES8311_ADDR ES8311_CODEC_DEFAULT_ADDR
#define BOOT_BUTTON_GPIO GPIO_NUM_35
#define SCREEN_SWAP_XY false
#define SCREEN_MIRROR_X false
#define SCREEN_MIRROR_Y false
#define SCREEN_OFFSET_X 0
#define SCREEN_OFFSET_Y 0
#endif // _BOARD_CONFIG_H_

404
main/boards/lilygo-t-display-p4/hi8561_driver.cc Normal file
View File

@@ -0,0 +1,404 @@
/*
* SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "soc/soc_caps.h"
#if SOC_MIPI_DSI_SUPPORTED
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_check.h"
#include "esp_lcd_panel_commands.h"
#include "esp_lcd_panel_interface.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_mipi_dsi.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_log.h"
#include "hi8561_driver.h"
#define HI8561_PAD_CONTROL (0xB2)
#define HI8561_DSI_2_LANE (0x10)
#define HI8561_DSI_4_LANE (0x00)
#define HI8561_CMD_SHLR_BIT (1ULL << 0)
#define HI8561_CMD_UPDN_BIT (1ULL << 1)
#define HI8561_MDCTL_VALUE_DEFAULT (0x01)
static const hi8561_lcd_init_cmd_t vendor_specific_init_default[] = {
// {cmd, { data }, data_size, delay_ms}
/**** CMD_Page 3 ****/
{0xDF, (uint8_t[]){0x90, 0x69, 0xF9}, 3, 0},
{0xDE, (uint8_t[]){0x00}, 1, 0},
{0xBB, (uint8_t[]){0x0F, 0x10, 0x43, 0x50, 0x32, 0x44, 0x44}, 7, 0},
{0xBF, (uint8_t[]){0x46, 0x32}, 2, 0},
{0xC0, (uint8_t[]){0x01, 0xAD, 0x01, 0xAD}, 4, 0},
{0xBD, (uint8_t[]){0x00, 0xB4}, 2, 0},
{0xC6, (uint8_t[]){0x00, 0x7D, 0x00, 0xC8, 0x00, 0x17, 0x1A, 0x82, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01}, 23, 0},
{0xC8, (uint8_t[]){0x23, 0x48, 0x87}, 3, 0},
// {0xCC, (uint8_t[]){0x33}, 1, 0},//4lane
{0xCC, (uint8_t[]){0x31}, 1, 0}, // 2lane
// {0xCC, (uint8_t[]){0x30}, 1, 0}, // 1lane
{0xBC, (uint8_t[]){0x2E, 0x80, 0x84}, 3, 0},
{0xC3, (uint8_t[]){0x3B, 0x01, 0x02, 0x05, 0x0C, 0x0C, 0x75, 0x0A, 0x79, 0x0A, 0x79, 0x02, 0x6E, 0x02, 0x6E, 0x02, 0x6E, 0x0A, 0x0D, 0x0A, 0x0F, 0x0A, 0x0F, 0x0A, 0x0F}, 25, 0},
{0xC4, (uint8_t[]){0x01, 0x02, 0x05, 0x0C, 0x0C, 0x75, 0x0A, 0x79, 0x0A, 0x79, 0x02, 0x6E, 0x02, 0x6E, 0x02, 0x6E, 0x0A, 0x0D, 0x0A, 0x0F, 0x0A, 0x0F, 0x0A, 0x0F}, 24, 0},
{0xC5, (uint8_t[]){0x03, 0x05, 0x0C, 0x0C, 0x75, 0x0A, 0x79, 0x0A, 0x79, 0x02, 0x6E, 0x02, 0x6E, 0x02, 0x6E, 0x0A, 0x0D, 0x0A, 0x0F, 0x0A, 0x0F, 0x0A, 0x0F}, 23, 0},
{0xD7, (uint8_t[]){0x00, 0x0A, 0x63, 0x0A, 0x63, 0x0A, 0x63, 0x0A, 0x63, 0x0A, 0x63, 0x0A, 0x63, 0x0A, 0x63, 0x0A, 0x63}, 17, 0},
{0xCB, (uint8_t[]){0x7F, 0x78, 0x71, 0x64, 0x5A, 0x58, 0x4B, 0x51, 0x3A, 0x53, 0x51, 0x4F, 0x6A, 0x54, 0x57, 0x46, 0x3F, 0x2F, 0x1B, 0x0F, 0x08, 0x7F, 0x78, 0x71, 0x64, 0x5A, 0x58, 0x4B, 0x51, 0x3A, 0x53, 0x51, 0x4F, 0x6A, 0x54, 0x57, 0x46, 0x3F, 0x2F, 0x1B, 0x0F, 0x08, 0x00}, 43, 0},
{0xCE, (uint8_t[]){0x00, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C}, 23, 0},
{0xCF, (uint8_t[]){0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 45, 0},
{0xD0, (uint8_t[]){0x00, 0x1F, 0x1F, 0x11, 0x1E, 0x1F, 0x0F, 0x0F, 0x0D, 0x0D, 0x0B, 0x0B, 0x09, 0x09, 0x07, 0x07, 0x05, 0x05, 0x01, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 29, 0},
{0xD1, (uint8_t[]){0x00, 0x1F, 0x1F, 0x10, 0x1E, 0x1F, 0x0E, 0x0E, 0x0C, 0x0C, 0x0A, 0x0A, 0x08, 0x08, 0x06, 0x06, 0x04, 0x04, 0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 29, 0},
{0xD2, (uint8_t[]){0x00, 0x5F, 0x1F, 0x10, 0x1F, 0x1E, 0x08, 0x08, 0x4A, 0x0A, 0x0C, 0x0C, 0x0E, 0x0E, 0x04, 0x04, 0x06, 0x06, 0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 29, 0},
{0xD3, (uint8_t[]){0x00, 0x1F, 0x1F, 0x11, 0x1F, 0x1E, 0x09, 0x09, 0x0B, 0x0B, 0x0D, 0x0D, 0x0F, 0x0F, 0x05, 0x05, 0x07, 0x07, 0x01, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 29, 0},
{0xD4, (uint8_t[]){0x00, 0x20, 0x0B, 0x00, 0x0D, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x00, 0x81, 0x04, 0xAE, 0x04, 0xB0, 0x04, 0xB2, 0x04, 0xB4, 0x04, 0xB6, 0x04, 0xB8, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x06, 0x44, 0x06, 0x46, 0x03, 0x03, 0x00, 0x00, 0x07, 0x00, 0x06, 0x04, 0xA7, 0x04, 0xA8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0x00}, 87, 0},
{0xD5, (uint8_t[]){0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x07, 0x32, 0x5A, 0x00, 0x00, 0x3C, 0x00, 0x1E, 0x00, 0x1E, 0xB3, 0x00, 0x0F, 0x06, 0x0C, 0x00, 0x71, 0x20, 0x04, 0x10, 0x04, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 61, 0},
{0xCD, (uint8_t[]){0x00, 0x00}, 2, 0},
{0xDE, (uint8_t[]){0x01}, 1, 0},
{0xB9, (uint8_t[]){0x00, 0xFF, 0xFF, 0x04}, 4, 0},
{0xC7, (uint8_t[]){0x1F, 0x14, 0x0E}, 3, 0},
{0xDE, (uint8_t[]){0x02}, 1, 0},
{0xE5, (uint8_t[]){0x00, 0x60, 0x60, 0x02, 0x18, 0x60, 0x18, 0x60, 0x09, 0x04, 0x00, 0xC5, 0x01, 0x2C, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04}, 24, 0},
{0xE6, (uint8_t[]){0x10, 0x10, 0x82}, 3, 0},
{0xC4, (uint8_t[]){0x00, 0x11, 0x07, 0x00, 0x11, 0x01, 0x08}, 7, 0},
{0xC3, (uint8_t[]){0x20, 0xFF}, 2, 0},
{0xBD, (uint8_t[]){0x1B}, 1, 0},
{0xC6, (uint8_t[]){0x4A, 0x00}, 2, 0},
{0xCD, (uint8_t[]){0x14, 0x64, 0x11, 0x40}, 4, 0},
{0xC1, (uint8_t[]){0x00, 0x40, 0x00, 0x02, 0x02, 0x02, 0x02, 0x7F, 0x00, 0x00}, 10, 0},
{0xB3, (uint8_t[]){0x00, 0xA8}, 2, 0},
{0xBB, (uint8_t[]){0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x40, 0x43, 0x04}, 11, 0},
{0xC2, (uint8_t[]){0x02, 0x42, 0x50, 0x00, 0x02, 0xE4, 0x61, 0x73, 0xF9, 0x08}, 10, 0},
{0xEC, (uint8_t[]){0x07, 0x07, 0x40, 0x00, 0x22, 0x02, 0x00, 0xFF, 0x08, 0x7C, 0x00, 0x00, 0x00, 0x00}, 14, 0},
{0xDE, (uint8_t[]){0x03}, 1, 0},
{0xD1, (uint8_t[]){0x00, 0x00, 0x21, 0xFF, 0x00}, 5, 0},
{0xDE, (uint8_t[]){0x00}, 1, 0},
{0x35, (uint8_t[]){0x00}, 0, 30},
{0x11, (uint8_t[]){0x00}, 0, 120},
{0x29, (uint8_t[]){0x00}, 0, 50},
//============ Gamma END===========
};
typedef struct
{
esp_lcd_panel_io_handle_t io;
int reset_gpio_num;
uint8_t madctl_val; // save current value of LCD_CMD_MADCTL register
const hi8561_lcd_init_cmd_t *init_cmds;
uint16_t init_cmds_size;
uint8_t lane_num;
struct
{
unsigned int reset_level : 1;
} flags;
// To save the original functions of MIPI DPI panel
esp_err_t (*del)(esp_lcd_panel_t *panel);
esp_err_t (*init)(esp_lcd_panel_t *panel);
} hi8561_panel_t;
static const char *TAG = "hi8561";
static esp_err_t panel_hi8561_send_init_cmds(hi8561_panel_t *hi8561);
static esp_err_t panel_hi8561_del(esp_lcd_panel_t *panel);
static esp_err_t panel_hi8561_init(esp_lcd_panel_t *panel);
static esp_err_t panel_hi8561_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_hi8561_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_hi8561_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_hi8561_sleep(esp_lcd_panel_t *panel, bool sleep);
static esp_err_t panel_hi8561_on_off(esp_lcd_panel_t *panel, bool on_off);
esp_err_t esp_lcd_new_panel_hi8561(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
esp_lcd_panel_handle_t *ret_panel)
{
// ESP_LOGI(TAG, "version: %d.%d.%d", ESP_LCD_hi8561_VER_MAJOR, ESP_LCD_hi8561_VER_MINOR,
// ESP_LCD_hi8561_VER_PATCH);
ESP_RETURN_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, TAG, "invalid arguments");
hi8561_vendor_config_t *vendor_config = (hi8561_vendor_config_t *)panel_dev_config->vendor_config;
ESP_RETURN_ON_FALSE(vendor_config && vendor_config->mipi_config.dpi_config && vendor_config->mipi_config.dsi_bus, ESP_ERR_INVALID_ARG, TAG,
"invalid vendor config");
esp_err_t ret = ESP_OK;
hi8561_panel_t *hi8561 = (hi8561_panel_t *)calloc(1, sizeof(hi8561_panel_t));
ESP_RETURN_ON_FALSE(hi8561, ESP_ERR_NO_MEM, TAG, "no mem for hi8561 panel");
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_config_t io_conf = {
.pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num,
.mode = GPIO_MODE_OUTPUT,
};
ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed");
}
hi8561->io = io;
hi8561->init_cmds = vendor_config->init_cmds;
hi8561->init_cmds_size = vendor_config->init_cmds_size;
hi8561->lane_num = vendor_config->mipi_config.lane_num;
hi8561->reset_gpio_num = panel_dev_config->reset_gpio_num;
hi8561->flags.reset_level = panel_dev_config->flags.reset_active_high;
hi8561->madctl_val = HI8561_MDCTL_VALUE_DEFAULT;
// Create MIPI DPI panel
ESP_GOTO_ON_ERROR(esp_lcd_new_panel_dpi(vendor_config->mipi_config.dsi_bus, vendor_config->mipi_config.dpi_config, ret_panel), err, TAG,
"create MIPI DPI panel failed");
ESP_LOGD(TAG, "new MIPI DPI panel @%p", *ret_panel);
// Save the original functions of MIPI DPI panel
hi8561->del = (*ret_panel)->del;
hi8561->init = (*ret_panel)->init;
// Overwrite the functions of MIPI DPI panel
(*ret_panel)->del = panel_hi8561_del;
(*ret_panel)->init = panel_hi8561_init;
(*ret_panel)->reset = panel_hi8561_reset;
(*ret_panel)->mirror = panel_hi8561_mirror;
(*ret_panel)->invert_color = panel_hi8561_invert_color;
(*ret_panel)->disp_sleep = panel_hi8561_sleep;
(*ret_panel)->disp_on_off = panel_hi8561_on_off;
(*ret_panel)->user_data = hi8561;
ESP_LOGD(TAG, "new hi8561 panel @%p", hi8561);
return ESP_OK;
err:
if (hi8561)
{
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_reset_pin(static_cast<gpio_num_t>(panel_dev_config->reset_gpio_num));
}
free(hi8561);
}
return ret;
}
static esp_err_t panel_hi8561_send_init_cmds(hi8561_panel_t *hi8561)
{
esp_lcd_panel_io_handle_t io = hi8561->io;
const hi8561_lcd_init_cmd_t *init_cmds = NULL;
uint16_t init_cmds_size = 0;
// uint8_t lane_command = HI8561_DSI_2_LANE;
// bool is_cmd_overwritten = false;
// switch (hi8561->lane_num)
// {
// case 0:
// case 2:
// lane_command = HI8561_DSI_2_LANE;
// break;
// case 4:
// lane_command = HI8561_DSI_4_LANE;
// break;
// default:
// ESP_LOGE(TAG, "Invalid lane number %d", hi8561->lane_num);
// return ESP_ERR_INVALID_ARG;
// }
// ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, HI8561_PAD_CONTROL, (uint8_t[]){
// lane_command,
// },
// 1),
// TAG, "send command failed");
// vendor specific initialization, it can be different between manufacturers
// should consult the LCD supplier for initialization sequence code
// if (hi8561->init_cmds)
// {
// init_cmds = hi8561->init_cmds;
// init_cmds_size = hi8561->init_cmds_size;
// }
// else
// {
// init_cmds = vendor_specific_init_default;
// init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(hi8561_lcd_init_cmd_t);
// }
init_cmds = vendor_specific_init_default;
init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(hi8561_lcd_init_cmd_t);
for (int i = 0; i < init_cmds_size; i++)
{
// // Check if the command has been used or conflicts with the internal
// if (init_cmds[i].data_bytes > 0)
// {
// switch (init_cmds[i].cmd)
// {
// case LCD_CMD_MADCTL:
// is_cmd_overwritten = true;
// hi8561->madctl_val = ((uint8_t *)init_cmds[i].data)[0];
// break;
// default:
// is_cmd_overwritten = false;
// break;
// }
// if (is_cmd_overwritten)
// {
// is_cmd_overwritten = false;
// ESP_LOGW(TAG, "The %02Xh command has been used and will be overwritten by external initialization sequence",
// init_cmds[i].cmd);
// }
// }
esp_lcd_panel_io_tx_param(io, init_cmds[i].cmd, init_cmds[i].data, init_cmds[i].data_bytes);
vTaskDelay(pdMS_TO_TICKS(init_cmds[i].delay_ms));
// printf("Ciallo\n");
}
ESP_LOGD(TAG, "send init commands success");
return ESP_OK;
}
static esp_err_t panel_hi8561_del(esp_lcd_panel_t *panel)
{
hi8561_panel_t *hi8561 = (hi8561_panel_t *)panel->user_data;
if (hi8561->reset_gpio_num >= 0)
{
gpio_reset_pin(static_cast<gpio_num_t>(hi8561->reset_gpio_num));
}
// Delete MIPI DPI panel
hi8561->del(panel);
ESP_LOGD(TAG, "del hi8561 panel @%p", hi8561);
free(hi8561);
return ESP_OK;
}
static esp_err_t panel_hi8561_init(esp_lcd_panel_t *panel)
{
hi8561_panel_t *hi8561 = (hi8561_panel_t *)panel->user_data;
ESP_RETURN_ON_ERROR(panel_hi8561_send_init_cmds(hi8561), TAG, "send init commands failed");
ESP_RETURN_ON_ERROR(hi8561->init(panel), TAG, "init MIPI DPI panel failed");
return ESP_OK;
}
static esp_err_t panel_hi8561_reset(esp_lcd_panel_t *panel)
{
hi8561_panel_t *hi8561 = (hi8561_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = hi8561->io;
// Perform hardware reset
if (hi8561->reset_gpio_num >= 0)
{
gpio_set_level(static_cast<gpio_num_t>(hi8561->reset_gpio_num), hi8561->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
gpio_set_level(static_cast<gpio_num_t>(hi8561->reset_gpio_num), !hi8561->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(20));
}
else if (io)
{ // Perform software reset
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(20));
}
return ESP_OK;
}
static esp_err_t panel_hi8561_sleep(esp_lcd_panel_t *panel, bool sleep)
{
hi8561_panel_t *hi8561 = (hi8561_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = hi8561->io;
if (sleep == true)
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x10, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_hi8561 sleep on");
}
else
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x11, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_hi8561 sleep off");
}
vTaskDelay(pdMS_TO_TICKS(120));
return ESP_OK;
}
static esp_err_t panel_hi8561_on_off(esp_lcd_panel_t *panel, bool on_off)
{
hi8561_panel_t *hi8561 = (hi8561_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = hi8561->io;
if (on_off == true)
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x29, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_hi8561 display on");
}
else
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x28, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_hi8561 display off");
}
vTaskDelay(pdMS_TO_TICKS(120));
return ESP_OK;
}
static esp_err_t panel_hi8561_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
hi8561_panel_t *hi8561 = (hi8561_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = hi8561->io;
uint8_t madctl_val = hi8561->madctl_val;
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_STATE, TAG, "invalid panel IO");
// Control mirror through LCD command
if (mirror_x)
{
madctl_val |= HI8561_CMD_SHLR_BIT;
}
else
{
madctl_val &= ~HI8561_CMD_SHLR_BIT;
}
if (mirror_y)
{
madctl_val |= HI8561_CMD_UPDN_BIT;
}
else
{
madctl_val &= ~HI8561_CMD_UPDN_BIT;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]){madctl_val}, 1), TAG, "send command failed");
hi8561->madctl_val = madctl_val;
return ESP_OK;
}
static esp_err_t panel_hi8561_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
{
hi8561_panel_t *hi8561 = (hi8561_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = hi8561->io;
uint8_t command = 0;
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_STATE, TAG, "invalid panel IO");
if (invert_color_data)
{
command = LCD_CMD_INVON;
}
else
{
command = LCD_CMD_INVOFF;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
#endif

66
main/boards/lilygo-t-display-p4/hi8561_driver.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* @Description: hi8561_driver
* @Author: LILYGO_L
* @Date: 2025-06-13 11:02:44
* @LastEditTime: 2025-10-09 10:36:27
* @License: GPL 3.0
*/
#pragma once
#include <stdint.h>
#include "soc/soc_caps.h"
#if SOC_MIPI_DSI_SUPPORTED
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_mipi_dsi.h"
/**
* @brief LCD panel initialization commands.
*
*/
typedef struct
{
int cmd; /*<! The specific LCD command */
const void *data; /*<! Buffer that holds the command specific data */
size_t data_bytes; /*<! Size of `data` in memory, in bytes */
unsigned int delay_ms; /*<! Delay in milliseconds after this command */
} hi8561_lcd_init_cmd_t;
/**
* @brief LCD panel vendor configuration.
*
* @note This structure needs to be passed to the `vendor_config` field in `esp_lcd_panel_dev_config_t`.
*
*/
typedef struct
{
const hi8561_lcd_init_cmd_t *init_cmds; /*!< Pointer to initialization commands array. Set to NULL if using default commands.
* The array should be declared as `static const` and positioned outside the function.
* Please refer to `vendor_specific_init_default` in source file.
*/
uint16_t init_cmds_size; /*<! Number of commands in above array */
struct
{
esp_lcd_dsi_bus_handle_t dsi_bus; /*!< MIPI-DSI bus configuration */
const esp_lcd_dpi_panel_config_t *dpi_config; /*!< MIPI-DPI panel configuration */
uint8_t lane_num; /*!< Number of MIPI-DSI lanes, defaults to 2 if set to 0 */
} mipi_config;
} hi8561_vendor_config_t;
/**
* @brief Create LCD panel for model HI8561
*
* @note Vendor specific initialization can be different between manufacturers, should consult the LCD supplier for initialization sequence code.
*
* @param[in] io LCD panel IO handle
* @param[in] panel_dev_config General panel device configuration
* @param[out] ret_panel Returned LCD panel handle
* @return
* - ESP_ERR_INVALID_ARG if parameter is invalid
* - ESP_OK on success
* - Otherwise on fail
*/
esp_err_t esp_lcd_new_panel_hi8561(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
esp_lcd_panel_handle_t *ret_panel);
#endif

397
main/boards/lilygo-t-display-p4/lilygo-t-display-p4.cc Normal file
View File

@@ -0,0 +1,397 @@
#include "wifi_board.h"
#include "codecs/es8311_audio_codec.h"
#include "application.h"
#include "display/lcd_display.h"
#include "button.h"
#include "config.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_mipi_dsi.h"
#include "esp_ldo_regulator.h"
#include <wifi_station.h>
#include <esp_log.h>
#include <driver/i2c_master.h>
#include <esp_lvgl_port.h>
#include "cpp_bus_driver_library.h"
#include "hi8561_driver.h"
#include "rm69a10_driver.h"
#define TAG "LilygoTDisplayP4Board"
void TouchTask(void *arg);
#if defined CONFIG_SCREEN_TYPE_HI8561
class CustomBacklight : public Backlight {
private:
std::unique_ptr<Cpp_Bus_Driver::Tool> tool_;
public:
CustomBacklight(std::unique_ptr<Cpp_Bus_Driver::Tool> tool) : tool_(std::move(tool)) {}
void SetBrightnessImpl(uint8_t brightness) override{
tool_->set_pwm_duty(brightness);
};
};
#elif defined CONFIG_SCREEN_TYPE_RM69A10
class CustomBacklight : public Backlight {
private:
esp_lcd_panel_handle_t mipi_dpi_panel_;
public:
CustomBacklight(esp_lcd_panel_handle_t panel) : mipi_dpi_panel_(panel) {}
void SetBrightnessImpl(uint8_t brightness) override{
set_rm69a10_brightness(mipi_dpi_panel_,static_cast<uint8_t>(static_cast<float>(brightness) * 2.55));
};
};
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
class LilygoTDisplayP4Board : public WifiBoard {
public:
i2c_master_bus_handle_t audio_codec_i2c_bus_;
Button boot_button_;
LcdDisplay *display_;
esp_lcd_panel_handle_t mipi_dpi_panel_;
esp_timer_handle_t touchpad_timer_;
uint8_t brightness_;
std::shared_ptr<Cpp_Bus_Driver::Hardware_Iic_1> xl9535_iic_bus_ = std::make_shared<Cpp_Bus_Driver::Hardware_Iic_1>(XL9535_SDA, XL9535_SCL, I2C_NUM_1);
std::unique_ptr<Cpp_Bus_Driver::Xl95x5> xl9535_ = std::make_unique<Cpp_Bus_Driver::Xl95x5>(xl9535_iic_bus_, XL9535_IIC_ADDRESS, DEFAULT_CPP_BUS_DRIVER_VALUE);
#if defined CONFIG_SCREEN_TYPE_HI8561
std::shared_ptr<Cpp_Bus_Driver::Hardware_Iic_1> hi8561_t_iic_bus_ = std::make_shared<Cpp_Bus_Driver::Hardware_Iic_1>(HI8561_TOUCH_SDA, HI8561_TOUCH_SCL, I2C_NUM_1);
std::unique_ptr<Cpp_Bus_Driver::Hi8561_Touch> hi8561_t_ = std::make_unique<Cpp_Bus_Driver::Hi8561_Touch>(hi8561_t_iic_bus_, HI8561_TOUCH_IIC_ADDRESS, DEFAULT_CPP_BUS_DRIVER_VALUE);
std::unique_ptr<Cpp_Bus_Driver::Tool> hi8561_backlight_ = std::make_unique<Cpp_Bus_Driver::Tool>();
#elif defined CONFIG_SCREEN_TYPE_RM69A10
std::shared_ptr<Cpp_Bus_Driver::Hardware_Iic_1> gt9895_iic_bus_ = std::make_shared<Cpp_Bus_Driver::Hardware_Iic_1>(GT9895_TOUCH_SDA, GT9895_TOUCH_SCL, I2C_NUM_1);
std::unique_ptr<Cpp_Bus_Driver::Gt9895> gt9895_ = std::make_unique<Cpp_Bus_Driver::Gt9895>(gt9895_iic_bus_, GT9895_IIC_ADDRESS, GT9895_X_SCALE_FACTOR, GT9895_Y_SCALE_FACTOR,
DEFAULT_CPP_BUS_DRIVER_VALUE);
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
std::unique_ptr<Cpp_Bus_Driver::Tool> esp32p4_ = std::make_unique<Cpp_Bus_Driver::Tool>();
bool Init_Ldo_Channel_Power(uint8_t chan_id, uint32_t voltage_mv){
esp_ldo_channel_handle_t ldo_channel_handle = NULL;
esp_ldo_channel_config_t ldo_channel_config ={
.chan_id = static_cast<int>(chan_id),
.voltage_mv = static_cast<int>(voltage_mv),
};
if (esp_ldo_acquire_channel(&ldo_channel_config, &ldo_channel_handle) != ESP_OK){
printf("esp_ldo_acquire_channel %d fail\n", chan_id);
return false;
}
return true;
}
void InitializeCodecI2c() {
// Initialize I2C peripheral
i2c_master_bus_config_t i2c_bus_cfg = {
.i2c_port = I2C_NUM_0,
.sda_io_num = AUDIO_CODEC_I2C_SDA_PIN,
.scl_io_num = AUDIO_CODEC_I2C_SCL_PIN,
.clk_source = I2C_CLK_SRC_DEFAULT,
.glitch_ignore_cnt = 7,
.intr_priority = 0,
.trans_queue_depth = 0,
.flags = {
.enable_internal_pullup = 1,
},
};
ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_cfg, &audio_codec_i2c_bus_));
}
void InitializeXl9535() {
xl9535_->begin(500000);
xl9535_->pin_mode(XL9535_ESP32P4_VCCA_POWER_EN, Cpp_Bus_Driver::Xl95x5::Mode::OUTPUT);
xl9535_->pin_mode(XL9535_5_0_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Mode::OUTPUT);
xl9535_->pin_mode(XL9535_3_3_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Mode::OUTPUT);
// 开关3.3v电压时候必须先将GPS断电
xl9535_->pin_mode(XL9535_GPS_WAKE_UP, Cpp_Bus_Driver::Xl95x5::Mode::OUTPUT);
xl9535_->pin_write(XL9535_GPS_WAKE_UP, Cpp_Bus_Driver::Xl95x5::Value::LOW);
// 开关3.3v电压时候必须先将ESP32C6断电
xl9535_->pin_mode(XL9535_ESP32C6_EN, Cpp_Bus_Driver::Xl95x5::Mode::OUTPUT);
xl9535_->pin_write(XL9535_ESP32C6_EN, Cpp_Bus_Driver::Xl95x5::Value::LOW);
xl9535_->pin_write(XL9535_ESP32P4_VCCA_POWER_EN, Cpp_Bus_Driver::Xl95x5::Value::LOW);
xl9535_->pin_write(XL9535_5_0_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_5_0_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Value::LOW);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_5_0_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_3_3_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Value::LOW);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_3_3_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_3_3_V_POWER_EN, Cpp_Bus_Driver::Xl95x5::Value::LOW);
vTaskDelay(pdMS_TO_TICKS(10));
// ESP32C6复位
xl9535_->pin_write(XL9535_ESP32C6_EN, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(100));
xl9535_->pin_write(XL9535_ESP32C6_EN, Cpp_Bus_Driver::Xl95x5::Value::LOW);
vTaskDelay(pdMS_TO_TICKS(100));
xl9535_->pin_write(XL9535_ESP32C6_EN, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(100));
vTaskDelay(pdMS_TO_TICKS(1000));
}
void InitializeLCD() {
xl9535_->pin_mode(XL9535_SCREEN_RST, Cpp_Bus_Driver::Xl95x5::Mode::OUTPUT);
xl9535_->pin_write(XL9535_SCREEN_RST, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_SCREEN_RST, Cpp_Bus_Driver::Xl95x5::Value::LOW);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_SCREEN_RST, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(10));
Init_Ldo_Channel_Power(3, 1800);
esp_lcd_panel_io_handle_t mipi_dbi_io = NULL;
esp_lcd_dsi_bus_handle_t mipi_dsi_bus = NULL;
esp_lcd_dsi_bus_config_t bus_config = {
.bus_id = 0,
.num_data_lanes = SCREEN_DATA_LANE_NUM,
.phy_clk_src = MIPI_DSI_PHY_CLK_SRC_DEFAULT,
.lane_bit_rate_mbps = SCREEN_LANE_BIT_RATE_MBPS,
};
esp_lcd_new_dsi_bus(&bus_config, &mipi_dsi_bus);
ESP_LOGI(TAG, "Install MIPI DSI LCD control panel");
// we use DBI interface to send LCD commands and parameters
esp_lcd_dbi_io_config_t dbi_io_config = {
.virtual_channel = 0,
.lcd_cmd_bits = 8, // according to the LCD spec
.lcd_param_bits = 8, // according to the LCD spec
};
esp_lcd_new_panel_io_dbi(mipi_dsi_bus, &dbi_io_config, &mipi_dbi_io);
esp_lcd_dpi_panel_config_t dpi_config = {
.virtual_channel = 0,
.dpi_clk_src = MIPI_DSI_DPI_CLK_SRC_DEFAULT,
.dpi_clock_freq_mhz = SCREEN_MIPI_DSI_DPI_CLK_MHZ,
.pixel_format = SCREEN_COLOR_RGB_PIXEL_FORMAT,
.num_fbs = 0,
.video_timing = {
.h_size = SCREEN_WIDTH,
.v_size = SCREEN_HEIGHT,
.hsync_pulse_width = SCREEN_MIPI_DSI_HSYNC,
.hsync_back_porch = SCREEN_MIPI_DSI_HBP,
.hsync_front_porch = SCREEN_MIPI_DSI_HFP,
.vsync_pulse_width = SCREEN_MIPI_DSI_VSYNC,
.vsync_back_porch = SCREEN_MIPI_DSI_VBP,
.vsync_front_porch = SCREEN_MIPI_DSI_VFP,
},
.flags = {
.use_dma2d = true, // use DMA2D to copy draw buffer into frame buffer
}
};
#if defined CONFIG_SCREEN_TYPE_HI8561
hi8561_vendor_config_t vendor_config = {
.mipi_config = {
.dsi_bus = mipi_dsi_bus,
.dpi_config = &dpi_config,
},
};
esp_lcd_panel_dev_config_t dev_config = {
.reset_gpio_num = -1,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = SCREEN_BITS_PER_PIXEL,
.vendor_config = &vendor_config,
};
esp_lcd_new_panel_hi8561(mipi_dbi_io, &dev_config, &mipi_dpi_panel_);
#elif defined CONFIG_SCREEN_TYPE_RM69A10
rm69a10_vendor_config_t vendor_config = {
.mipi_config = {
.dsi_bus = mipi_dsi_bus,
.dpi_config = &dpi_config,
},
};
esp_lcd_panel_dev_config_t dev_config = {
.reset_gpio_num = -1,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = SCREEN_BITS_PER_PIXEL,
.vendor_config = &vendor_config,
};
esp_lcd_new_panel_rm69a10(mipi_dbi_io, &dev_config, &mipi_dpi_panel_);
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
esp_lcd_panel_init(mipi_dpi_panel_);
#if defined CONFIG_SCREEN_TYPE_HI8561
hi8561_backlight_->create_pwm(HI8561_SCREEN_BL, ledc_channel_t::LEDC_CHANNEL_0, 2000);
#elif defined CONFIG_SCREEN_TYPE_RM69A10
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
display_ = new MipiLcdDisplay(mipi_dbi_io, mipi_dpi_panel_, SCREEN_WIDTH, SCREEN_HEIGHT,
SCREEN_OFFSET_X, SCREEN_OFFSET_Y, SCREEN_MIRROR_X, SCREEN_MIRROR_Y, SCREEN_SWAP_XY);
}
void InitializeTouch(){
xl9535_->pin_mode(XL9535_TOUCH_RST, Cpp_Bus_Driver::Xl95x5::Mode::OUTPUT);
xl9535_->pin_write(XL9535_TOUCH_RST, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_TOUCH_RST, Cpp_Bus_Driver::Xl95x5::Value::LOW);
vTaskDelay(pdMS_TO_TICKS(10));
xl9535_->pin_write(XL9535_TOUCH_RST, Cpp_Bus_Driver::Xl95x5::Value::HIGH);
vTaskDelay(pdMS_TO_TICKS(10));
#if defined CONFIG_SCREEN_TYPE_HI8561
hi8561_t_iic_bus_->set_bus_handle(xl9535_iic_bus_->get_bus_handle());
hi8561_t_->begin();
#elif defined CONFIG_SCREEN_TYPE_RM69A10
gt9895_iic_bus_->set_bus_handle(xl9535_iic_bus_->get_bus_handle());
gt9895_->begin();
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
xTaskCreate(TouchTask, "tp", 2 * 1024, this, 5, NULL);
}
void AppToggleChatState(void){
auto& app = Application::GetInstance();
if (app.GetDeviceState() == kDeviceStateStarting && !WifiStation::GetInstance().IsConnected()) {
ResetWifiConfiguration();
}
app.ToggleChatState();
}
void InitializeButtons() {
boot_button_.OnClick([this]() {
AppToggleChatState();
});
}
LilygoTDisplayP4Board() :
boot_button_(BOOT_BUTTON_GPIO) {
InitializeCodecI2c();
InitializeXl9535();
InitializeLCD();
InitializeTouch();
InitializeButtons();
GetBacklight()->SetBrightness(100);
}
virtual AudioCodec *GetAudioCodec() override {
static Es8311AudioCodec audio_codec(audio_codec_i2c_bus_, I2C_NUM_0, AUDIO_INPUT_SAMPLE_RATE, AUDIO_OUTPUT_SAMPLE_RATE,
AUDIO_I2S_GPIO_MCLK, AUDIO_I2S_GPIO_BCLK, AUDIO_I2S_GPIO_WS, AUDIO_I2S_GPIO_DOUT, AUDIO_I2S_GPIO_DIN,
AUDIO_CODEC_PA_PIN, AUDIO_CODEC_ES8311_ADDR);
return &audio_codec;
}
virtual Display *GetDisplay() override {
return display_;
}
#if defined CONFIG_SCREEN_TYPE_HI8561
virtual Backlight* GetBacklight() override {
static CustomBacklight backlight(std::move(hi8561_backlight_));
return &backlight;
}
#elif defined CONFIG_SCREEN_TYPE_RM69A10
virtual Backlight* GetBacklight() override {
static CustomBacklight backlight(std::move(mipi_dpi_panel_));
return &backlight;
}
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
};
void TouchTask(void *arg) {
LilygoTDisplayP4Board* board = (LilygoTDisplayP4Board*)arg;
static bool touch_flag = false;
static bool touch_lock_flag = true;
static size_t first_touch_time = 0;
static bool waiting_for_second_tap = false;
while (1){
#if defined CONFIG_SCREEN_TYPE_HI8561
if (board->hi8561_t_->get_finger_count() > 0){
if(touch_flag == false){
touch_lock_flag = false;
}
touch_flag = true;
} else {
touch_flag = false;
}
#elif defined CONFIG_SCREEN_TYPE_RM69A10
if (board->gt9895_->get_finger_count() > 0){
if(touch_flag == false){
touch_lock_flag = false;
}
touch_flag = true;
} else {
touch_flag = false;
}
#else
#error "unknown macro definition, please select the correct macro definition."
#endif
if(touch_lock_flag == false){
size_t current_time = board->esp32p4_->get_system_time_ms();
if (!waiting_for_second_tap) {
// 第一次点击
first_touch_time = current_time;
waiting_for_second_tap = true;
printf("first touch detected, waiting for second...\n");
} else {
// 第二次点击，检查时间间隔
// 500ms内完成双击
if ((current_time - first_touch_time) <= 500) {
printf("double touch trigger\n");
board->AppToggleChatState();
// 重置状态
waiting_for_second_tap = false;
first_touch_time = 0;
} else {
// 超时，重新开始
first_touch_time = current_time;
printf("first touch timeout, restart...\n");
}
}
touch_lock_flag = true;
}
// 处理双击超时
if (waiting_for_second_tap) {
size_t current_time = board->esp32p4_->get_system_time_ms();
if ((current_time - first_touch_time) > 500) {
waiting_for_second_tap = false;
first_touch_time = 0;
printf("double touch timeout\n");
}
}
vTaskDelay(pdMS_TO_TICKS(50));
}
}
DECLARE_BOARD(LilygoTDisplayP4Board);

377
main/boards/lilygo-t-display-p4/rm69a10_driver.cc Normal file
View File

@@ -0,0 +1,377 @@
/*
* SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "soc/soc_caps.h"
#if SOC_MIPI_DSI_SUPPORTED
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_check.h"
#include "esp_lcd_panel_commands.h"
#include "esp_lcd_panel_interface.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_mipi_dsi.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_log.h"
#include "rm69a10_driver.h"
#define RM69A10_PAD_CONTROL (0xB2)
#define RM69A10_DSI_2_LANE (0x10)
#define RM69A10_DSI_4_LANE (0x00)
#define RM69A10_CMD_SHLR_BIT (1ULL << 0)
#define RM69A10_CMD_UPDN_BIT (1ULL << 1)
#define RM69A10_MDCTL_VALUE_DEFAULT (0x01)
static const rm69a10_lcd_init_cmd_t vendor_specific_init_default[] = {
// {cmd, { data }, data_size, delay_ms}
/**** CMD_Page 3 ****/
{0xFE, (uint8_t[]){0xFD}, 1, 0},
{0x80, (uint8_t[]){0xFC}, 1, 0},
{0xFE, (uint8_t[]){0x00}, 1, 0},
{0x2A, (uint8_t[]){0x00, 0x00, 0x02, 0x37}, 4, 0},
{0x2B, (uint8_t[]){0x00, 0x00, 0x04, 0xCF}, 4, 0},
{0x31, (uint8_t[]){0x00, 0x03, 0x02, 0x34}, 4, 0},
{0x30, (uint8_t[]){0x00, 0x00, 0x04, 0xCF}, 4, 0},
{0x12, (uint8_t[]){0x00}, 1, 0},
{0x35, (uint8_t[]){0x00}, 1, 0},
#if CONFIG_SCREEN_PIXEL_FORMAT_RGB565
{0x3A, (uint8_t[]){0x75}, 1, 0}, // interface pixel format 16bit/pixel
#elif CONFIG_SCREEN_PIXEL_FORMAT_RGB888
{0x3A, (uint8_t[]){0x77}, 1, 0}, // interface pixel format 24bit/pixel
#endif
// {0x51, (uint8_t[]){0xFE}, 1, 0},
{0x51, (uint8_t[]){0x00}, 1, 0}, // 设置屏幕亮度为0
{0x11, (uint8_t[]){0x00}, 0, 120},
{0x29, (uint8_t[]){0x00}, 0, 0},
//============ Gamma END===========
};
typedef struct
{
esp_lcd_panel_io_handle_t io;
int reset_gpio_num;
uint8_t madctl_val; // save current value of LCD_CMD_MADCTL register
const rm69a10_lcd_init_cmd_t *init_cmds;
uint16_t init_cmds_size;
uint8_t lane_num;
struct
{
unsigned int reset_level : 1;
} flags;
// To save the original functions of MIPI DPI panel
esp_err_t (*del)(esp_lcd_panel_t *panel);
esp_err_t (*init)(esp_lcd_panel_t *panel);
} rm69a10_panel_t;
static const char *TAG = "rm69a10";
static esp_err_t panel_rm69a10_send_init_cmds(rm69a10_panel_t *rm69a10);
static esp_err_t panel_rm69a10_del(esp_lcd_panel_t *panel);
static esp_err_t panel_rm69a10_init(esp_lcd_panel_t *panel);
static esp_err_t panel_rm69a10_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_rm69a10_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_rm69a10_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_rm69a10_sleep(esp_lcd_panel_t *panel, bool sleep);
static esp_err_t panel_rm69a10_on_off(esp_lcd_panel_t *panel, bool on_off);
esp_err_t esp_lcd_new_panel_rm69a10(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
esp_lcd_panel_handle_t *ret_panel)
{
// ESP_LOGI(TAG, "version: %d.%d.%d", ESP_LCD_RM69A10_VER_MAJOR, ESP_LCD_RM69A10_VER_MINOR,
// ESP_LCD_RM69A10_VER_PATCH);
ESP_RETURN_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, TAG, "invalid arguments");
rm69a10_vendor_config_t *vendor_config = (rm69a10_vendor_config_t *)panel_dev_config->vendor_config;
ESP_RETURN_ON_FALSE(vendor_config && vendor_config->mipi_config.dpi_config && vendor_config->mipi_config.dsi_bus, ESP_ERR_INVALID_ARG, TAG,
"invalid vendor config");
esp_err_t ret = ESP_OK;
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)calloc(1, sizeof(rm69a10_panel_t));
ESP_RETURN_ON_FALSE(rm69a10, ESP_ERR_NO_MEM, TAG, "no mem for rm69a10 panel");
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_config_t io_conf = {
.pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num,
.mode = GPIO_MODE_OUTPUT,
};
ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed");
}
rm69a10->io = io;
rm69a10->init_cmds = vendor_config->init_cmds;
rm69a10->init_cmds_size = vendor_config->init_cmds_size;
rm69a10->lane_num = vendor_config->mipi_config.lane_num;
rm69a10->reset_gpio_num = panel_dev_config->reset_gpio_num;
rm69a10->flags.reset_level = panel_dev_config->flags.reset_active_high;
rm69a10->madctl_val = RM69A10_MDCTL_VALUE_DEFAULT;
// Create MIPI DPI panel
ESP_GOTO_ON_ERROR(esp_lcd_new_panel_dpi(vendor_config->mipi_config.dsi_bus, vendor_config->mipi_config.dpi_config, ret_panel), err, TAG,
"create MIPI DPI panel failed");
ESP_LOGD(TAG, "new MIPI DPI panel @%p", *ret_panel);
// Save the original functions of MIPI DPI panel
rm69a10->del = (*ret_panel)->del;
rm69a10->init = (*ret_panel)->init;
// Overwrite the functions of MIPI DPI panel
(*ret_panel)->del = panel_rm69a10_del;
(*ret_panel)->init = panel_rm69a10_init;
(*ret_panel)->reset = panel_rm69a10_reset;
(*ret_panel)->mirror = panel_rm69a10_mirror;
(*ret_panel)->invert_color = panel_rm69a10_invert_color;
(*ret_panel)->disp_sleep = panel_rm69a10_sleep;
(*ret_panel)->disp_on_off = panel_rm69a10_on_off;
(*ret_panel)->user_data = rm69a10;
ESP_LOGD(TAG, "new rm69a10 panel @%p", rm69a10);
return ESP_OK;
err:
if (rm69a10)
{
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_reset_pin(static_cast<gpio_num_t>(panel_dev_config->reset_gpio_num));
}
free(rm69a10);
}
return ret;
}
static esp_err_t panel_rm69a10_send_init_cmds(rm69a10_panel_t *rm69a10)
{
esp_lcd_panel_io_handle_t io = rm69a10->io;
const rm69a10_lcd_init_cmd_t *init_cmds = NULL;
uint16_t init_cmds_size = 0;
// uint8_t lane_command = RM69A10_DSI_2_LANE;
// bool is_cmd_overwritten = false;
// switch (rm69a10->lane_num)
// {
// case 0:
// case 2:
// lane_command = RM69A10_DSI_2_LANE;
// break;
// case 4:
// lane_command = RM69A10_DSI_4_LANE;
// break;
// default:
// ESP_LOGE(TAG, "Invalid lane number %d", rm69a10->lane_num);
// return ESP_ERR_INVALID_ARG;
// }
// ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, RM69A10_PAD_CONTROL, (uint8_t[]){
// lane_command,
// },
// 1),
// TAG, "send command failed");
// vendor specific initialization, it can be different between manufacturers
// should consult the LCD supplier for initialization sequence code
// if (rm69a10->init_cmds)
// {
// init_cmds = rm69a10->init_cmds;
// init_cmds_size = rm69a10->init_cmds_size;
// }
// else
// {
// init_cmds = vendor_specific_init_default;
// init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(rm69a10_lcd_init_cmd_t);
// }
init_cmds = vendor_specific_init_default;
init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(rm69a10_lcd_init_cmd_t);
for (int i = 0; i < init_cmds_size; i++)
{
// // Check if the command has been used or conflicts with the internal
// if (init_cmds[i].data_bytes > 0)
// {
// switch (init_cmds[i].cmd)
// {
// case LCD_CMD_MADCTL:
// is_cmd_overwritten = true;
// rm69a10->madctl_val = ((uint8_t *)init_cmds[i].data)[0];
// break;
// default:
// is_cmd_overwritten = false;
// break;
// }
// if (is_cmd_overwritten)
// {
// is_cmd_overwritten = false;
// ESP_LOGW(TAG, "The %02Xh command has been used and will be overwritten by external initialization sequence",
// init_cmds[i].cmd);
// }
// }
// Send command
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, init_cmds[i].cmd, init_cmds[i].data, init_cmds[i].data_bytes), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(init_cmds[i].delay_ms));
// printf("Ciallo\n");
}
ESP_LOGD(TAG, "send init commands success");
return ESP_OK;
}
static esp_err_t panel_rm69a10_del(esp_lcd_panel_t *panel)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
if (rm69a10->reset_gpio_num >= 0)
{
gpio_reset_pin(static_cast<gpio_num_t>(rm69a10->reset_gpio_num));
}
// Delete MIPI DPI panel
rm69a10->del(panel);
ESP_LOGD(TAG, "del rm69a10 panel @%p", rm69a10);
free(rm69a10);
return ESP_OK;
}
static esp_err_t panel_rm69a10_init(esp_lcd_panel_t *panel)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
ESP_RETURN_ON_ERROR(panel_rm69a10_send_init_cmds(rm69a10), TAG, "send init commands failed");
ESP_RETURN_ON_ERROR(rm69a10->init(panel), TAG, "init MIPI DPI panel failed");
return ESP_OK;
}
static esp_err_t panel_rm69a10_reset(esp_lcd_panel_t *panel)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = rm69a10->io;
// Perform hardware reset
if (rm69a10->reset_gpio_num >= 0)
{
gpio_set_level(static_cast<gpio_num_t>(rm69a10->reset_gpio_num), rm69a10->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
gpio_set_level(static_cast<gpio_num_t>(rm69a10->reset_gpio_num), !rm69a10->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(20));
}
else if (io)
{ // Perform software reset
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(20));
}
return ESP_OK;
}
static esp_err_t panel_rm69a10_sleep(esp_lcd_panel_t *panel, bool sleep)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = rm69a10->io;
if (sleep == true)
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x10, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_rm69a10 sleep on");
}
else
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x11, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_rm69a10 sleep off");
}
vTaskDelay(pdMS_TO_TICKS(120));
return ESP_OK;
}
static esp_err_t panel_rm69a10_on_off(esp_lcd_panel_t *panel, bool on_off)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = rm69a10->io;
if (on_off == true)
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x29, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_rm69a10 display on");
}
else
{
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x28, 0x00, 0), TAG, "esp_lcd_panel_io_tx_param fail");
ESP_LOGI(TAG, "panel_rm69a10 display off");
}
vTaskDelay(pdMS_TO_TICKS(120));
return ESP_OK;
}
static esp_err_t panel_rm69a10_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = rm69a10->io;
uint8_t madctl_val = rm69a10->madctl_val;
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_STATE, TAG, "invalid panel IO");
// Control mirror through LCD command
if (mirror_x)
{
madctl_val |= RM69A10_CMD_SHLR_BIT;
}
else
{
madctl_val &= ~RM69A10_CMD_SHLR_BIT;
}
if (mirror_y)
{
madctl_val |= RM69A10_CMD_UPDN_BIT;
}
else
{
madctl_val &= ~RM69A10_CMD_UPDN_BIT;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]){madctl_val}, 1), TAG, "send command failed");
rm69a10->madctl_val = madctl_val;
return ESP_OK;
}
static esp_err_t panel_rm69a10_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = rm69a10->io;
uint8_t command = 0;
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_STATE, TAG, "invalid panel IO");
if (invert_color_data)
{
command = LCD_CMD_INVON;
}
else
{
command = LCD_CMD_INVOFF;
}
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
esp_err_t set_rm69a10_brightness(esp_lcd_panel_t *panel, uint8_t brightness)
{
rm69a10_panel_t *rm69a10 = (rm69a10_panel_t *)panel->user_data;
esp_lcd_panel_io_handle_t io = rm69a10->io;
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, 0x51, &brightness, 1), TAG, "esp_lcd_panel_io_tx_param fail");
return ESP_OK;
}
#endif

68
main/boards/lilygo-t-display-p4/rm69a10_driver.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* @Description: rm69a10_driver
* @Author: LILYGO_L
* @Date: 2025-07-07 14:23:16
* @LastEditTime: 2025-10-09 10:36:33
* @License: GPL 3.0
*/
#pragma once
#include <stdint.h>
#include "soc/soc_caps.h"
#if SOC_MIPI_DSI_SUPPORTED
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_mipi_dsi.h"
/**
* @brief LCD panel initialization commands.
*
*/
typedef struct
{
int cmd; /*<! The specific LCD command */
const void *data; /*<! Buffer that holds the command specific data */
size_t data_bytes; /*<! Size of `data` in memory, in bytes */
unsigned int delay_ms; /*<! Delay in milliseconds after this command */
} rm69a10_lcd_init_cmd_t;
/**
* @brief LCD panel vendor configuration.
*
* @note This structure needs to be passed to the `vendor_config` field in `esp_lcd_panel_dev_config_t`.
*
*/
typedef struct
{
const rm69a10_lcd_init_cmd_t *init_cmds; /*!< Pointer to initialization commands array. Set to NULL if using default commands.
* The array should be declared as `static const` and positioned outside the function.
* Please refer to `vendor_specific_init_default` in source file.
*/
uint16_t init_cmds_size; /*<! Number of commands in above array */
struct
{
esp_lcd_dsi_bus_handle_t dsi_bus; /*!< MIPI-DSI bus configuration */
const esp_lcd_dpi_panel_config_t *dpi_config; /*!< MIPI-DPI panel configuration */
uint8_t lane_num; /*!< Number of MIPI-DSI lanes, defaults to 2 if set to 0 */
} mipi_config;
} rm69a10_vendor_config_t;
/**
* @brief Create LCD panel for model RM69A10
*
* @note Vendor specific initialization can be different between manufacturers, should consult the LCD supplier for initialization sequence code.
*
* @param[in] io LCD panel IO handle
* @param[in] panel_dev_config General panel device configuration
* @param[out] ret_panel Returned LCD panel handle
* @return
* - ESP_ERR_INVALID_ARG if parameter is invalid
* - ESP_OK on success
* - Otherwise on fail
*/
esp_err_t esp_lcd_new_panel_rm69a10(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
esp_lcd_panel_handle_t *ret_panel);
esp_err_t set_rm69a10_brightness(esp_lcd_panel_t *panel, uint8_t brightness);
#endif

233
main/boards/lilygo-t-display-p4/t_display_p4_config.h Normal file
View File

@@ -0,0 +1,233 @@
/*
* @Description: t_display_p4_config
* @Author: LILYGO_L
* @Date: 2024-12-06 10:32:28
* @LastEditTime: 2025-09-10 11:56:28
*/
#pragma once
////////////////////////////////////////////////// gpio config //////////////////////////////////////////////////
// IIC
#define IIC_1_SDA 7
#define IIC_1_SCL 8
#define IIC_2_SDA 20
#define IIC_2_SCL 21
// BOOT
#define ESP32P4_BOOT 35
// XL9535
#define XL9535_SDA IIC_1_SDA
#define XL9535_SCL IIC_1_SCL
#define XL9535_INT 5
// XL9535引脚功能
#define XL9535_3_3_V_POWER_EN Cpp_Bus_Driver::Xl95x5::Pin::IO0
#define XL9535_SKY13453_VCTL Cpp_Bus_Driver::Xl95x5::Pin::IO1
#define XL9535_SCREEN_RST Cpp_Bus_Driver::Xl95x5::Pin::IO2
#define XL9535_TOUCH_RST Cpp_Bus_Driver::Xl95x5::Pin::IO3
#define XL9535_TOUCH_INT Cpp_Bus_Driver::Xl95x5::Pin::IO4
#define XL9535_ETHERNET_RST Cpp_Bus_Driver::Xl95x5::Pin::IO5
#define XL9535_5_0_V_POWER_EN Cpp_Bus_Driver::Xl95x5::Pin::IO6
#define XL9535_EXTERNAL_SENSOR_INT Cpp_Bus_Driver::Xl95x5::Pin::IO7
#define XL9535_ESP32P4_VCCA_POWER_EN Cpp_Bus_Driver::Xl95x5::Pin::IO10
#define XL9535_GPS_WAKE_UP Cpp_Bus_Driver::Xl95x5::Pin::IO11
#define XL9535_RTC_INT Cpp_Bus_Driver::Xl95x5::Pin::IO12
#define XL9535_ESP32C6_WAKE_UP Cpp_Bus_Driver::Xl95x5::Pin::IO13
#define XL9535_ESP32C6_EN Cpp_Bus_Driver::Xl95x5::Pin::IO14
#define XL9535_SD_EN Cpp_Bus_Driver::Xl95x5::Pin::IO15
#define XL9535_SX1262_RST Cpp_Bus_Driver::Xl95x5::Pin::IO16
#define XL9535_SX1262_DIO1 Cpp_Bus_Driver::Xl95x5::Pin::IO17
// ES8311
#define ES8311_SDA IIC_2_SDA
#define ES8311_SCL IIC_2_SCL
#define ES8311_ADC_DATA 11
#define ES8311_DAC_DATA 10
#define ES8311_BCLK 12
#define ES8311_MCLK 13
#define ES8311_WS_LRCK 9
// AW86224
#define AW86224_SDA IIC_2_SDA
#define AW86224_SCL IIC_2_SCL
// SGM38121
#define SGM38121_SDA IIC_2_SDA
#define SGM38121_SCL IIC_2_SCL
// PCF8563
#define PCF8563_SDA IIC_1_SDA
#define PCF8563_SCL IIC_1_SCL
// BQ27220
#define BQ27220_SDA IIC_1_SDA
#define BQ27220_SCL IIC_1_SCL
// SPI
#define SPI_1_SCLK 2
#define SPI_1_MOSI 3
#define SPI_1_MISO 4
// SX1262
#define SX1262_CS 24
#define SX1262_BUSY 6
#define SX1262_SCLK SPI_1_SCLK
#define SX1262_MOSI SPI_1_MOSI
#define SX1262_MISO SPI_1_MISO
// L76K
#define GPS_TX 22
#define GPS_RX 23
// ICM20948
#define ICM20948_SDA IIC_2_SDA
#define ICM20948_SCL IIC_2_SCL
// HI8561
#define HI8561_SCREEN_BL 51
#define HI8561_TOUCH_SDA IIC_1_SDA
#define HI8561_TOUCH_SCL IIC_1_SCL
// GT9895
#define GT9895_TOUCH_SDA IIC_1_SDA
#define GT9895_TOUCH_SCL IIC_1_SCL
// Camera
#define CAMERA_SDA IIC_2_SDA
#define CAMERA_SCL IIC_2_SCL
// SDIO
#define SDIO_1_CLK 43
#define SDIO_1_CMD 44
#define SDIO_1_D0 39
#define SDIO_1_D1 40
#define SDIO_1_D2 41
#define SDIO_1_D3 42
#define SDIO_2_CLK 18
#define SDIO_2_CMD 19
#define SDIO_2_D0 14
#define SDIO_2_D1 15
#define SDIO_2_D2 16
#define SDIO_2_D3 17
// SD
// SDMMC
#define SD_SDIO_CLK SDIO_1_CLK
#define SD_SDIO_CMD SDIO_1_CMD
#define SD_SDIO_D0 SDIO_1_D0
#define SD_SDIO_D1 SDIO_1_D1
#define SD_SDIO_D2 SDIO_1_D2
#define SD_SDIO_D3 SDIO_1_D3
// SDSPI
#define SD_SCLK SDIO_1_CLK
#define SD_MOSI SDIO_1_CMD
#define SD_MISO SDIO_1_D0
#define SD_CS SDIO_1_D3
// ESP32C6 SDIO
#define ESP32C6_SDIO_CLK SDIO_2_CLK
#define ESP32C6_SDIO_CMD SDIO_2_CMD
#define ESP32C6_SDIO_D0 SDIO_2_D0
#define ESP32C6_SDIO_D1 SDIO_2_D1
#define ESP32C6_SDIO_D2 SDIO_2_D2
#define ESP32C6_SDIO_D3 SDIO_2_D3
// Extended io
#define EXT_2X8P_SPI_SCLK SPI_1_SCLK
#define EXT_2X8P_SPI_MOSI SPI_1_MOSI
#define EXT_2X8P_SPI_MISO SPI_1_MISO
#define EXT_2X8P_IO_26 26
#define EXT_2X8P_IO_27 27
#define EXT_2X8P_IO_33 33
#define EXT_2X8P_IO_32 32
#define EXT_2X8P_IO_25 25
#define EXT_2X8P_IO_36 36
#define EXT_2X8P_IO_53 53
#define EXT_2X8P_IO_54 54
#define EXT_1X4P_1_IO_47 47
#define EXT_1X4P_1_IO_48 48
#define EXT_1X4P_2_IO_45 45
#define EXT_1X4P_2_IO_46 46
////////////////////////////////////////////////// gpio config //////////////////////////////////////////////////
////////////////////////////////////////////////// other define config //////////////////////////////////////////////////
// XL9535
#define XL9535_IIC_ADDRESS 0x20
// ES8311
#define ES8311_IIC_ADDRESS 0x18
// AW86224
#define AW86224_IIC_ADDRESS 0x58
// SGM38121
#define SGM38121_IIC_ADDRESS 0x28
// PCF8563
#define PCF8563_IIC_ADDRESS 0x51
// BQ27220
#define BQ27220_IIC_ADDRESS 0x55
// ICM20948
#define ICM20948_IIC_ADDRESS 0x68
// HI8561
#define HI8561_SCREEN_WIDTH 540
#define HI8561_SCREEN_HEIGHT 1168
#define HI8561_SCREEN_MIPI_DSI_DPI_CLK_MHZ 60
// #define HI8561_SCREEN_MIPI_DSI_DPI_CLK_MHZ 45
#define HI8561_SCREEN_MIPI_DSI_HSYNC 28
#define HI8561_SCREEN_MIPI_DSI_HBP 26
#define HI8561_SCREEN_MIPI_DSI_HFP 20
#define HI8561_SCREEN_MIPI_DSI_VSYNC 2
#define HI8561_SCREEN_MIPI_DSI_VBP 22
#define HI8561_SCREEN_MIPI_DSI_VFP 200
#define HI8561_SCREEN_DATA_LANE_NUM 2
#define HI8561_SCREEN_LANE_BIT_RATE_MBPS 1000
#define HI8561_TOUCH_IIC_ADDRESS 0x68
// RM69A10
#define RM69A10_SCREEN_WIDTH 568
#define RM69A10_SCREEN_HEIGHT 1232
// #define RM69A10_SCREEN_MIPI_DSI_DPI_CLK_MHZ 80
#define RM69A10_SCREEN_MIPI_DSI_DPI_CLK_MHZ 60
#define RM69A10_SCREEN_MIPI_DSI_HSYNC 50
#define RM69A10_SCREEN_MIPI_DSI_HBP 150
#define RM69A10_SCREEN_MIPI_DSI_HFP 50
#define RM69A10_SCREEN_MIPI_DSI_VSYNC 40
#define RM69A10_SCREEN_MIPI_DSI_VBP 120
#define RM69A10_SCREEN_MIPI_DSI_VFP 80
#define RM69A10_SCREEN_DATA_LANE_NUM 2
#define RM69A10_SCREEN_LANE_BIT_RATE_MBPS 1000
// GT9895
#define GT9895_IIC_ADDRESS 0x5D
#define GT9895_MAX_X_SIZE 1060
#define GT9895_MAX_Y_SIZE 2400
#define GT9895_X_SCALE_FACTOR static_cast<float>(RM69A10_SCREEN_WIDTH) / static_cast<float>(GT9895_MAX_X_SIZE)
#define GT9895_Y_SCALE_FACTOR static_cast<float>(RM69A10_SCREEN_HEIGHT) / static_cast<float>(GT9895_MAX_Y_SIZE)
// CAMERA
#define CAMERA_WIDTH 1920
#define CAMERA_HEIGHT 1080
// #define CAMERA_WIDTH 1280
// #define CAMERA_HEIGHT 720
// #define CAMERA_WIDTH 800
// #define CAMERA_HEIGHT 800
// #define CAMERA_WIDTH 640
// #define CAMERA_HEIGHT 480
#define CAMERA_DATA_LANE_NUM 2
#define CAMERA_LANE_BIT_RATE_MBPS 1000
#define CAMERA_MIPI_DSI_DPI_CLK_MHZ 60
// SD
#define SD_BASE_PATH "/sdcard"
////////////////////////////////////////////////// other define config //////////////////////////////////////////////////

5
main/idf_component.yml
View File

@@ -82,6 +82,11 @@ dependencies:
rules:
- if: target in [esp32c3]
llgok/cpp_bus_driver:
version: 1.1.0
rules:
- if: target in [esp32p4]
## Required IDF version
idf:
version: '>=5.4.0'