From 4c675acbfaca9825ca05fb0201bd54114872186d Mon Sep 17 00:00:00 2001 From: jarvis <1071094494@qq.com> Date: Mon, 3 Mar 2025 21:36:45 +0800 Subject: [PATCH] =?UTF-8?q?=E5=9C=A8main=E6=96=87=E4=BB=B6=E4=B8=AD?= =?UTF-8?q?=E6=96=B0=E5=A2=9E=E8=A7=A6=E6=91=B8=E5=B1=8F=E9=A9=B1=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dependencies.lock | 27 +- main/i80_controller_example_main.c | 162 +++---- main/idf_component.yml | 1 + .../espressif__esp_lcd_touch/.component_hash | 1 + .../espressif__esp_lcd_touch/CMakeLists.txt | 1 + .../espressif__esp_lcd_touch/Kconfig | 13 + .../espressif__esp_lcd_touch/README.md | 16 + .../espressif__esp_lcd_touch/esp_lcd_touch.c | 266 +++++++++++ .../idf_component.yml | 10 + .../include/esp_lcd_touch.h | 429 ++++++++++++++++++ .../espressif__esp_lcd_touch/license.txt | 202 +++++++++ .../.component_hash | 1 + .../CMakeLists.txt | 1 + .../espressif__esp_lcd_touch_ft5x06/README.md | 65 +++ .../esp_lcd_touch_ft5x06.c | 329 ++++++++++++++ .../idf_component.yml | 12 + .../include/esp_lcd_touch_ft5x06.h | 59 +++ .../license.txt | 202 +++++++++ sdkconfig | 7 + 19 files changed, 1723 insertions(+), 81 deletions(-) create mode 100644 managed_components/espressif__esp_lcd_touch/.component_hash create mode 100644 managed_components/espressif__esp_lcd_touch/CMakeLists.txt create mode 100644 managed_components/espressif__esp_lcd_touch/Kconfig create mode 100644 managed_components/espressif__esp_lcd_touch/README.md create mode 100644 managed_components/espressif__esp_lcd_touch/esp_lcd_touch.c create mode 100644 managed_components/espressif__esp_lcd_touch/idf_component.yml create mode 100644 managed_components/espressif__esp_lcd_touch/include/esp_lcd_touch.h create mode 100644 managed_components/espressif__esp_lcd_touch/license.txt create mode 100644 managed_components/espressif__esp_lcd_touch_ft5x06/.component_hash create mode 100644 managed_components/espressif__esp_lcd_touch_ft5x06/CMakeLists.txt create mode 100644 managed_components/espressif__esp_lcd_touch_ft5x06/README.md create mode 100644 managed_components/espressif__esp_lcd_touch_ft5x06/esp_lcd_touch_ft5x06.c create mode 100644 managed_components/espressif__esp_lcd_touch_ft5x06/idf_component.yml create mode 100644 managed_components/espressif__esp_lcd_touch_ft5x06/include/esp_lcd_touch_ft5x06.h create mode 100644 managed_components/espressif__esp_lcd_touch_ft5x06/license.txt diff --git a/dependencies.lock b/dependencies.lock index ad4a2a7..6f7c6f7 100644 --- a/dependencies.lock +++ b/dependencies.lock @@ -1,4 +1,28 @@ dependencies: + espressif/esp_lcd_touch: + component_hash: 779b4ba2464a3ae85681e4b860caa5fdc35801458c23f3039ee761bae7f442a4 + dependencies: + - name: idf + require: private + version: '>=4.4.2' + source: + registry_url: https://components.espressif.com + type: service + version: 1.1.2 + espressif/esp_lcd_touch_ft5x06: + component_hash: abaec05f46a793549b60afdda9eff86e3c8e87782c8c169007911232388d2858 + dependencies: + - name: espressif/esp_lcd_touch + registry_url: https://components.espressif.com + require: public + version: ^1.0.4 + - name: idf + require: private + version: '>=4.4.2' + source: + registry_url: https://components.espressif.com/ + type: service + version: 1.0.7 idf: source: type: idf @@ -11,7 +35,8 @@ dependencies: type: service version: 8.4.0 direct_dependencies: +- espressif/esp_lcd_touch_ft5x06 - lvgl/lvgl -manifest_hash: d403fcd20f67e94fd3f38426dfd0b50d3031d96d32780480cc18577ddc286a06 +manifest_hash: 5a409aa14e6871dd5b4a370b7060c8ce1c4ce68ef17a7f30e3154244d15b8b5e target: esp32s3 version: 2.0.0 diff --git a/main/i80_controller_example_main.c b/main/i80_controller_example_main.c index 2b0df6c..981e91c 100644 --- a/main/i80_controller_example_main.c +++ b/main/i80_controller_example_main.c @@ -18,6 +18,10 @@ #include "driver/gpio.h" #include "lvgl.h" +//新增触摸屏驱动头文件 +#include "driver/i2c.h" +#include "esp_lcd_touch_ft5x06.h" + static const char *TAG = "example"; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -27,6 +31,7 @@ static const char *TAG = "example"; #define EXAMPLE_LCD_BK_LIGHT_ON_LEVEL 0 #define EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL !EXAMPLE_LCD_BK_LIGHT_ON_LEVEL +/*定义数据接口*/ #define EXAMPLE_PIN_NUM_DATA0 18 #define EXAMPLE_PIN_NUM_DATA1 17 #define EXAMPLE_PIN_NUM_DATA2 16 @@ -35,16 +40,8 @@ static const char *TAG = "example"; #define EXAMPLE_PIN_NUM_DATA5 6 #define EXAMPLE_PIN_NUM_DATA6 5 #define EXAMPLE_PIN_NUM_DATA7 4 -#if CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH > 8 -#define EXAMPLE_PIN_NUM_DATA8 14 -#define EXAMPLE_PIN_NUM_DATA9 15 -#define EXAMPLE_PIN_NUM_DATA10 16 -#define EXAMPLE_PIN_NUM_DATA11 17 -#define EXAMPLE_PIN_NUM_DATA12 18 -#define EXAMPLE_PIN_NUM_DATA13 19 -#define EXAMPLE_PIN_NUM_DATA14 20 -#define EXAMPLE_PIN_NUM_DATA15 21 -#endif + +/*定义屏幕显示其他接口*/ #define EXAMPLE_PIN_NUM_PCLK 19 #define EXAMPLE_PIN_NUM_CS 45 #define EXAMPLE_PIN_NUM_DC 20 @@ -55,22 +52,14 @@ static const char *TAG = "example"; #define EXAMPLE_LCD_H_RES 320 #define EXAMPLE_LCD_V_RES 480 // Bit number used to represent command and parameter -#if CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ST7789 #define EXAMPLE_LCD_CMD_BITS 8 #define EXAMPLE_LCD_PARAM_BITS 8 -#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_NT35510 -#define EXAMPLE_LCD_CMD_BITS 16 -#define EXAMPLE_LCD_PARAM_BITS 16 -#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ILI9341 -#define EXAMPLE_LCD_CMD_BITS 8 -#define EXAMPLE_LCD_PARAM_BITS 8 -#endif +//定义所使用触摸屏驱动接口 #define EXAMPLE_I2C_NUM 0 // I2C number #define EXAMPLE_I2C_SCL 21 #define EXAMPLE_I2C_SDA 47 - #define EXAMPLE_LVGL_TICK_PERIOD_MS 2 #define EXAMPLE_LVGL_TASK_MAX_DELAY_MS 500 #define EXAMPLE_LVGL_TASK_MIN_DELAY_MS 1 @@ -101,6 +90,31 @@ static void example_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_ esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map); } +/*新增电容触摸屏缓存*/ +static void example_lvgl_touch_cb(lv_indev_drv_t *drv, lv_indev_data_t *data) +{ + uint16_t touchpad_x[1] = {0}; + uint16_t touchpad_y[1] = {0}; + uint8_t touchpad_cnt = 0; + + /* Read touch controller data */ + esp_lcd_touch_read_data(drv->user_data); + + /* Get coordinates */ + bool touchpad_pressed = esp_lcd_touch_get_coordinates(drv->user_data, touchpad_x, touchpad_y, NULL, &touchpad_cnt, 1); + + if (touchpad_pressed && touchpad_cnt > 0) + { + data->point.x = touchpad_x[0]; + data->point.y = touchpad_y[0]; + data->state = LV_INDEV_STATE_PRESSED; + } + else + { + data->state = LV_INDEV_STATE_RELEASED; + } +} + static void example_increase_lvgl_tick(void *arg) { /* Tell LVGL how many milliseconds has elapsed */ @@ -195,16 +209,6 @@ void example_init_i80_bus(esp_lcd_panel_io_handle_t *io_handle, void *user_ctx) EXAMPLE_PIN_NUM_DATA5, EXAMPLE_PIN_NUM_DATA6, EXAMPLE_PIN_NUM_DATA7, -#if CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH > 8 - EXAMPLE_PIN_NUM_DATA8, - EXAMPLE_PIN_NUM_DATA9, - EXAMPLE_PIN_NUM_DATA10, - EXAMPLE_PIN_NUM_DATA11, - EXAMPLE_PIN_NUM_DATA12, - EXAMPLE_PIN_NUM_DATA13, - EXAMPLE_PIN_NUM_DATA14, - EXAMPLE_PIN_NUM_DATA15, -#endif }, .bus_width = CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH, .max_transfer_bytes = EXAMPLE_LCD_H_RES * 100 * sizeof(uint16_t), @@ -236,7 +240,7 @@ void example_init_i80_bus(esp_lcd_panel_io_handle_t *io_handle, void *user_ctx) void example_init_lcd_panel(esp_lcd_panel_io_handle_t io_handle, esp_lcd_panel_handle_t *panel) { esp_lcd_panel_handle_t panel_handle = NULL; -#if CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ST7789 + ESP_LOGI(TAG, "Install LCD driver of st7789"); esp_lcd_panel_dev_config_t panel_config = { .reset_gpio_num = EXAMPLE_PIN_NUM_RST, @@ -253,59 +257,53 @@ void example_init_lcd_panel(esp_lcd_panel_io_handle_t io_handle, esp_lcd_panel_h esp_lcd_panel_set_gap(panel_handle, 0, 0); esp_lcd_panel_mirror(panel_handle, true, false); - -#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_NT35510 - ESP_LOGI(TAG, "Install LCD driver of nt35510"); - esp_lcd_panel_dev_config_t panel_config = { - .reset_gpio_num = EXAMPLE_PIN_NUM_RST, - .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_BGR, - .bits_per_pixel = 16, - }; - ESP_ERROR_CHECK(esp_lcd_new_panel_nt35510(io_handle, &panel_config, &panel_handle)); - - esp_lcd_panel_reset(panel_handle); - esp_lcd_panel_init(panel_handle); - // Set inversion, x/y coordinate order, x/y mirror according to your LCD module spec - // the gap is LCD panel specific, even panels with the same driver IC, can have different gap value - esp_lcd_panel_swap_xy(panel_handle, true); - esp_lcd_panel_mirror(panel_handle, true, false); -#elif CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ILI9341 - // ILI9341 is NOT a distinct driver, but a special case of ST7789 - // (essential registers are identical). A few lines further down in this code, - // it's shown how to issue additional device-specific commands. - ESP_LOGI(TAG, "Install LCD driver of ili9341 (st7789 compatible)"); - esp_lcd_panel_dev_config_t panel_config = { - .reset_gpio_num = EXAMPLE_PIN_NUM_RST, - .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_BGR, - .bits_per_pixel = 16, - }; - ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(io_handle, &panel_config, &panel_handle)); - - esp_lcd_panel_reset(panel_handle); - esp_lcd_panel_init(panel_handle); - // Set inversion, x/y coordinate order, x/y mirror according to your LCD module spec - // the gap is LCD panel specific, even panels with the same driver IC, can have different gap value - esp_lcd_panel_swap_xy(panel_handle, true); - esp_lcd_panel_invert_color(panel_handle, false); - // ILI9341 is very similar to ST7789 and shares the same driver. - // Anything unconventional (such as this custom gamma table) can - // be issued here in user code and need not modify the driver. - esp_lcd_panel_io_tx_param(io_handle, 0xF2, (uint8_t[]) { - 0 - }, 1); // 3Gamma function disable - esp_lcd_panel_io_tx_param(io_handle, 0x26, (uint8_t[]) { - 1 - }, 1); // Gamma curve 1 selected - esp_lcd_panel_io_tx_param(io_handle, 0xE0, (uint8_t[]) { // Set positive gamma - 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00 - }, 15); - esp_lcd_panel_io_tx_param(io_handle, 0xE1, (uint8_t[]) { // Set negative gamma - 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F - }, 15); -#endif *panel = panel_handle; } +/*初始化触摸屏驱动*/ +void example_init_touch_panel(void) +{ + esp_lcd_touch_handle_t tp = NULL; + esp_lcd_panel_io_handle_t tp_io_handle = NULL; + + ESP_LOGI(TAG, "Initialize I2C"); + + const i2c_config_t i2c_conf = { + .mode = I2C_MODE_MASTER, + .sda_io_num = EXAMPLE_I2C_SDA, + .scl_io_num = EXAMPLE_I2C_SCL, + .sda_pullup_en = GPIO_PULLUP_ENABLE, + .scl_pullup_en = GPIO_PULLUP_ENABLE, + .master.clk_speed = 400000, + }; + /* Initialize I2C */ + ESP_ERROR_CHECK(i2c_param_config(EXAMPLE_I2C_NUM, &i2c_conf)); + ESP_ERROR_CHECK(i2c_driver_install(EXAMPLE_I2C_NUM, i2c_conf.mode, 0, 0, 0)); + + esp_lcd_panel_io_i2c_config_t tp_io_config = ESP_LCD_TOUCH_IO_I2C_FT5x06_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)EXAMPLE_I2C_NUM, &tp_io_config, &tp_io_handle)); + + esp_lcd_touch_config_t tp_cfg = { + .x_max = EXAMPLE_LCD_V_RES, + .y_max = EXAMPLE_LCD_H_RES, + .rst_gpio_num = -1, + .int_gpio_num = -1, + .flags = { + .swap_xy = 0, + .mirror_x = 0, + .mirror_y = 0, + }, + }; + + ESP_LOGI(TAG, "Initialize touch controller FT5X06"); + ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_ft5x06(tp_io_handle, &tp_cfg, &tp)); +} + + void app_main(void) { static lv_disp_draw_buf_t disp_buf; // contains internal graphic buffer(s) called draw buffer(s) @@ -340,11 +338,15 @@ void app_main(void) gpio_set_level(EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_ON_LEVEL); #endif // EXAMPLE_PIN_NUM_BK_LIGHT >= 0 + /*将触摸屏驱动初始化放置到这里*/ + example_init_touch_panel(); + ESP_LOGI(TAG, "Initialize LVGL library"); lv_init(); // alloc draw buffers used by LVGL // it's recommended to choose the size of the draw buffer(s) to be at least 1/10 screen sized uint32_t draw_buf_alloc_caps = 0; + #if CONFIG_EXAMPLE_LCD_I80_COLOR_IN_PSRAM draw_buf_alloc_caps |= MALLOC_CAP_SPIRAM; #endif diff --git a/main/idf_component.yml b/main/idf_component.yml index 982d037..eaed44f 100644 --- a/main/idf_component.yml +++ b/main/idf_component.yml @@ -1,2 +1,3 @@ dependencies: lvgl/lvgl: "~8.4.0" + esp_lcd_touch_ft5x06: "^1.0" diff --git a/managed_components/espressif__esp_lcd_touch/.component_hash b/managed_components/espressif__esp_lcd_touch/.component_hash new file mode 100644 index 0000000..5cd93e3 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/.component_hash @@ -0,0 +1 @@ +779b4ba2464a3ae85681e4b860caa5fdc35801458c23f3039ee761bae7f442a4 \ No newline at end of file diff --git a/managed_components/espressif__esp_lcd_touch/CMakeLists.txt b/managed_components/espressif__esp_lcd_touch/CMakeLists.txt new file mode 100644 index 0000000..a464b4d --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/CMakeLists.txt @@ -0,0 +1 @@ +idf_component_register(SRCS "esp_lcd_touch.c" INCLUDE_DIRS "include" REQUIRES "driver" "esp_lcd") diff --git a/managed_components/espressif__esp_lcd_touch/Kconfig b/managed_components/espressif__esp_lcd_touch/Kconfig new file mode 100644 index 0000000..ed30f44 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/Kconfig @@ -0,0 +1,13 @@ +menu "ESP LCD TOUCH" + + config ESP_LCD_TOUCH_MAX_POINTS + int "Maximum count of the touch points" + range 1 10 + default 5 + + config ESP_LCD_TOUCH_MAX_BUTTONS + int "Maximum count of the touch buttons supported" + range 0 10 + default 1 + +endmenu \ No newline at end of file diff --git a/managed_components/espressif__esp_lcd_touch/README.md b/managed_components/espressif__esp_lcd_touch/README.md new file mode 100644 index 0000000..de6e614 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/README.md @@ -0,0 +1,16 @@ +# ESP LCD Touch Component + +[![Component Registry](https://components.espressif.com/components/espressif/esp_lcd_touch/badge.svg)](https://components.espressif.com/components/espressif/esp_lcd_touch) + +This componnent is main esp_lcd_touch component which defines main functions and types for easy adding specific touch controller component. + +## Supported features + +- [x] Read XY +- [x] Swap XY +- [x] Mirror X +- [x] Mirror Y +- [x] Interrupt callback +- [x] Sleep mode +- [ ] Calibration + diff --git a/managed_components/espressif__esp_lcd_touch/esp_lcd_touch.c b/managed_components/espressif__esp_lcd_touch/esp_lcd_touch.c new file mode 100644 index 0000000..2e6034f --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/esp_lcd_touch.c @@ -0,0 +1,266 @@ +/* + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#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; +} + +esp_err_t esp_lcd_touch_register_interrupt_callback_with_data(esp_lcd_touch_handle_t tp, esp_lcd_touch_interrupt_callback_t callback, void *user_data) +{ + assert(tp != NULL); + + tp->config.user_data = user_data; + return esp_lcd_touch_register_interrupt_callback(tp, callback); +} diff --git a/managed_components/espressif__esp_lcd_touch/idf_component.yml b/managed_components/espressif__esp_lcd_touch/idf_component.yml new file mode 100644 index 0000000..0fef7c4 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/idf_component.yml @@ -0,0 +1,10 @@ +dependencies: + idf: + version: '>=4.4.2' +description: ESP LCD Touch - main component for using touch screen controllers +repository: git://github.com/espressif/esp-bsp.git +repository_info: + commit_sha: 54e9ba5f17d0f007f5a4073240b5f6c20e099f91 + path: components/lcd_touch/esp_lcd_touch +url: https://github.com/espressif/esp-bsp/tree/master/components/lcd_touch/esp_lcd_touch +version: 1.1.2 diff --git a/managed_components/espressif__esp_lcd_touch/include/esp_lcd_touch.h b/managed_components/espressif__esp_lcd_touch/include/esp_lcd_touch.h new file mode 100644 index 0000000..d0b2676 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/include/esp_lcd_touch.h @@ -0,0 +1,429 @@ +/* + * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @file + * @brief ESP LCD touch + */ + +#pragma once + +#include +#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 + +/** + * @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 occurred */ + esp_lcd_touch_interrupt_callback_t interrupt_callback; + /*!< User data passed to callback */ + void *user_data; + /*!< User data passed to driver */ + void *driver_data; +} 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 occurred + * + * @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 Register user callback called after the touch interrupt occurred with user data + * + * @param tp: Touch handler + * @param callback: Interrupt callback + * @param user_data: User data passed to callback + * + * @return + * - ESP_OK on success + */ +esp_err_t esp_lcd_touch_register_interrupt_callback_with_data(esp_lcd_touch_handle_t tp, esp_lcd_touch_interrupt_callback_t callback, void *user_data); + +/** + * @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 diff --git a/managed_components/espressif__esp_lcd_touch/license.txt b/managed_components/espressif__esp_lcd_touch/license.txt new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch/license.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/managed_components/espressif__esp_lcd_touch_ft5x06/.component_hash b/managed_components/espressif__esp_lcd_touch_ft5x06/.component_hash new file mode 100644 index 0000000..7c68464 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch_ft5x06/.component_hash @@ -0,0 +1 @@ +abaec05f46a793549b60afdda9eff86e3c8e87782c8c169007911232388d2858 \ No newline at end of file diff --git a/managed_components/espressif__esp_lcd_touch_ft5x06/CMakeLists.txt b/managed_components/espressif__esp_lcd_touch_ft5x06/CMakeLists.txt new file mode 100644 index 0000000..32caf48 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch_ft5x06/CMakeLists.txt @@ -0,0 +1 @@ +idf_component_register(SRCS "esp_lcd_touch_ft5x06.c" INCLUDE_DIRS "include" REQUIRES "esp_lcd") diff --git a/managed_components/espressif__esp_lcd_touch_ft5x06/README.md b/managed_components/espressif__esp_lcd_touch_ft5x06/README.md new file mode 100644 index 0000000..fd5bf67 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch_ft5x06/README.md @@ -0,0 +1,65 @@ +# ESP LCD Touch FT5x06 Controller + +[![Component Registry](https://components.espressif.com/components/espressif/esp_lcd_touch_ft5x06/badge.svg)](https://components.espressif.com/components/espressif/esp_lcd_touch_ft5x06) + +Implementation of the FT5x06 touch controller with esp_lcd_touch component. + +| Touch controller | Communication interface | Component name | Link to datasheet | +| :--------------: | :---------------------: | :------------: | :---------------: | +| FT5x06 | I2C (SPI [^1]) | esp_lcd_touch_ft5x06 | [PDF](https://www.displayfuture.com/Display/datasheet/controller/FT5x06.pdf) | + +[^1]: **NOTE:** This controller should work via I2C or SPI communication interface. But it was tested on HW only via I2C communication interface. + +## Add to project + +Packages from this repository are uploaded to [Espressif's component service](https://components.espressif.com/). +You can add them to your project via `idf.py add-dependancy`, e.g. +``` + idf.py add-dependency esp_lcd_touch_ft5x06==1.0.0 +``` + +Alternatively, you can create `idf_component.yml`. More is in [Espressif's documentation](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/tools/idf-component-manager.html). + +## Example use + +I2C initialization of the touch component. + +``` + esp_lcd_panel_io_i2c_config_t io_config = ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG(); + + esp_lcd_touch_config_t tp_cfg = { + .x_max = CONFIG_LCD_HRES, + .y_max = CONFIG_LCD_VRES, + .rst_gpio_num = -1, + .int_gpio_num = -1, + .levels = { + .reset = 0, + .interrupt = 0, + }, + .flags = { + .swap_xy = 0, + .mirror_x = 0, + .mirror_y = 0, + }, + }; + + esp_lcd_touch_handle_t tp; + esp_lcd_touch_new_i2c_ft5x06(io_handle, &tp_cfg, &tp); +``` + +Read data from the touch controller and store it in RAM memory. It should be called regularly in poll. + +``` + esp_lcd_touch_read_data(tp); +``` + +Get one X and Y coordinates with strength of touch. + +``` + uint16_t touch_x[1]; + uint16_t touch_y[1]; + uint16_t touch_strength[1]; + uint8_t touch_cnt = 0; + + bool touchpad_pressed = esp_lcd_touch_get_coordinates(tp, touch_x, touch_y, touch_strength, &touch_cnt, 1); +``` diff --git a/managed_components/espressif__esp_lcd_touch_ft5x06/esp_lcd_touch_ft5x06.c b/managed_components/espressif__esp_lcd_touch_ft5x06/esp_lcd_touch_ft5x06.c new file mode 100644 index 0000000..ff10a5d --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch_ft5x06/esp_lcd_touch_ft5x06.c @@ -0,0 +1,329 @@ +/* + * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "esp_system.h" +#include "esp_err.h" +#include "esp_log.h" +#include "esp_check.h" +#include "driver/gpio.h" +#include "esp_lcd_panel_io.h" +#include "esp_lcd_touch.h" + +static const char *TAG = "FT5x06"; + +/* Registers */ +#define FT5x06_DEVICE_MODE (0x00) +#define FT5x06_GESTURE_ID (0x01) +#define FT5x06_TOUCH_POINTS (0x02) + +#define FT5x06_TOUCH1_EV_FLAG (0x03) +#define FT5x06_TOUCH1_XH (0x03) +#define FT5x06_TOUCH1_XL (0x04) +#define FT5x06_TOUCH1_YH (0x05) +#define FT5x06_TOUCH1_YL (0x06) + +#define FT5x06_TOUCH2_EV_FLAG (0x09) +#define FT5x06_TOUCH2_XH (0x09) +#define FT5x06_TOUCH2_XL (0x0A) +#define FT5x06_TOUCH2_YH (0x0B) +#define FT5x06_TOUCH2_YL (0x0C) + +#define FT5x06_TOUCH3_EV_FLAG (0x0F) +#define FT5x06_TOUCH3_XH (0x0F) +#define FT5x06_TOUCH3_XL (0x10) +#define FT5x06_TOUCH3_YH (0x11) +#define FT5x06_TOUCH3_YL (0x12) + +#define FT5x06_TOUCH4_EV_FLAG (0x15) +#define FT5x06_TOUCH4_XH (0x15) +#define FT5x06_TOUCH4_XL (0x16) +#define FT5x06_TOUCH4_YH (0x17) +#define FT5x06_TOUCH4_YL (0x18) + +#define FT5x06_TOUCH5_EV_FLAG (0x1B) +#define FT5x06_TOUCH5_XH (0x1B) +#define FT5x06_TOUCH5_XL (0x1C) +#define FT5x06_TOUCH5_YH (0x1D) +#define FT5x06_TOUCH5_YL (0x1E) + +#define FT5x06_ID_G_THGROUP (0x80) +#define FT5x06_ID_G_THPEAK (0x81) +#define FT5x06_ID_G_THCAL (0x82) +#define FT5x06_ID_G_THWATER (0x83) +#define FT5x06_ID_G_THTEMP (0x84) +#define FT5x06_ID_G_THDIFF (0x85) +#define FT5x06_ID_G_CTRL (0x86) +#define FT5x06_ID_G_TIME_ENTER_MONITOR (0x87) +#define FT5x06_ID_G_PERIODACTIVE (0x88) +#define FT5x06_ID_G_PERIODMONITOR (0x89) +#define FT5x06_ID_G_AUTO_CLB_MODE (0xA0) +#define FT5x06_ID_G_LIB_VERSION_H (0xA1) +#define FT5x06_ID_G_LIB_VERSION_L (0xA2) +#define FT5x06_ID_G_CIPHER (0xA3) +#define FT5x06_ID_G_MODE (0xA4) +#define FT5x06_ID_G_PMODE (0xA5) +#define FT5x06_ID_G_FIRMID (0xA6) +#define FT5x06_ID_G_STATE (0xA7) +#define FT5x06_ID_G_FT5201ID (0xA8) +#define FT5x06_ID_G_ERR (0xA9) + +/******************************************************************************* +* Function definitions +*******************************************************************************/ +static esp_err_t esp_lcd_touch_ft5x06_read_data(esp_lcd_touch_handle_t tp); +static bool esp_lcd_touch_ft5x06_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 esp_lcd_touch_ft5x06_del(esp_lcd_touch_handle_t tp); + +/* I2C read */ +static esp_err_t touch_ft5x06_i2c_write(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t data); +static esp_err_t touch_ft5x06_i2c_read(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t *data, uint8_t len); + +/* FT5x06 init */ +static esp_err_t touch_ft5x06_init(esp_lcd_touch_handle_t tp); +/* FT5x06 reset */ +static esp_err_t touch_ft5x06_reset(esp_lcd_touch_handle_t tp); + +/******************************************************************************* +* Public API functions +*******************************************************************************/ + +esp_err_t esp_lcd_touch_new_i2c_ft5x06(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *out_touch) +{ + esp_err_t ret = ESP_OK; + + assert(config != NULL); + assert(out_touch != NULL); + + /* Prepare main structure */ + esp_lcd_touch_handle_t esp_lcd_touch_ft5x06 = heap_caps_calloc(1, sizeof(esp_lcd_touch_t), MALLOC_CAP_DEFAULT); + ESP_GOTO_ON_FALSE(esp_lcd_touch_ft5x06, ESP_ERR_NO_MEM, err, TAG, "no mem for FT5x06 controller"); + + /* Communication interface */ + esp_lcd_touch_ft5x06->io = io; + + /* Only supported callbacks are set */ + esp_lcd_touch_ft5x06->read_data = esp_lcd_touch_ft5x06_read_data; + esp_lcd_touch_ft5x06->get_xy = esp_lcd_touch_ft5x06_get_xy; + esp_lcd_touch_ft5x06->del = esp_lcd_touch_ft5x06_del; + + /* Mutex */ + esp_lcd_touch_ft5x06->data.lock.owner = portMUX_FREE_VAL; + + /* Save config */ + memcpy(&esp_lcd_touch_ft5x06->config, config, sizeof(esp_lcd_touch_config_t)); + + /* Prepare pin for touch interrupt */ + if (esp_lcd_touch_ft5x06->config.int_gpio_num != GPIO_NUM_NC) { + const gpio_config_t int_gpio_config = { + .mode = GPIO_MODE_INPUT, + .intr_type = (esp_lcd_touch_ft5x06->config.levels.interrupt ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE), + .pin_bit_mask = BIT64(esp_lcd_touch_ft5x06->config.int_gpio_num) + }; + ret = gpio_config(&int_gpio_config); + ESP_GOTO_ON_ERROR(ret, err, TAG, "GPIO config failed"); + + /* Register interrupt callback */ + if (esp_lcd_touch_ft5x06->config.interrupt_callback) { + esp_lcd_touch_register_interrupt_callback(esp_lcd_touch_ft5x06, esp_lcd_touch_ft5x06->config.interrupt_callback); + } + } + + /* Prepare pin for touch controller reset */ + if (esp_lcd_touch_ft5x06->config.rst_gpio_num != GPIO_NUM_NC) { + const gpio_config_t rst_gpio_config = { + .mode = GPIO_MODE_OUTPUT, + .pin_bit_mask = BIT64(esp_lcd_touch_ft5x06->config.rst_gpio_num) + }; + ret = gpio_config(&rst_gpio_config); + ESP_GOTO_ON_ERROR(ret, err, TAG, "GPIO config failed"); + } + + /* Reset controller */ + ret = touch_ft5x06_reset(esp_lcd_touch_ft5x06); + ESP_GOTO_ON_ERROR(ret, err, TAG, "FT5x06 reset failed"); + + /* Init controller */ + ret = touch_ft5x06_init(esp_lcd_touch_ft5x06); + ESP_GOTO_ON_ERROR(ret, err, TAG, "FT5x06 init failed"); + + *out_touch = esp_lcd_touch_ft5x06; + +err: + if (ret != ESP_OK) { + ESP_LOGE(TAG, "Error (0x%x)! Touch controller FT5x06 initialization failed!", ret); + if (esp_lcd_touch_ft5x06) { + esp_lcd_touch_ft5x06_del(esp_lcd_touch_ft5x06); + } + } + + return ret; +} + +static esp_err_t esp_lcd_touch_ft5x06_read_data(esp_lcd_touch_handle_t tp) +{ + esp_err_t err; + uint8_t data[30]; + uint8_t points; + size_t i = 0; + + assert(tp != NULL); + + err = touch_ft5x06_i2c_read(tp, FT5x06_TOUCH_POINTS, &points, 1); + ESP_RETURN_ON_ERROR(err, TAG, "I2C read error!"); + + if (points > 5 || points == 0) { + return ESP_OK; + } + + /* Number of touched points */ + points = (points > CONFIG_ESP_LCD_TOUCH_MAX_POINTS ? CONFIG_ESP_LCD_TOUCH_MAX_POINTS : points); + + err = touch_ft5x06_i2c_read(tp, FT5x06_TOUCH1_XH, data, 6 * points); + ESP_RETURN_ON_ERROR(err, TAG, "I2C read error!"); + + portENTER_CRITICAL(&tp->data.lock); + + /* Number of touched points */ + tp->data.points = points; + + /* Fill all coordinates */ + for (i = 0; i < points; i++) { + tp->data.coords[i].x = (((uint16_t)data[(i * 6) + 0] & 0x0f) << 8) + data[(i * 6) + 1]; + tp->data.coords[i].y = (((uint16_t)data[(i * 6) + 2] & 0x0f) << 8) + data[(i * 6) + 3]; + } + + portEXIT_CRITICAL(&tp->data.lock); + + return ESP_OK; +} + +static bool esp_lcd_touch_ft5x06_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) +{ + assert(tp != NULL); + assert(x != NULL); + assert(y != NULL); + assert(point_num != NULL); + assert(max_point_num > 0); + + 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 esp_lcd_touch_ft5x06_del(esp_lcd_touch_handle_t tp) +{ + assert(tp != NULL); + + /* 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); + } + } + + /* Reset GPIO pin settings */ + if (tp->config.rst_gpio_num != GPIO_NUM_NC) { + gpio_reset_pin(tp->config.rst_gpio_num); + } + + free(tp); + + return ESP_OK; +} + +/******************************************************************************* +* Private API function +*******************************************************************************/ + +static esp_err_t touch_ft5x06_init(esp_lcd_touch_handle_t tp) +{ + esp_err_t ret = ESP_OK; + + // Valid touching detect threshold + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_THGROUP, 70); + + // valid touching peak detect threshold + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_THPEAK, 60); + + // Touch focus threshold + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_THCAL, 16); + + // threshold when there is surface water + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_THWATER, 60); + + // threshold of temperature compensation + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_THTEMP, 10); + + // Touch difference threshold + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_THDIFF, 20); + + // Delay to enter 'Monitor' status (s) + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_TIME_ENTER_MONITOR, 2); + + // Period of 'Active' status (ms) + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_PERIODACTIVE, 12); + + // Timer to enter 'idle' when in 'Monitor' (ms) + ret |= touch_ft5x06_i2c_write(tp, FT5x06_ID_G_PERIODMONITOR, 40); + + return ret; +} + +/* Reset controller */ +static esp_err_t touch_ft5x06_reset(esp_lcd_touch_handle_t tp) +{ + assert(tp != NULL); + + if (tp->config.rst_gpio_num != GPIO_NUM_NC) { + ESP_RETURN_ON_ERROR(gpio_set_level(tp->config.rst_gpio_num, tp->config.levels.reset), TAG, "GPIO set level error!"); + vTaskDelay(pdMS_TO_TICKS(10)); + ESP_RETURN_ON_ERROR(gpio_set_level(tp->config.rst_gpio_num, !tp->config.levels.reset), TAG, "GPIO set level error!"); + vTaskDelay(pdMS_TO_TICKS(10)); + } + + return ESP_OK; +} + +static esp_err_t touch_ft5x06_i2c_write(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t data) +{ + assert(tp != NULL); + + // *INDENT-OFF* + /* Write data */ + return esp_lcd_panel_io_tx_param(tp->io, reg, (uint8_t[]){data}, 1); + // *INDENT-ON* +} + +static esp_err_t touch_ft5x06_i2c_read(esp_lcd_touch_handle_t tp, uint8_t reg, uint8_t *data, uint8_t len) +{ + assert(tp != NULL); + assert(data != NULL); + + /* Read data */ + return esp_lcd_panel_io_rx_param(tp->io, reg, data, len); +} diff --git a/managed_components/espressif__esp_lcd_touch_ft5x06/idf_component.yml b/managed_components/espressif__esp_lcd_touch_ft5x06/idf_component.yml new file mode 100644 index 0000000..ae3b203 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch_ft5x06/idf_component.yml @@ -0,0 +1,12 @@ +dependencies: + esp_lcd_touch: + public: true + version: ^1.0.4 + idf: '>=4.4.2' +description: ESP LCD Touch FT5x06 - touch controller FT5x06 +repository: git://github.com/espressif/esp-bsp.git +repository_info: + commit_sha: e5daac9acdfecafa1f56bc64b670543cb4d76d94 + path: components/lcd_touch/esp_lcd_touch_ft5x06 +url: https://github.com/espressif/esp-bsp/tree/master/components/lcd_touch/esp_lcd_touch_ft5x06 +version: 1.0.7 diff --git a/managed_components/espressif__esp_lcd_touch_ft5x06/include/esp_lcd_touch_ft5x06.h b/managed_components/espressif__esp_lcd_touch_ft5x06/include/esp_lcd_touch_ft5x06.h new file mode 100644 index 0000000..e10bbd8 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch_ft5x06/include/esp_lcd_touch_ft5x06.h @@ -0,0 +1,59 @@ +/* + * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @file + * @brief ESP LCD touch: FT5x06 + */ + +#pragma once + +#include "esp_lcd_touch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Create a new FT5x06 touch driver + * + * @note The I2C communication should be initialized before use this function. + * + * @param io LCD/Touch panel IO handle + * @param config: Touch configuration + * @param out_touch: Touch instance handle + * @return + * - ESP_OK on success + * - ESP_ERR_NO_MEM if there is no memory for allocating main structure + */ +esp_err_t esp_lcd_touch_new_i2c_ft5x06(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *out_touch); + +/** + * @brief I2C address of the FT5x06 controller + * + */ +#define ESP_LCD_TOUCH_IO_I2C_FT5x06_ADDRESS (0x38) + +/** + * @brief Touch IO configuration structure + * + */ +#define ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG() \ + { \ + .dev_addr = ESP_LCD_TOUCH_IO_I2C_FT5x06_ADDRESS, \ + .control_phase_bytes = 1, \ + .dc_bit_offset = 0, \ + .lcd_cmd_bits = 8, \ + .flags = \ + { \ + .disable_control_phase = 1, \ + } \ + } + + +#ifdef __cplusplus +} +#endif diff --git a/managed_components/espressif__esp_lcd_touch_ft5x06/license.txt b/managed_components/espressif__esp_lcd_touch_ft5x06/license.txt new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/managed_components/espressif__esp_lcd_touch_ft5x06/license.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/sdkconfig b/sdkconfig index e77ac9a..d08d68f 100644 --- a/sdkconfig +++ b/sdkconfig @@ -2067,6 +2067,13 @@ CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y # CONFIG_WIFI_PROV_STA_FAST_SCAN is not set # end of Wi-Fi Provisioning Manager +# +# ESP LCD TOUCH +# +CONFIG_ESP_LCD_TOUCH_MAX_POINTS=5 +CONFIG_ESP_LCD_TOUCH_MAX_BUTTONS=1 +# end of ESP LCD TOUCH + # # LVGL configuration #