initial commit

managed_components/espressif__esp_lcd_touch/.component_hash

@@ -0,0 +1 @@
+779b4ba2464a3ae85681e4b860caa5fdc35801458c23f3039ee761bae7f442a4

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")

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

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
+

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 <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;
+}
+
+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);
+}

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

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 <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
+
+/**
+ * @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

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.