1. 测试了屏幕驱动，lvgl,触摸，驱动文件在Lib/Display当中。全部通过(修改了sdkconfig,以适配lvgl)

2. 新增了优雅的C语言错误处理

Lib/Display/Touch_Driver/CST816.c

@@ -0,0 +1,243 @@
+#include "CST816.h"
+
+
+#define POINT_NUM_MAX       (1)
+
+#define DATA_START_REG      (0x02)
+#define CHIP_ID_REG         (0xA7)
+#define AutoSleep_REG       (0xFE)
+
+static const char *TAG = "CST816";
+
+esp_lcd_touch_handle_t tp = NULL;
+
+static esp_err_t read_data(esp_lcd_touch_handle_t tp);
+static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
+static esp_err_t del(esp_lcd_touch_handle_t tp);
+
+static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len);
+static esp_err_t i2c_write_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t* data, uint8_t len);
+
+static esp_err_t reset(esp_lcd_touch_handle_t tp);
+static esp_err_t read_id(esp_lcd_touch_handle_t tp);
+static void AutoSleep(bool Sleep_State);
+
+esp_err_t esp_lcd_touch_new_i2c_cst816(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp)
+{
+    ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_ARG, TAG, "Invalid io");
+    ESP_RETURN_ON_FALSE(config, ESP_ERR_INVALID_ARG, TAG, "Invalid config");
+    ESP_RETURN_ON_FALSE(tp, ESP_ERR_INVALID_ARG, TAG, "Invalid touch handle");
+
+    /* Prepare main structure */
+    esp_err_t ret = ESP_OK;
+    esp_lcd_touch_handle_t cst816s = calloc(1, sizeof(esp_lcd_touch_t));
+    ESP_GOTO_ON_FALSE(cst816s, ESP_ERR_NO_MEM, err, TAG, "Touch handle malloc failed");
+
+    /* Communication interface */
+    cst816s->io = io;
+    /* Only supported callbacks are set */
+    cst816s->read_data = read_data;
+    cst816s->get_xy = get_xy;
+    cst816s->del = del;
+    /* Mutex */
+    cst816s->data.lock.owner = portMUX_FREE_VAL;
+    /* Save config */
+    memcpy(&cst816s->config, config, sizeof(esp_lcd_touch_config_t));
+
+    /* Prepare pin for touch interrupt */
+    if (cst816s->config.int_gpio_num != GPIO_NUM_NC) {
+        const gpio_config_t int_gpio_config = {
+            .mode = GPIO_MODE_INPUT,
+            .intr_type = (cst816s->config.levels.interrupt ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE),
+            .pin_bit_mask = BIT64(cst816s->config.int_gpio_num)
+        };
+        ESP_GOTO_ON_ERROR(gpio_config(&int_gpio_config), err, TAG, "GPIO intr config failed");
+
+        /* Register interrupt callback */
+        if (cst816s->config.interrupt_callback) {
+            esp_lcd_touch_register_interrupt_callback(cst816s, cst816s->config.interrupt_callback);
+        }
+    }
+    /* Prepare pin for touch controller reset */
+    if (cst816s->config.rst_gpio_num != GPIO_NUM_NC) {
+        const gpio_config_t rst_gpio_config = {
+            .mode = GPIO_MODE_OUTPUT,
+            .pin_bit_mask = BIT64(cst816s->config.rst_gpio_num)
+        };
+        ESP_GOTO_ON_ERROR(gpio_config(&rst_gpio_config), err, TAG, "GPIO reset config failed");
+    }
+    /* Reset controller */
+    ESP_GOTO_ON_ERROR(reset(cst816s), err, TAG, "Reset failed");
+
+    /* Read product id */
+    ESP_GOTO_ON_ERROR(read_id(cst816s), err, TAG, "Read version failed");
+    *tp = cst816s;
+    AutoSleep(false);
+    return ESP_OK;
+err:
+    if (cst816s) {
+        del(cst816s);
+    }
+    ESP_LOGE(TAG, "Initialization failed!");
+    return ret;
+}
+
+static esp_err_t read_data(esp_lcd_touch_handle_t tp)
+{
+    typedef struct {
+        uint8_t num;
+        uint8_t x_h : 4;
+        uint8_t : 4;
+        uint8_t x_l;
+        uint8_t y_h : 4;
+        uint8_t : 4;
+        uint8_t y_l;
+    } data_t;
+
+    data_t point;
+    ESP_RETURN_ON_ERROR(i2c_read_bytes(tp, DATA_START_REG, (uint8_t *)&point, sizeof(data_t)), TAG, "I2C read failed");
+
+    portENTER_CRITICAL(&tp->data.lock);
+    point.num = (point.num > POINT_NUM_MAX ? POINT_NUM_MAX : point.num);
+    tp->data.points = point.num;
+    /* Fill all coordinates */
+    for (int i = 0; i < point.num; i++) {
+        tp->data.coords[i].x = point.x_h << 8 | point.x_l;
+        tp->data.coords[i].y = point.y_h << 8 | point.y_l;
+    }
+    portEXIT_CRITICAL(&tp->data.lock);
+
+    return ESP_OK;
+}
+
+static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num)
+{
+    portENTER_CRITICAL(&tp->data.lock);
+    /* Count of points */
+    *point_num = (tp->data.points > max_point_num ? max_point_num : tp->data.points);
+    for (size_t i = 0; i < *point_num; i++) {
+        x[i] = tp->data.coords[i].x;
+        y[i] = tp->data.coords[i].y;
+
+        if (strength) {
+            strength[i] = tp->data.coords[i].strength;
+        }
+    }
+    /* Invalidate */
+    tp->data.points = 0;
+    portEXIT_CRITICAL(&tp->data.lock);
+
+    return (*point_num > 0);
+}
+
+static esp_err_t del(esp_lcd_touch_handle_t tp)
+{
+    /* Reset GPIO pin settings */
+    if (tp->config.int_gpio_num != GPIO_NUM_NC) {
+        gpio_reset_pin(tp->config.int_gpio_num);
+        if (tp->config.interrupt_callback) {
+            gpio_isr_handler_remove(tp->config.int_gpio_num);
+        }
+    }
+    if (tp->config.rst_gpio_num != GPIO_NUM_NC) {
+        gpio_reset_pin(tp->config.rst_gpio_num);
+    }
+    /* Release memory */
+    free(tp);
+
+    return ESP_OK;
+}
+
+static esp_err_t reset(esp_lcd_touch_handle_t tp)
+{
+
+    Set_EXIO(TCA9554_EXIO1,false);
+    vTaskDelay(pdMS_TO_TICKS(10));
+    Set_EXIO(TCA9554_EXIO1,true);
+    vTaskDelay(pdMS_TO_TICKS(50));
+
+    return ESP_OK;
+}
+
+static esp_err_t read_id(esp_lcd_touch_handle_t tp)
+{
+    uint8_t id;
+    ESP_RETURN_ON_ERROR(i2c_read_bytes(tp, CHIP_ID_REG, &id, 1), TAG, "I2C read failed");
+    ESP_LOGI(TAG, "IC id: %d", id);
+    return ESP_OK;
+}
+/*!
+    @brief  Fall asleep automatically
+*/
+static void AutoSleep(bool Sleep_State) {
+    uint8_t Sleep_State_Set = (uint8_t)(!Sleep_State);
+    i2c_write_bytes(tp, AutoSleep_REG, &Sleep_State_Set, 1);
+}
+
+static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len)
+{
+    ESP_RETURN_ON_FALSE(data, ESP_ERR_INVALID_ARG, TAG, "Invalid data");
+
+    return esp_lcd_panel_io_rx_param(tp->io, reg, data, len);
+}
+
+static esp_err_t i2c_write_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t* data, uint8_t len)
+{
+    assert(tp != NULL);
+
+    // *INDENT-OFF*
+    /* Write data */
+    return esp_lcd_panel_io_tx_param(tp->io, reg, data, len);
+    // *INDENT-ON*
+}
+
+/**
+ * @brief i2c master initialization
+ */
+esp_err_t Touch_I2C_Init(void)
+{
+    int i2c_master_port = I2C_Touch_MASTER_NUM;
+
+    i2c_config_t conf = {
+        .mode = I2C_MODE_MASTER,
+        .sda_io_num = I2C_Touch_SDA_IO,
+        .scl_io_num = I2C_Touch_SCL_IO,
+        .sda_pullup_en = GPIO_PULLUP_ENABLE,
+        .scl_pullup_en = GPIO_PULLUP_ENABLE,
+        .master.clk_speed = I2C_Touch_MASTER_FREQ_HZ,
+    };
+
+    i2c_param_config(i2c_master_port, &conf);
+
+    return i2c_driver_install(i2c_master_port, conf.mode, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0);
+}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void Touch_Init(void)
+{
+    
+    ESP_ERROR_CHECK(Touch_I2C_Init());
+    ESP_LOGI(TAG, "I2C initialized successfully");
+/********************* Touch *********************/
+
+    esp_lcd_panel_io_handle_t tp_io_handle = NULL;
+    esp_lcd_panel_io_i2c_config_t tp_io_config = ESP_LCD_TOUCH_IO_I2C_CST816_CONFIG();
+    ESP_LOGI(TAG, "Initialize touch IO (I2C)");
+    /* Touch IO handle */
+    ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)I2C_Touch_MASTER_NUM, &tp_io_config, &tp_io_handle));
+    esp_lcd_touch_config_t tp_cfg = {
+        .x_max = EXAMPLE_LCD_WIDTH,
+        .y_max = EXAMPLE_LCD_HEIGHT,
+        .rst_gpio_num = I2C_Touch_RST_IO,
+        .int_gpio_num = I2C_Touch_INT_IO,
+        .flags = {
+            .swap_xy = 0,
+            .mirror_x = 0,
+            .mirror_y = 0,
+        },
+    };
+    /* Initialize touch */
+    ESP_LOGI(TAG, "Initialize touch controller CST816");
+    ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_cst816(tp_io_handle, &tp_cfg, &tp));
+}
+

Lib/Display/Touch_Driver/CST816.h

@@ -0,0 +1,70 @@
+/**
+ * @file
+ * @brief ESP LCD touch: CST820
+ */
+
+#pragma once
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "driver/gpio.h"
+#include "driver/i2c.h"
+#include "esp_system.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_check.h"
+#include "esp_lcd_panel_io.h"
+#include "esp_lcd_touch.h"
+
+#include "TCA9554PWR.h"
+#include "ST77916.h"
+
+/**
+ * @brief Create a new CST816S touch driver
+ *
+ * @note  The I2C communication should be initialized before use this function.
+ *
+ * @param io LCD panel IO handle, it should be created by `esp_lcd_new_panel_io_i2c()`
+ * @param config Touch panel configuration
+ * @param tp Touch panel handle
+ * @return
+ *      - ESP_OK: on success
+ */
+esp_err_t esp_lcd_touch_new_i2c_cst816s(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp);
+
+/**
+ * @brief I2C address of the CST816S controller
+ *
+ */
+#define ESP_LCD_TOUCH_IO_I2C_CST816S_ADDRESS    (0x15)
+
+/**
+ * @brief Touch IO configuration structure
+ *
+ */
+#define ESP_LCD_TOUCH_IO_I2C_CST816_CONFIG()             \
+    {                                                    \
+        .dev_addr = ESP_LCD_TOUCH_IO_I2C_CST816S_ADDRESS, \
+        .control_phase_bytes = 1,                        \
+        .dc_bit_offset = 0,                              \
+        .lcd_cmd_bits = 8,                              \
+        .flags =                                         \
+        {                                                \
+            .disable_control_phase = 1,                  \
+        }                                                \
+    }
+    
+
+// I2C settings
+#define I2C_Touch_SDA_IO            1               /*!< GPIO number used for I2C master data  */
+#define I2C_Touch_SCL_IO            3               /*!< GPIO number used for I2C master clock */
+#define I2C_Touch_INT_IO            4               /*!< GPIO number used for I2C master data  */
+#define I2C_Touch_RST_IO            -1              /*!< GPIO number used for I2C master clock */
+#define I2C_Touch_MASTER_NUM        1               /*!< I2C master i2c port number, the number of i2c peripheral interfaces available will depend on the chip */
+#define I2C_Touch_MASTER_FREQ_HZ    400000          /*!< I2C master clock frequency */
+
+extern esp_lcd_touch_handle_t tp;
+
+void Touch_Init(void);

Lib/Display/Touch_Driver/esp_lcd_touch/esp_lcd_touch.c

@@ -0,0 +1,258 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "driver/gpio.h"
+#include "esp_system.h"
+#include "esp_err.h"
+#include "esp_check.h"
+#include "esp_log.h"
+#include "esp_lcd_touch.h"
+
+static const char *TAG = "TP";
+
+/*******************************************************************************
+* Function definitions
+*******************************************************************************/
+
+/*******************************************************************************
+* Local variables
+*******************************************************************************/
+
+/*******************************************************************************
+* Public API functions
+*******************************************************************************/
+
+esp_err_t esp_lcd_touch_enter_sleep(esp_lcd_touch_handle_t tp)
+{
+    assert(tp != NULL);
+    if (tp->enter_sleep == NULL) {
+        ESP_LOGE(TAG, "Sleep mode not supported!");
+        return ESP_FAIL;
+    } else {
+        return tp->enter_sleep(tp);
+    }
+}
+
+esp_err_t esp_lcd_touch_exit_sleep(esp_lcd_touch_handle_t tp)
+{
+    assert(tp != NULL);
+    if (tp->exit_sleep == NULL) {
+        ESP_LOGE(TAG, "Sleep mode not supported!");
+        return ESP_FAIL;
+    } else {
+        return tp->exit_sleep(tp);
+    }
+}
+
+esp_err_t esp_lcd_touch_read_data(esp_lcd_touch_handle_t tp)
+{
+    assert(tp != NULL);
+    assert(tp->read_data != NULL);
+
+    return tp->read_data(tp);
+}
+
+bool esp_lcd_touch_get_coordinates(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num)
+{
+    bool touched = false;
+
+    assert(tp != NULL);
+    assert(x != NULL);
+    assert(y != NULL);
+    assert(tp->get_xy != NULL);
+
+    touched = tp->get_xy(tp, x, y, strength, point_num, max_point_num);
+    if (!touched) {
+        return false;
+    }
+
+    /* Process coordinates by user */
+    if (tp->config.process_coordinates != NULL) {
+        tp->config.process_coordinates(tp, x, y, strength, point_num, max_point_num);
+    }
+
+    /* Software coordinates adjustment needed */
+    bool sw_adj_needed = ((tp->config.flags.mirror_x && (tp->set_mirror_x == NULL)) ||
+                          (tp->config.flags.mirror_y && (tp->set_mirror_y == NULL)) ||
+                          (tp->config.flags.swap_xy && (tp->set_swap_xy == NULL)));
+
+    /* Adjust all coordinates */
+    for (int i = 0; (sw_adj_needed && i < *point_num); i++) {
+
+        /*  Mirror X coordinates (if not supported by HW) */
+        if (tp->config.flags.mirror_x && tp->set_mirror_x == NULL) {
+            x[i] = tp->config.x_max - x[i];
+        }
+
+        /*  Mirror Y coordinates (if not supported by HW) */
+        if (tp->config.flags.mirror_y && tp->set_mirror_y == NULL) {
+            y[i] = tp->config.y_max - y[i];
+        }
+
+        /* Swap X and Y coordinates (if not supported by HW) */
+        if (tp->config.flags.swap_xy && tp->set_swap_xy == NULL) {
+            uint16_t tmp = x[i];
+            x[i] = y[i];
+            y[i] = tmp;
+        }
+    }
+
+    return touched;
+}
+
+#if (CONFIG_ESP_LCD_TOUCH_MAX_BUTTONS > 0)
+esp_err_t esp_lcd_touch_get_button_state(esp_lcd_touch_handle_t tp, uint8_t n, uint8_t *state)
+{
+    assert(tp != NULL);
+    assert(state != NULL);
+
+    *state = 0;
+
+    if (tp->get_button_state) {
+        return tp->get_button_state(tp, n, state);
+    } else {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+
+    return ESP_OK;
+}
+#endif
+
+esp_err_t esp_lcd_touch_set_swap_xy(esp_lcd_touch_handle_t tp, bool swap)
+{
+    assert(tp != NULL);
+
+    tp->config.flags.swap_xy = swap;
+
+    /* Is swap supported by HW? */
+    if (tp->set_swap_xy) {
+        return tp->set_swap_xy(tp, swap);
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_lcd_touch_get_swap_xy(esp_lcd_touch_handle_t tp, bool *swap)
+{
+    assert(tp != NULL);
+    assert(swap != NULL);
+
+    /* Is swap supported by HW? */
+    if (tp->get_swap_xy) {
+        return tp->get_swap_xy(tp, swap);
+    } else {
+        *swap = tp->config.flags.swap_xy;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_lcd_touch_set_mirror_x(esp_lcd_touch_handle_t tp, bool mirror)
+{
+    assert(tp != NULL);
+
+    tp->config.flags.mirror_x = mirror;
+
+    /* Is mirror supported by HW? */
+    if (tp->set_mirror_x) {
+        return tp->set_mirror_x(tp, mirror);
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_lcd_touch_get_mirror_x(esp_lcd_touch_handle_t tp, bool *mirror)
+{
+    assert(tp != NULL);
+    assert(mirror != NULL);
+
+    /* Is swap supported by HW? */
+    if (tp->get_mirror_x) {
+        return tp->get_mirror_x(tp, mirror);
+    } else {
+        *mirror = tp->config.flags.mirror_x;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_lcd_touch_set_mirror_y(esp_lcd_touch_handle_t tp, bool mirror)
+{
+    assert(tp != NULL);
+
+    tp->config.flags.mirror_y = mirror;
+
+    /* Is mirror supported by HW? */
+    if (tp->set_mirror_y) {
+        return tp->set_mirror_y(tp, mirror);
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_lcd_touch_get_mirror_y(esp_lcd_touch_handle_t tp, bool *mirror)
+{
+    assert(tp != NULL);
+    assert(mirror != NULL);
+
+    /* Is swap supported by HW? */
+    if (tp->get_mirror_y) {
+        return tp->get_mirror_y(tp, mirror);
+    } else {
+        *mirror = tp->config.flags.mirror_y;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_lcd_touch_del(esp_lcd_touch_handle_t tp)
+{
+    assert(tp != NULL);
+
+    if (tp->del != NULL) {
+        return tp->del(tp);
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_lcd_touch_register_interrupt_callback(esp_lcd_touch_handle_t tp, esp_lcd_touch_interrupt_callback_t callback)
+{
+    esp_err_t ret = ESP_OK;
+    assert(tp != NULL);
+
+    /* Interrupt pin is not selected */
+    if (tp->config.int_gpio_num == GPIO_NUM_NC) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    tp->config.interrupt_callback = callback;
+
+    if (callback != NULL) {
+        ret = gpio_install_isr_service(0);
+        /* ISR service can be installed from user before, then it returns invalid state */
+        if (ret != ESP_OK && ret != ESP_ERR_INVALID_STATE) {
+            ESP_LOGE(TAG, "GPIO ISR install failed");
+            return ret;
+        }
+        /* Add GPIO ISR handler */
+        ret = gpio_intr_enable(tp->config.int_gpio_num);
+        ESP_RETURN_ON_ERROR(ret, TAG, "GPIO ISR install failed");
+        ret = gpio_isr_handler_add(tp->config.int_gpio_num, (gpio_isr_t)tp->config.interrupt_callback, tp);
+        ESP_RETURN_ON_ERROR(ret, TAG, "GPIO ISR install failed");
+    } else {
+        /* Remove GPIO ISR handler */
+        ret = gpio_isr_handler_remove(tp->config.int_gpio_num);
+        ESP_RETURN_ON_ERROR(ret, TAG, "GPIO ISR remove handler failed");
+        ret = gpio_intr_disable(tp->config.int_gpio_num);
+        ESP_RETURN_ON_ERROR(ret, TAG, "GPIO ISR disable failed");
+    }
+
+    return ESP_OK;
+}

Lib/Display/Touch_Driver/esp_lcd_touch/esp_lcd_touch.h

@@ -0,0 +1,413 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file
+ * @brief ESP LCD touch
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include "sdkconfig.h"
+#include "esp_err.h"
+#include "driver/gpio.h"
+#include "esp_lcd_panel_io.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define CONFIG_ESP_LCD_TOUCH_MAX_POINTS 2
+/**
+ * @brief Touch controller type
+ *
+ */
+typedef struct esp_lcd_touch_s esp_lcd_touch_t;
+typedef esp_lcd_touch_t *esp_lcd_touch_handle_t;
+
+/**
+ * @brief Touch controller interrupt callback type
+ *
+ */
+typedef void (*esp_lcd_touch_interrupt_callback_t)(esp_lcd_touch_handle_t tp);
+
+/**
+ * @brief Touch Configuration Type
+ *
+ */
+typedef struct {
+    uint16_t x_max; /*!< X coordinates max (for mirroring) */
+    uint16_t y_max; /*!< Y coordinates max (for mirroring) */
+
+    gpio_num_t rst_gpio_num;    /*!< GPIO number of reset pin */
+    gpio_num_t int_gpio_num;    /*!< GPIO number of interrupt pin */
+
+    struct {
+        unsigned int reset: 1;    /*!< Level of reset pin in reset */
+        unsigned int interrupt: 1;/*!< Active Level of interrupt pin */
+    } levels;
+
+    struct {
+        unsigned int swap_xy: 1;  /*!< Swap X and Y after read coordinates */
+        unsigned int mirror_x: 1; /*!< Mirror X after read coordinates */
+        unsigned int mirror_y: 1; /*!< Mirror Y after read coordinates */
+    } flags;
+
+    /*!< User callback called after get coordinates from touch controller for apply user adjusting */
+    void (*process_coordinates)(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
+    /*!< User callback called after the touch interrupt occured */
+    esp_lcd_touch_interrupt_callback_t interrupt_callback;
+} esp_lcd_touch_config_t;
+
+typedef struct {
+    uint8_t points; /*!< Count of touch points saved */
+
+    struct {
+        uint16_t x; /*!< X coordinate */
+        uint16_t y; /*!< Y coordinate */
+        uint16_t strength; /*!< Strength */
+    } coords[CONFIG_ESP_LCD_TOUCH_MAX_POINTS];
+
+#if (CONFIG_ESP_LCD_TOUCH_MAX_BUTTONS > 0)
+    uint8_t buttons; /*!< Count of buttons states saved */
+
+    struct {
+        uint8_t status; /*!< Status of button */
+    } button[CONFIG_ESP_LCD_TOUCH_MAX_BUTTONS];
+#endif
+
+    portMUX_TYPE lock; /*!< Lock for read/write */
+} esp_lcd_touch_data_t;
+
+/**
+ * @brief Declare of Touch Type
+ *
+ */
+struct esp_lcd_touch_s {
+
+    /**
+     * @brief set touch controller into sleep mode
+     *
+     * @note This function is usually blocking.
+     *
+     * @param tp: Touch handler
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*enter_sleep)(esp_lcd_touch_handle_t tp);
+
+    /**
+     * @brief set touch controller into normal mode
+     *
+     * @note This function is usually blocking.
+     *
+     * @param tp: Touch handler
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*exit_sleep)(esp_lcd_touch_handle_t tp);
+
+    /**
+     * @brief Read data from touch controller (mandatory)
+     *
+     * @note This function is usually blocking.
+     *
+     * @param tp: Touch handler
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*read_data)(esp_lcd_touch_handle_t tp);
+
+    /**
+     * @brief Get coordinates from touch controller (mandatory)
+     *
+     * @param tp: Touch handler
+     * @param x: Array of X coordinates
+     * @param y: Array of Y coordinates
+     * @param strength: Array of strengths
+     * @param point_num: Count of points touched (equals with count of items in x and y array)
+     * @param max_point_num: Maximum count of touched points to return (equals with max size of x and y array)
+     *
+     * @return
+     *      - Returns true, when touched and coordinates readed. Otherwise returns false.
+     */
+    bool (*get_xy)(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
+
+
+#if (CONFIG_ESP_LCD_TOUCH_MAX_BUTTONS > 0)
+    /**
+     * @brief Get button state (optional)
+     *
+     * @param tp: Touch handler
+     * @param n: Button index
+     * @param state: Button state
+     *
+     * @return
+     *      - Returns true, when touched and coordinates readed. Otherwise returns false.
+     */
+    esp_err_t (*get_button_state)(esp_lcd_touch_handle_t tp, uint8_t n, uint8_t *state);
+#endif
+
+    /**
+     * @brief Swap X and Y after read coordinates (optional)
+     *        If set, then not used SW swapping.
+     *
+     * @param tp: Touch handler
+     * @param swap: Set swap value
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*set_swap_xy)(esp_lcd_touch_handle_t tp, bool swap);
+
+    /**
+     * @brief Are X and Y coordinates swapped (optional)
+     *
+     * @param tp: Touch handler
+     * @param swap: Get swap value
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*get_swap_xy)(esp_lcd_touch_handle_t tp, bool *swap);
+
+    /**
+     * @brief Mirror X after read coordinates
+     *        If set, then not used SW mirroring.
+     *
+     * @param tp: Touch handler
+     * @param mirror: Set X mirror value
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*set_mirror_x)(esp_lcd_touch_handle_t tp, bool mirror);
+
+    /**
+     * @brief Is mirrored X (optional)
+     *
+     * @param tp: Touch handler
+     * @param mirror: Get X mirror value
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*get_mirror_x)(esp_lcd_touch_handle_t tp, bool *mirror);
+
+    /**
+     * @brief Mirror Y after read coordinates
+     *        If set, then not used SW mirroring.
+     *
+     * @param tp: Touch handler
+     * @param mirror: Set Y mirror value
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*set_mirror_y)(esp_lcd_touch_handle_t tp, bool mirror);
+
+    /**
+     * @brief Is mirrored Y (optional)
+     *
+     * @param tp: Touch handler
+     * @param mirror: Get Y mirror value
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*get_mirror_y)(esp_lcd_touch_handle_t tp, bool *mirror);
+
+    /**
+     * @brief Delete Touch
+     *
+     * @param tp: Touch handler
+     *
+     * @return
+     *      - ESP_OK on success, otherwise returns ESP_ERR_xxx
+     */
+    esp_err_t (*del)(esp_lcd_touch_handle_t tp);
+
+    /**
+     * @brief Configuration structure
+     */
+    esp_lcd_touch_config_t config;
+
+    /**
+     * @brief Communication interface
+     */
+    esp_lcd_panel_io_handle_t io;
+
+    /**
+     * @brief Data structure
+     */
+    esp_lcd_touch_data_t data;
+};
+
+/**
+ * @brief Read data from touch controller
+ *
+ * @note This function is usually blocking.
+ *
+ * @param tp: Touch handler
+ *
+ * @return
+ *     - ESP_OK                 on success
+ *     - ESP_ERR_INVALID_ARG    parameter error
+ *     - ESP_FAIL               sending command error, slave hasn't ACK the transfer
+ *     - ESP_ERR_INVALID_STATE  I2C driver not installed or not in master mode
+ *     - ESP_ERR_TIMEOUT        operation timeout because the bus is busy
+ */
+esp_err_t esp_lcd_touch_read_data(esp_lcd_touch_handle_t tp);
+
+/**
+ * @brief Read coordinates from touch controller
+ *
+ * @param tp: Touch handler
+ * @param x: Array of X coordinates
+ * @param y: Array of Y coordinates
+ * @param strength: Array of the strengths (can be NULL)
+ * @param point_num: Count of points touched (equals with count of items in x and y array)
+ * @param max_point_num: Maximum count of touched points to return (equals with max size of x and y array)
+ *
+ * @return
+ *      - Returns true, when touched and coordinates readed. Otherwise returns false.
+ */
+bool esp_lcd_touch_get_coordinates(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
+
+
+#if (CONFIG_ESP_LCD_TOUCH_MAX_BUTTONS > 0)
+/**
+ * @brief Get button state
+ *
+ * @param tp: Touch handler
+ * @param n: Button index
+ * @param state: Button state
+ *
+ * @return
+ *      - ESP_OK                    on success
+ *      - ESP_ERR_NOT_SUPPORTED     if this function is not supported by controller
+ *      - ESP_ERR_INVALID_ARG       if bad button index
+ */
+esp_err_t esp_lcd_touch_get_button_state(esp_lcd_touch_handle_t tp, uint8_t n, uint8_t *state);
+#endif
+
+/**
+ * @brief Swap X and Y after read coordinates
+ *
+ * @param tp: Touch handler
+ * @param swap: Set swap value
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_set_swap_xy(esp_lcd_touch_handle_t tp, bool swap);
+
+/**
+ * @brief Are X and Y coordinates swapped
+ *
+ * @param tp: Touch handler
+ * @param swap: Get swap value
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_get_swap_xy(esp_lcd_touch_handle_t tp, bool *swap);
+
+/**
+ * @brief Mirror X after read coordinates
+ *
+ * @param tp: Touch handler
+ * @param mirror: Set X mirror value
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_set_mirror_x(esp_lcd_touch_handle_t tp, bool mirror);
+
+/**
+ * @brief Is mirrored X
+ *
+ * @param tp: Touch handler
+ * @param mirror: Get X mirror value
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_get_mirror_x(esp_lcd_touch_handle_t tp, bool *mirror);
+
+/**
+ * @brief Mirror Y after read coordinates
+ *
+ * @param tp: Touch handler
+ * @param mirror: Set Y mirror value
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_set_mirror_y(esp_lcd_touch_handle_t tp, bool mirror);
+
+/**
+ * @brief Is mirrored Y
+ *
+ * @param tp: Touch handler
+ * @param mirror: Get Y mirror value
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_get_mirror_y(esp_lcd_touch_handle_t tp, bool *mirror);
+
+/**
+ * @brief Delete touch (free all allocated memory and restart HW)
+ *
+ * @param tp: Touch handler
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_del(esp_lcd_touch_handle_t tp);
+
+/**
+ * @brief Register user callback called after the touch interrupt occured
+ *
+ * @param tp: Touch handler
+ * @param callback: Interrupt callback
+ *
+ * @return
+ *      - ESP_OK on success
+ */
+esp_err_t esp_lcd_touch_register_interrupt_callback(esp_lcd_touch_handle_t tp, esp_lcd_touch_interrupt_callback_t callback);
+
+/**
+ * @brief Enter sleep mode
+ *
+ * @param tp: Touch handler
+ *
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_ARG if parameter is invalid
+ */
+esp_err_t esp_lcd_touch_enter_sleep(esp_lcd_touch_handle_t tp);
+
+/**
+ * @brief Exit sleep mode
+ *
+ * @param tp: Touch handler
+ *
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_ARG if parameter is invalid
+ */
+esp_err_t esp_lcd_touch_exit_sleep(esp_lcd_touch_handle_t tp);
+
+#ifdef __cplusplus
+}
+#endif