zhengxin/P4-USB-transfer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

初始提交卡包 USB 工程

Browse Source 
纳入固件源码、屏幕组件、nand_xfer 工具和文档。忽略本机构建产物、sdkconfig，以及含本机路径的依赖锁。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
zhengxin
2026-10-13 21:54:50 +08:00
co-authored by Cursor
commit 851e347cf5
260 changed files with 269349 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/esp_lcd_qspi_amoled/CMakeLists.txt
+7
View File
@@ -0,0 +1,7 @@
idf_component_register(SRCS "esp_lcd_qspi_amoled.c" INCLUDE_DIRS "include" PRIV_REQUIRES "driver" REQUIRES "esp_lcd")
include(package_manager)
cu_pkg_define_version(${CMAKE_CURRENT_LIST_DIR})
components/esp_lcd_qspi_amoled/esp_lcd_qspi_amoled.c
+357
View File
@@ -0,0 +1,357 @@
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include <sys/cdefs.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_check.h"
#include "esp_lcd_panel_interface.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_commands.h"
#include "esp_log.h"
#include "esp_lcd_qspi_amoled.h"
#define LCD_OPCODE_WRITE_CMD (0x02ULL)
#define LCD_OPCODE_READ_CMD (0x03ULL)
#define LCD_OPCODE_WRITE_COLOR (0x32ULL)
static const char *TAG = "qspi_amoled";
static esp_err_t panel_qspi_amoled_del(esp_lcd_panel_t *panel);
static esp_err_t panel_qspi_amoled_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_qspi_amoled_init(esp_lcd_panel_t *panel);
esp_err_t panel_qspi_amoled_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data);
static esp_err_t panel_qspi_amoled_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_qspi_amoled_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_qspi_amoled_swap_xy(esp_lcd_panel_t *panel, bool swap_axes);
static esp_err_t panel_qspi_amoled_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap);
static esp_err_t panel_qspi_amoled_disp_on_off(esp_lcd_panel_t *panel, bool off);
typedef struct {
esp_lcd_panel_t base;
esp_lcd_panel_io_handle_t io;
int reset_gpio_num;
int x_gap;
int y_gap;
uint8_t fb_bits_per_pixel;
uint8_t madctl_val; // save current value of LCD_CMD_MADCTL register
uint8_t colmod_val; // save surrent value of LCD_CMD_COLMOD register
const qspi_amoled_lcd_init_cmd_t *init_cmds;
uint16_t init_cmds_size;
struct {
unsigned int use_qspi_interface: 1;
unsigned int reset_level: 1;
} flags;
} qspi_amoled_panel_t;
esp_err_t esp_lcd_new_panel_qspi_amoled(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel)
{
ESP_RETURN_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
esp_err_t ret = ESP_OK;
qspi_amoled_panel_t *qspi_amoled = NULL;
qspi_amoled = calloc(1, sizeof(qspi_amoled_panel_t));
ESP_GOTO_ON_FALSE(qspi_amoled, ESP_ERR_NO_MEM, err, TAG, "no mem for qspi_amoled panel");
if (panel_dev_config->reset_gpio_num >= 0) {
gpio_config_t io_conf = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num,
};
ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed");
}
switch (panel_dev_config->rgb_ele_order) {
case LCD_RGB_ELEMENT_ORDER_RGB:
qspi_amoled->madctl_val = 0;
break;
case LCD_RGB_ELEMENT_ORDER_BGR:
qspi_amoled->madctl_val |= LCD_CMD_BGR_BIT;
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported color element order");
break;
}
uint8_t fb_bits_per_pixel = 0;
switch (panel_dev_config->bits_per_pixel) {
case 16: // RGB565
qspi_amoled->colmod_val = 0x55;
fb_bits_per_pixel = 16;
break;
case 18: // RGB666
qspi_amoled->colmod_val = 0x66;
// each color component (R/G/B) should occupy the 6 high bits of a byte, which means 3 full bytes are required for a pixel
fb_bits_per_pixel = 18;
break;
case 24: // RGB888
qspi_amoled->colmod_val = 0x77;
fb_bits_per_pixel = 24;
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_NOT_SUPPORTED, err, TAG, "unsupported pixel width");
break;
}
qspi_amoled->io = io;
qspi_amoled->reset_gpio_num = panel_dev_config->reset_gpio_num;
qspi_amoled->fb_bits_per_pixel = fb_bits_per_pixel;
qspi_amoled_vendor_config_t *vendor_config = (qspi_amoled_vendor_config_t *)panel_dev_config->vendor_config;
if (vendor_config) {
qspi_amoled->init_cmds = vendor_config->init_cmds;
qspi_amoled->init_cmds_size = vendor_config->init_cmds_size;
qspi_amoled->flags.use_qspi_interface = vendor_config->flags.use_qspi_interface;
}
qspi_amoled->flags.reset_level = panel_dev_config->flags.reset_active_high;
qspi_amoled->base.del = panel_qspi_amoled_del;
qspi_amoled->base.reset = panel_qspi_amoled_reset;
qspi_amoled->base.init = panel_qspi_amoled_init;
qspi_amoled->base.draw_bitmap = panel_qspi_amoled_draw_bitmap;
qspi_amoled->base.invert_color = panel_qspi_amoled_invert_color;
qspi_amoled->base.set_gap = panel_qspi_amoled_set_gap;
qspi_amoled->base.mirror = panel_qspi_amoled_mirror;
qspi_amoled->base.swap_xy = panel_qspi_amoled_swap_xy;
qspi_amoled->base.disp_on_off = panel_qspi_amoled_disp_on_off;
*ret_panel = &(qspi_amoled->base);
ESP_LOGD(TAG, "new qspi_amoled panel @%p", qspi_amoled);
ESP_LOGI(TAG, "LCD panel create success, version: %d.%d.%d", ESP_LCD_QSPI_AMOLED_VER_MAJOR, ESP_LCD_QSPI_AMOLED_VER_MINOR,
ESP_LCD_QSPI_AMOLED_VER_PATCH);
return ESP_OK;
err:
if (qspi_amoled) {
if (panel_dev_config->reset_gpio_num >= 0) {
gpio_reset_pin(panel_dev_config->reset_gpio_num);
}
free(qspi_amoled);
}
return ret;
}
static esp_err_t tx_param(qspi_amoled_panel_t *qspi_amoled, esp_lcd_panel_io_handle_t io, int lcd_cmd, const void *param, size_t param_size)
{
if (qspi_amoled->flags.use_qspi_interface) {
lcd_cmd &= 0xff;
lcd_cmd <<= 8;
lcd_cmd |= LCD_OPCODE_WRITE_CMD << 24;
}
return esp_lcd_panel_io_tx_param(io, lcd_cmd, param, param_size);
}
static esp_err_t tx_color(qspi_amoled_panel_t *qspi_amoled, esp_lcd_panel_io_handle_t io, int lcd_cmd, const void *param, size_t param_size)
{
if (qspi_amoled->flags.use_qspi_interface) {
lcd_cmd &= 0xff;
lcd_cmd <<= 8;
lcd_cmd |= LCD_OPCODE_WRITE_COLOR << 24;
}
return esp_lcd_panel_io_tx_color(io, lcd_cmd, param, param_size);
}
static esp_err_t panel_qspi_amoled_del(esp_lcd_panel_t *panel)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
if (qspi_amoled->reset_gpio_num >= 0) {
gpio_reset_pin(qspi_amoled->reset_gpio_num);
}
ESP_LOGD(TAG, "del qspi_amoled panel @%p", qspi_amoled);
free(qspi_amoled);
return ESP_OK;
}
static esp_err_t panel_qspi_amoled_reset(esp_lcd_panel_t *panel)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
esp_lcd_panel_io_handle_t io = qspi_amoled->io;
// Perform hardware reset
if (qspi_amoled->reset_gpio_num >= 0) {
gpio_set_level(qspi_amoled->reset_gpio_num, qspi_amoled->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
gpio_set_level(qspi_amoled->reset_gpio_num, !qspi_amoled->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(150));
} else { // Perform software reset
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, LCD_CMD_SWRESET, NULL, 0), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(80));
}
return ESP_OK;
}
static const qspi_amoled_lcd_init_cmd_t vendor_specific_init_default[] = {
// {cmd, { data }, data_size, delay_ms}
{0x44, (uint8_t []){0x01, 0xD1}, 2, 0},
{0x35, (uint8_t []){0x00}, 0, 0},
{0x53, (uint8_t []){0x20}, 1, 25},
};
static esp_err_t panel_qspi_amoled_init(esp_lcd_panel_t *panel)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
esp_lcd_panel_io_handle_t io = qspi_amoled->io;
const qspi_amoled_lcd_init_cmd_t *init_cmds = NULL;
uint16_t init_cmds_size = 0;
bool is_cmd_overwritten = false;
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, LCD_CMD_MADCTL, (uint8_t[]) {
qspi_amoled->madctl_val,
}, 1), TAG, "send command failed");
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, LCD_CMD_COLMOD, (uint8_t[]) {
qspi_amoled->colmod_val,
}, 1), TAG, "send command failed");
// vendor specific initialization, it can be different between manufacturers
// should consult the LCD supplier for initialization sequence code
if (qspi_amoled->init_cmds) {
init_cmds = qspi_amoled->init_cmds;
init_cmds_size = qspi_amoled->init_cmds_size;
} else {
init_cmds = vendor_specific_init_default;
init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(qspi_amoled_lcd_init_cmd_t);
}
for (int i = 0; i < init_cmds_size; i++) {
// Check if the command has been used or conflicts with the internal
switch (init_cmds[i].cmd) {
case LCD_CMD_MADCTL:
is_cmd_overwritten = true;
qspi_amoled->madctl_val = ((uint8_t *)init_cmds[i].data)[0];
break;
case LCD_CMD_COLMOD:
is_cmd_overwritten = true;
qspi_amoled->colmod_val = ((uint8_t *)init_cmds[i].data)[0];
break;
default:
is_cmd_overwritten = false;
break;
}
if (is_cmd_overwritten) {
ESP_LOGW(TAG, "The %02Xh command has been used and will be overwritten by external initialization sequence", init_cmds[i].cmd);
}
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, init_cmds[i].cmd, init_cmds[i].data, init_cmds[i].data_bytes), TAG,
"send command failed");
vTaskDelay(pdMS_TO_TICKS(init_cmds[i].delay_ms));
}
ESP_LOGD(TAG, "send init commands success");
return ESP_OK;
}
esp_err_t panel_qspi_amoled_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
assert((x_start < x_end) && (y_start < y_end) && "start position must be smaller than end position");
esp_lcd_panel_io_handle_t io = qspi_amoled->io;
x_start += qspi_amoled->x_gap;
x_end += qspi_amoled->x_gap;
y_start += qspi_amoled->y_gap;
y_end += qspi_amoled->y_gap;
// define an area of frame memory where MCU can access
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, LCD_CMD_CASET, (uint8_t[]) {
(x_start >> 8) & 0xFF,
x_start & 0xFF,
((x_end - 1) >> 8) & 0xFF,
(x_end - 1) & 0xFF,
}, 4), TAG, "send command failed");
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, LCD_CMD_RASET, (uint8_t[]) {
(y_start >> 8) & 0xFF,
y_start & 0xFF,
((y_end - 1) >> 8) & 0xFF,
(y_end - 1) & 0xFF,
}, 4), TAG, "send command failed");
// transfer frame buffer
size_t len = (x_end - x_start) * (y_end - y_start) * qspi_amoled->fb_bits_per_pixel / 8;
ESP_RETURN_ON_ERROR(tx_color(qspi_amoled, io, LCD_CMD_RAMWR, color_data, len), TAG, "send color data failed");
return ESP_OK;
}
static esp_err_t panel_qspi_amoled_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
esp_lcd_panel_io_handle_t io = qspi_amoled->io;
int command = 0;
if (invert_color_data) {
command = LCD_CMD_INVON;
} else {
command = LCD_CMD_INVOFF;
}
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
esp_err_t panel_qspi_amoled_set_brightness(esp_lcd_panel_t *panel, uint8_t brightness)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
esp_lcd_panel_io_handle_t io = qspi_amoled->io;
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, LCD_CMD_WRDISBV, (uint8_t[]) {
brightness
}, 1), TAG, "send command failed");
return ESP_OK;
}
static esp_err_t panel_qspi_amoled_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
esp_lcd_panel_io_handle_t io = qspi_amoled->io;
esp_err_t ret = ESP_OK;
if (mirror_x) {
qspi_amoled->madctl_val |= BIT(6);
} else {
qspi_amoled->madctl_val &= ~BIT(6);
}
if (mirror_y) {
ESP_LOGE(TAG, "mirror_y is not supported by this panel");
ret = ESP_ERR_NOT_SUPPORTED;
}
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, LCD_CMD_MADCTL, (uint8_t[]) {
qspi_amoled->madctl_val
}, 1), TAG, "send command failed");
return ret;
}
static esp_err_t panel_qspi_amoled_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
{
ESP_LOGE(TAG, "swap_xy is not supported by this panel");
return ESP_ERR_NOT_SUPPORTED;
}
static esp_err_t panel_qspi_amoled_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
qspi_amoled->x_gap = x_gap;
qspi_amoled->y_gap = y_gap;
return ESP_OK;
}
static esp_err_t panel_qspi_amoled_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
{
qspi_amoled_panel_t *qspi_amoled = __containerof(panel, qspi_amoled_panel_t, base);
esp_lcd_panel_io_handle_t io = qspi_amoled->io;
int command = 0;
if (on_off) {
command = LCD_CMD_DISPON;
} else {
command = LCD_CMD_DISPOFF;
}
ESP_RETURN_ON_ERROR(tx_param(qspi_amoled, io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
components/esp_lcd_qspi_amoled/idf_component.yml
+10
View File
@@ -0,0 +1,10 @@
dependencies:
cmake_utilities:
version: 0.*
idf:
version: '>5.0.4,!=5.1.1'
description: ESP LCD QSPI_AMOLED
issues: https://github.com/espressif/esp-iot-solution/issues
repository: https://github.com/espressif/esp-iot-solution.git
url: https://github.com/espressif/esp-iot-solution/tree/master/components/display/lcd/esp_lcd_qspi_amoled
version: 1.0.0
components/esp_lcd_qspi_amoled/include/esp_lcd_qspi_amoled.h
+117
View File
@@ -0,0 +1,117 @@
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include <stdint.h>
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_interface.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief LCD panel initialization commands.
*
*/
typedef struct {
int cmd; /*<! The specific LCD command */
const void *data; /*<! Buffer that holds the command specific data */
size_t data_bytes; /*<! Size of `data` in memory, in bytes */
unsigned int delay_ms; /*<! Delay in milliseconds after this command */
} qspi_amoled_lcd_init_cmd_t;
/**
* @brief LCD panel vendor configuration.
*
* @note This structure can be used to select interface type and override default initialization commands.
* @note This structure needs to be passed to the `vendor_config` field in `esp_lcd_panel_dev_config_t`.
*
*/
typedef struct {
const qspi_amoled_lcd_init_cmd_t *init_cmds; /*!< Pointer to initialization commands array.
* The array should be declared as `static const` and positioned outside the function.
* Please refer to `vendor_specific_init_default` in source file
*/
uint16_t init_cmds_size; /*<! Number of commands in above array */
struct {
unsigned int use_qspi_interface: 1; /*<! Set to 1 if use QSPI interface, default is SPI interface */
} flags;
} qspi_amoled_vendor_config_t;
/**
* @brief Create LCD panel for model QSPI_AMOLED
*
* @param[in] io LCD panel IO handle
* @param[in] panel_dev_config General panel device configuration (Use `vendor_config` to select QSPI interface or override default initialization commands)
* @param[out] ret_panel Returned LCD panel handle
* @return
* - ESP_OK: Success
* - Otherwise: Fail
*/
esp_err_t esp_lcd_new_panel_qspi_amoled(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel);
esp_err_t panel_qspi_amoled_set_brightness(esp_lcd_panel_t *panel, uint8_t brightness);
esp_err_t panel_qspi_amoled_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data);
/**
* @brief LCD panel bus configuration structure
*
*/
#define QSPI_AMOLED_PANEL_BUS_SPI_CONFIG(sclk, mosi, max_trans_sz) \
{ \
.sclk_io_num = sclk, \
.mosi_io_num = mosi, \
.miso_io_num = -1, \
.quadhd_io_num = -1, \
.quadwp_io_num = -1, \
.max_transfer_sz = max_trans_sz, \
}
#define QSPI_AMOLED_PANEL_BUS_QSPI_CONFIG(sclk, d0, d1, d2, d3, max_trans_sz) \
{ \
.sclk_io_num = sclk, \
.data0_io_num = d0, \
.data1_io_num = d1, \
.data2_io_num = d2, \
.data3_io_num = d3, \
.max_transfer_sz = max_trans_sz, \
}
/**
* @brief LCD panel IO configuration structure
*
*/
#define QSPI_AMOLED_PANEL_IO_SPI_CONFIG(cs, dc, cb, cb_ctx) \
{ \
.cs_gpio_num = cs, \
.dc_gpio_num = dc, \
.spi_mode = 0, \
.pclk_hz = 40 * 1000 * 1000, \
.trans_queue_depth = 10, \
.on_color_trans_done = cb, \
.user_ctx = cb_ctx, \
.lcd_cmd_bits = 8, \
.lcd_param_bits = 8, \
}
#define QSPI_AMOLED_PANEL_IO_QSPI_CONFIG(cs, cb, cb_ctx) \
{ \
.cs_gpio_num = cs, \
.dc_gpio_num = -1, \
.spi_mode = 0, \
.pclk_hz = 80 * 1000 * 1000, \
.trans_queue_depth = 10, \
.on_color_trans_done = cb, \
.user_ctx = cb_ctx, \
.lcd_cmd_bits = 32, \
.lcd_param_bits = 8, \
.flags = { \
.quad_mode = true, \
}, \
}
#ifdef __cplusplus
}
#endif
components/esp_lcd_touch_chsc6417/CMakeLists.txt
+1
View File
@@ -0,0 +1 @@
idf_component_register(SRCS "esp_lcd_touch_chsc6417.c" INCLUDE_DIRS "include" REQUIRES "esp_lcd_touch")
components/esp_lcd_touch_chsc6417/esp_lcd_touch_chsc6417.c
+228
View File
@@ -0,0 +1,228 @@
/*
* SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_system.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_check.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_touch.h"
#include "esp_lcd_touch_chsc6417.h"
#define POINT_NUM_MAX (1)
#define DATA_START_REG (0x00)
#define CHIP_ID_REG (0xA7)
static const char *TAG = "CHSC6417";
static esp_err_t read_data(esp_lcd_touch_handle_t tp);
static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
static esp_err_t del(esp_lcd_touch_handle_t tp);
static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len);
static esp_err_t reset(esp_lcd_touch_handle_t tp);
static esp_err_t read_id(esp_lcd_touch_handle_t tp);
esp_err_t esp_lcd_touch_new_i2c_chsc6417(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp)
{
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_ARG, TAG, "Invalid io");
ESP_RETURN_ON_FALSE(config, ESP_ERR_INVALID_ARG, TAG, "Invalid config");
ESP_RETURN_ON_FALSE(tp, ESP_ERR_INVALID_ARG, TAG, "Invalid touch handle");
/* Prepare main structure */
esp_err_t ret = ESP_OK;
esp_lcd_touch_handle_t chsc6417 = calloc(1, sizeof(esp_lcd_touch_t));
ESP_GOTO_ON_FALSE(chsc6417, ESP_ERR_NO_MEM, err, TAG, "Touch handle malloc failed");
/* Communication interface */
chsc6417->io = io;
/* Only supported callbacks are set */
chsc6417->read_data = read_data;
chsc6417->get_xy = get_xy;
chsc6417->del = del;
/* Mutex */
chsc6417->data.lock.owner = portMUX_FREE_VAL;
/* Save config */
memcpy(&chsc6417->config, config, sizeof(esp_lcd_touch_config_t));
/* Prepare pin for touch interrupt */
if (chsc6417->config.int_gpio_num != GPIO_NUM_NC) {
const gpio_config_t int_gpio_config = {
.mode = GPIO_MODE_INPUT,
.intr_type = (chsc6417->config.levels.interrupt ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE),
.pin_bit_mask = BIT64(chsc6417->config.int_gpio_num)
};
ESP_GOTO_ON_ERROR(gpio_config(&int_gpio_config), err, TAG, "GPIO intr config failed");
/* Register interrupt callback */
if (chsc6417->config.interrupt_callback) {
esp_lcd_touch_register_interrupt_callback(chsc6417, chsc6417->config.interrupt_callback);
}
}
/* Prepare pin for touch controller reset */
if (chsc6417->config.rst_gpio_num != GPIO_NUM_NC) {
const gpio_config_t rst_gpio_config = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = BIT64(chsc6417->config.rst_gpio_num)
};
ESP_GOTO_ON_ERROR(gpio_config(&rst_gpio_config), err, TAG, "GPIO reset config failed");
}
/* Reset controller */
ESP_GOTO_ON_ERROR(reset(chsc6417), err, TAG, "Reset failed");
/* Read product id */
// ESP_GOTO_ON_ERROR(read_id(chsc6417), err, TAG, "Read version failed");
*tp = chsc6417;
ESP_LOGI(TAG, "LCD touch panel create success, version: %d.%d.%d", ESP_LCD_TOUCH_CHSC6417_VER_MAJOR, ESP_LCD_TOUCH_CHSC6417_VER_MINOR,
ESP_LCD_TOUCH_CHSC6417_VER_PATCH);
return ESP_OK;
err:
if (chsc6417) {
del(chsc6417);
}
ESP_LOGE(TAG, "Initialization failed!");
return ret;
}
static esp_err_t read_data(esp_lcd_touch_handle_t tp)
{
typedef struct {
uint8_t num;
uint8_t x_h : 4;
uint8_t : 4;
uint8_t x_l;
uint8_t y_h : 4;
uint8_t : 4;
uint8_t y_l;
} data_t;
data_t point;
uint8_t lvalue[3]={0};
// uint8_t gesture_id=0;
uint16_t x=0;
uint16_t y=0;
esp_err_t err = i2c_read_bytes(tp, 0xE0, (uint8_t *)lvalue, sizeof(lvalue));
// 断言
ESP_RETURN_ON_ERROR(err, TAG, "I2C read failed");
// 如果读取失败，将num置为0
if (err != ESP_OK) {
point.num = 0;
x = 0;
y = 0;
}else{
point.num = lvalue[0] & 0x03; // 获取触摸点数量
x = (uint16_t)((((lvalue[0] & 0x40) >> 6) << 8) | lvalue[1]);
y = (uint16_t)(((lvalue[0] & 0x80) >> 7) << 8) | lvalue[2];
}
// gesture_id = lvalue[0];
// ESP_LOGI(TAG, "Touch position: %d,%d,%d", point.num, x, y);
portENTER_CRITICAL(&tp->data.lock);
point.num = (point.num > POINT_NUM_MAX ? POINT_NUM_MAX : point.num);
tp->data.points = point.num;
/* Fill all coordinates */
for (int i = 0; i < point.num; i++) {
tp->data.coords[i].x = x;
tp->data.coords[i].y = y;
}
portEXIT_CRITICAL(&tp->data.lock);
return ESP_OK;
}
// void read_touch()
// {
// uint8_t data1[1]={0xE0};
// uint8_t lvalue[3];
// i2c_write(TOUCH_I2C_ADD,TOUCH_I2C_W,data1,1);
// delay(1);
// i2c_read(TOUCH_I2C_ADD,TOUCH_I2C_R,lvalue,3);
// point_num = lvalue[0] & 0x03;
// x = (uint16_t)((((lvalue[0] & 0x40) >> 6) << 8) | lvalue[1]);
// y = (uint16_t)(((lvalue[0] & 0x80) >> 7) << 8) | lvalue[2];
// }
static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num)
{
portENTER_CRITICAL(&tp->data.lock);
/* Count of points */
*point_num = (tp->data.points > max_point_num ? max_point_num : tp->data.points);
for (size_t i = 0; i < *point_num; i++) {
x[i] = tp->data.coords[i].x;
y[i] = tp->data.coords[i].y;
if (strength) {
strength[i] = tp->data.coords[i].strength;
}
}
/* Invalidate */
tp->data.points = 0;
portEXIT_CRITICAL(&tp->data.lock);
return (*point_num > 0);
}
static esp_err_t del(esp_lcd_touch_handle_t tp)
{
/* Reset GPIO pin settings */
if (tp->config.int_gpio_num != GPIO_NUM_NC) {
gpio_reset_pin(tp->config.int_gpio_num);
if (tp->config.interrupt_callback) {
gpio_isr_handler_remove(tp->config.int_gpio_num);
}
}
if (tp->config.rst_gpio_num != GPIO_NUM_NC) {
gpio_reset_pin(tp->config.rst_gpio_num);
}
/* Release memory */
free(tp);
return ESP_OK;
}
static esp_err_t reset(esp_lcd_touch_handle_t tp)
{
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 failed");
vTaskDelay(pdMS_TO_TICKS(200));
ESP_RETURN_ON_ERROR(gpio_set_level(tp->config.rst_gpio_num, !tp->config.levels.reset), TAG, "GPIO set level failed");
vTaskDelay(pdMS_TO_TICKS(200));
}
return ESP_OK;
}
static esp_err_t read_id(esp_lcd_touch_handle_t tp)
{
uint8_t id;
ESP_RETURN_ON_ERROR(i2c_read_bytes(tp, CHIP_ID_REG, &id, 1), TAG, "I2C read failed");
ESP_LOGI(TAG, "IC id: %d", id);
return ESP_OK;
}
static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len)
{
ESP_RETURN_ON_FALSE(data, ESP_ERR_INVALID_ARG, TAG, "Invalid data");
return esp_lcd_panel_io_rx_param(tp->io, reg, data, len);
}
components/esp_lcd_touch_chsc6417/include/esp_lcd_touch_chsc6417.h
+61
View File
@@ -0,0 +1,61 @@
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief ESP LCD touch: CHSC6417
*/
#pragma once
#include "esp_lcd_touch.h"
#ifdef __cplusplus
extern "C" {
#endif
#define ESP_LCD_TOUCH_CHSC6417_VER_MAJOR (1)
#define ESP_LCD_TOUCH_CHSC6417_VER_MINOR (0)
#define ESP_LCD_TOUCH_CHSC6417_VER_PATCH (3)
/**
* @brief Create a new CHSC6417 touch driver
*
* @note The I2C communication should be initialized before use this function.
*
* @param io LCD panel IO handle, it should be created by `esp_lcd_new_panel_io_i2c()`
* @param config Touch panel configuration
* @param tp Touch panel handle
* @return
* - ESP_OK: on success
*/
esp_err_t esp_lcd_touch_new_i2c_chsc6417(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp);
/**
* @brief I2C address of the CHSC6417 controller
*
*/
#define ESP_LCD_TOUCH_IO_I2C_CHSC6417_ADDRESS (0x2E) // CHSC6417
/**
* @brief Touch IO configuration structure
*
*/
#define ESP_LCD_TOUCH_IO_I2C_CHSC6417_CONFIG() \
{ \
.dev_addr = ESP_LCD_TOUCH_IO_I2C_CHSC6417_ADDRESS, \
.control_phase_bytes = 1, \
.dc_bit_offset = 0, \
.lcd_cmd_bits = 8, \
.flags = \
{ \
.disable_control_phase = 1, \
} \
}
#ifdef __cplusplus
}
#endif
components/esp_lcd_touch_cst816/CMakeLists.txt
+1
View File
@@ -0,0 +1 @@
idf_component_register(SRCS "esp_lcd_touch_cst816.c" INCLUDE_DIRS "include" REQUIRES "esp_lcd_touch")
components/esp_lcd_touch_cst816/esp_lcd_touch_cst816.c
+201
View File
@@ -0,0 +1,201 @@
/*
* SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_system.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_check.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_touch.h"
#include "esp_lcd_touch_cst816.h"
#define POINT_NUM_MAX (1)
#define DATA_START_REG (0x00)
#define CHIP_ID_REG (0xA7)
static const char *TAG = "CST816";
static esp_err_t read_data(esp_lcd_touch_handle_t tp);
static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
static esp_err_t del(esp_lcd_touch_handle_t tp);
static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len);
static esp_err_t reset(esp_lcd_touch_handle_t tp);
static esp_err_t read_id(esp_lcd_touch_handle_t tp);
esp_err_t esp_lcd_touch_new_i2c_cst816(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp)
{
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_ARG, TAG, "Invalid io");
ESP_RETURN_ON_FALSE(config, ESP_ERR_INVALID_ARG, TAG, "Invalid config");
ESP_RETURN_ON_FALSE(tp, ESP_ERR_INVALID_ARG, TAG, "Invalid touch handle");
/* Prepare main structure */
esp_err_t ret = ESP_OK;
esp_lcd_touch_handle_t cst816 = calloc(1, sizeof(esp_lcd_touch_t));
ESP_GOTO_ON_FALSE(cst816, ESP_ERR_NO_MEM, err, TAG, "Touch handle malloc failed");
/* Communication interface */
cst816->io = io;
/* Only supported callbacks are set */
cst816->read_data = read_data;
cst816->get_xy = get_xy;
cst816->del = del;
/* Mutex */
cst816->data.lock.owner = portMUX_FREE_VAL;
/* Save config */
memcpy(&cst816->config, config, sizeof(esp_lcd_touch_config_t));
/* Prepare pin for touch interrupt */
if (cst816->config.int_gpio_num != GPIO_NUM_NC) {
const gpio_config_t int_gpio_config = {
.mode = GPIO_MODE_INPUT,
.intr_type = (cst816->config.levels.interrupt ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE),
.pin_bit_mask = BIT64(cst816->config.int_gpio_num)
};
ESP_GOTO_ON_ERROR(gpio_config(&int_gpio_config), err, TAG, "GPIO intr config failed");
/* Register interrupt callback */
if (cst816->config.interrupt_callback) {
esp_lcd_touch_register_interrupt_callback(cst816, cst816->config.interrupt_callback);
}
}
/* Prepare pin for touch controller reset */
if (cst816->config.rst_gpio_num != GPIO_NUM_NC) {
const gpio_config_t rst_gpio_config = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = BIT64(cst816->config.rst_gpio_num)
};
ESP_GOTO_ON_ERROR(gpio_config(&rst_gpio_config), err, TAG, "GPIO reset config failed");
}
/* Reset controller */
ESP_GOTO_ON_ERROR(reset(cst816), err, TAG, "Reset failed");
/* Read product id */
ESP_GOTO_ON_ERROR(read_id(cst816), err, TAG, "Read version failed");
*tp = cst816;
ESP_LOGI(TAG, "LCD touch panel create success, version: %d.%d.%d", ESP_LCD_TOUCH_CST816_VER_MAJOR, ESP_LCD_TOUCH_CST816_VER_MINOR,
ESP_LCD_TOUCH_CST816_VER_PATCH);
return ESP_OK;
err:
if (cst816) {
del(cst816);
}
ESP_LOGE(TAG, "Initialization failed!");
return ret;
}
static esp_err_t read_data(esp_lcd_touch_handle_t tp)
{
typedef struct {
uint8_t num;
uint8_t x_h : 4;
uint8_t : 4;
uint8_t x_l;
uint8_t y_h : 4;
uint8_t : 4;
uint8_t y_l;
} data_t;
data_t point;
uint8_t lvalue[15]={0};
uint8_t gesture_id=0;
uint16_t x=0;
uint16_t y=0;
ESP_RETURN_ON_ERROR(i2c_read_bytes(tp, DATA_START_REG, (uint8_t *)lvalue, sizeof(lvalue)), TAG, "I2C read failed");
gesture_id = lvalue[1];
point.num =lvalue[2];
x = (((uint16_t)(lvalue[3]&0x0f))<<8) | lvalue[4];
y = (((uint16_t)(lvalue[5]&0x0f))<<8) | lvalue[6];
portENTER_CRITICAL(&tp->data.lock);
point.num = (point.num > POINT_NUM_MAX ? POINT_NUM_MAX : point.num);
tp->data.points = point.num;
/* Fill all coordinates */
for (int i = 0; i < point.num; i++) {
tp->data.coords[i].x = x;
tp->data.coords[i].y = y;
}
portEXIT_CRITICAL(&tp->data.lock);
return ESP_OK;
}
static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num)
{
portENTER_CRITICAL(&tp->data.lock);
/* Count of points */
*point_num = (tp->data.points > max_point_num ? max_point_num : tp->data.points);
for (size_t i = 0; i < *point_num; i++) {
x[i] = tp->data.coords[i].x;
y[i] = tp->data.coords[i].y;
if (strength) {
strength[i] = tp->data.coords[i].strength;
}
}
/* Invalidate */
tp->data.points = 0;
portEXIT_CRITICAL(&tp->data.lock);
return (*point_num > 0);
}
static esp_err_t del(esp_lcd_touch_handle_t tp)
{
/* Reset GPIO pin settings */
if (tp->config.int_gpio_num != GPIO_NUM_NC) {
gpio_reset_pin(tp->config.int_gpio_num);
if (tp->config.interrupt_callback) {
gpio_isr_handler_remove(tp->config.int_gpio_num);
}
}
if (tp->config.rst_gpio_num != GPIO_NUM_NC) {
gpio_reset_pin(tp->config.rst_gpio_num);
}
/* Release memory */
free(tp);
return ESP_OK;
}
static esp_err_t reset(esp_lcd_touch_handle_t tp)
{
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 failed");
vTaskDelay(pdMS_TO_TICKS(200));
ESP_RETURN_ON_ERROR(gpio_set_level(tp->config.rst_gpio_num, !tp->config.levels.reset), TAG, "GPIO set level failed");
vTaskDelay(pdMS_TO_TICKS(200));
}
return ESP_OK;
}
static esp_err_t read_id(esp_lcd_touch_handle_t tp)
{
uint8_t id;
ESP_RETURN_ON_ERROR(i2c_read_bytes(tp, CHIP_ID_REG, &id, 1), TAG, "I2C read failed");
ESP_LOGI(TAG, "IC id: %d", id);
return ESP_OK;
}
static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len)
{
ESP_RETURN_ON_FALSE(data, ESP_ERR_INVALID_ARG, TAG, "Invalid data");
return esp_lcd_panel_io_rx_param(tp->io, reg, data, len);
}
components/esp_lcd_touch_cst816/include/esp_lcd_touch_cst816.h
+61
View File
@@ -0,0 +1,61 @@
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief ESP LCD touch: CST816
*/
#pragma once
#include "esp_lcd_touch.h"
#ifdef __cplusplus
extern "C" {
#endif
#define ESP_LCD_TOUCH_CST816_VER_MAJOR (1)
#define ESP_LCD_TOUCH_CST816_VER_MINOR (0)
#define ESP_LCD_TOUCH_CST816_VER_PATCH (3)
/**
* @brief Create a new CST816 touch driver
*
* @note The I2C communication should be initialized before use this function.
*
* @param io LCD panel IO handle, it should be created by `esp_lcd_new_panel_io_i2c()`
* @param config Touch panel configuration
* @param tp Touch panel handle
* @return
* - ESP_OK: on success
*/
esp_err_t esp_lcd_touch_new_i2c_cst816(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp);
/**
* @brief I2C address of the CST816 controller
*
*/
#define ESP_LCD_TOUCH_IO_I2C_CST816_ADDRESS (0x15) // CST816
/**
* @brief Touch IO configuration structure
*
*/
#define ESP_LCD_TOUCH_IO_I2C_CST816_CONFIG() \
{ \
.dev_addr = ESP_LCD_TOUCH_IO_I2C_CST816_ADDRESS, \
.control_phase_bytes = 1, \
.dc_bit_offset = 0, \
.lcd_cmd_bits = 8, \
.flags = \
{ \
.disable_control_phase = 1, \
} \
}
#ifdef __cplusplus
}
#endif
components/esp_lcd_touch_cst820/CMakeLists.txt
+1
View File
@@ -0,0 +1 @@
idf_component_register(SRCS "esp_lcd_touch_cst820.c" INCLUDE_DIRS "include" REQUIRES "esp_lcd_touch")
components/esp_lcd_touch_cst820/esp_lcd_touch_cst820.c
+201
View File
@@ -0,0 +1,201 @@
/*
* SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_system.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_check.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_touch.h"
#include "esp_lcd_touch_cst820.h"
#define POINT_NUM_MAX (1)
#define DATA_START_REG (0x00)
#define CHIP_ID_REG (0xA7)
static const char *TAG = "CST820";
static esp_err_t read_data(esp_lcd_touch_handle_t tp);
static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
static esp_err_t del(esp_lcd_touch_handle_t tp);
static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len);
static esp_err_t reset(esp_lcd_touch_handle_t tp);
static esp_err_t read_id(esp_lcd_touch_handle_t tp);
esp_err_t esp_lcd_touch_new_i2c_cst820(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp)
{
ESP_RETURN_ON_FALSE(io, ESP_ERR_INVALID_ARG, TAG, "Invalid io");
ESP_RETURN_ON_FALSE(config, ESP_ERR_INVALID_ARG, TAG, "Invalid config");
ESP_RETURN_ON_FALSE(tp, ESP_ERR_INVALID_ARG, TAG, "Invalid touch handle");
/* Prepare main structure */
esp_err_t ret = ESP_OK;
esp_lcd_touch_handle_t cst820 = calloc(1, sizeof(esp_lcd_touch_t));
ESP_GOTO_ON_FALSE(cst820, ESP_ERR_NO_MEM, err, TAG, "Touch handle malloc failed");
/* Communication interface */
cst820->io = io;
/* Only supported callbacks are set */
cst820->read_data = read_data;
cst820->get_xy = get_xy;
cst820->del = del;
/* Mutex */
cst820->data.lock.owner = portMUX_FREE_VAL;
/* Save config */
memcpy(&cst820->config, config, sizeof(esp_lcd_touch_config_t));
/* Prepare pin for touch interrupt */
if (cst820->config.int_gpio_num != GPIO_NUM_NC) {
const gpio_config_t int_gpio_config = {
.mode = GPIO_MODE_INPUT,
.intr_type = (cst820->config.levels.interrupt ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE),
.pin_bit_mask = BIT64(cst820->config.int_gpio_num)
};
ESP_GOTO_ON_ERROR(gpio_config(&int_gpio_config), err, TAG, "GPIO intr config failed");
/* Register interrupt callback */
if (cst820->config.interrupt_callback) {
esp_lcd_touch_register_interrupt_callback(cst820, cst820->config.interrupt_callback);
}
}
/* Prepare pin for touch controller reset */
if (cst820->config.rst_gpio_num != GPIO_NUM_NC) {
const gpio_config_t rst_gpio_config = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = BIT64(cst820->config.rst_gpio_num)
};
ESP_GOTO_ON_ERROR(gpio_config(&rst_gpio_config), err, TAG, "GPIO reset config failed");
}
/* Reset controller */
ESP_GOTO_ON_ERROR(reset(cst820), err, TAG, "Reset failed");
/* Read product id */
ESP_GOTO_ON_ERROR(read_id(cst820), err, TAG, "Read version failed");
*tp = cst820;
ESP_LOGI(TAG, "LCD touch panel create success, version: %d.%d.%d", ESP_LCD_TOUCH_CST820_VER_MAJOR, ESP_LCD_TOUCH_CST820_VER_MINOR,
ESP_LCD_TOUCH_CST820_VER_PATCH);
return ESP_OK;
err:
if (cst820) {
del(cst820);
}
ESP_LOGE(TAG, "Initialization failed!");
return ret;
}
static esp_err_t read_data(esp_lcd_touch_handle_t tp)
{
typedef struct {
uint8_t num;
uint8_t x_h : 4;
uint8_t : 4;
uint8_t x_l;
uint8_t y_h : 4;
uint8_t : 4;
uint8_t y_l;
} data_t;
data_t point;
uint8_t lvalue[15]={0};
uint8_t gesture_id=0;
uint16_t x=0;
uint16_t y=0;
ESP_RETURN_ON_ERROR(i2c_read_bytes(tp, DATA_START_REG, (uint8_t *)lvalue, sizeof(lvalue)), TAG, "I2C read failed");
gesture_id = lvalue[1];
point.num =lvalue[2];
x = (((uint16_t)(lvalue[3]&0x0f))<<8) | lvalue[4];
y = (((uint16_t)(lvalue[5]&0x0f))<<8) | lvalue[6];
portENTER_CRITICAL(&tp->data.lock);
point.num = (point.num > POINT_NUM_MAX ? POINT_NUM_MAX : point.num);
tp->data.points = point.num;
/* Fill all coordinates */
for (int i = 0; i < point.num; i++) {
tp->data.coords[i].x = x;
tp->data.coords[i].y = y;
}
portEXIT_CRITICAL(&tp->data.lock);
return ESP_OK;
}
static bool get_xy(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num)
{
portENTER_CRITICAL(&tp->data.lock);
/* Count of points */
*point_num = (tp->data.points > max_point_num ? max_point_num : tp->data.points);
for (size_t i = 0; i < *point_num; i++) {
x[i] = tp->data.coords[i].x;
y[i] = tp->data.coords[i].y;
if (strength) {
strength[i] = tp->data.coords[i].strength;
}
}
/* Invalidate */
tp->data.points = 0;
portEXIT_CRITICAL(&tp->data.lock);
return (*point_num > 0);
}
static esp_err_t del(esp_lcd_touch_handle_t tp)
{
/* Reset GPIO pin settings */
if (tp->config.int_gpio_num != GPIO_NUM_NC) {
gpio_reset_pin(tp->config.int_gpio_num);
if (tp->config.interrupt_callback) {
gpio_isr_handler_remove(tp->config.int_gpio_num);
}
}
if (tp->config.rst_gpio_num != GPIO_NUM_NC) {
gpio_reset_pin(tp->config.rst_gpio_num);
}
/* Release memory */
free(tp);
return ESP_OK;
}
static esp_err_t reset(esp_lcd_touch_handle_t tp)
{
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 failed");
vTaskDelay(pdMS_TO_TICKS(200));
ESP_RETURN_ON_ERROR(gpio_set_level(tp->config.rst_gpio_num, !tp->config.levels.reset), TAG, "GPIO set level failed");
vTaskDelay(pdMS_TO_TICKS(200));
}
return ESP_OK;
}
static esp_err_t read_id(esp_lcd_touch_handle_t tp)
{
uint8_t id;
ESP_RETURN_ON_ERROR(i2c_read_bytes(tp, CHIP_ID_REG, &id, 1), TAG, "I2C read failed");
ESP_LOGI(TAG, "IC id: %d", id);
return ESP_OK;
}
static esp_err_t i2c_read_bytes(esp_lcd_touch_handle_t tp, uint16_t reg, uint8_t *data, uint8_t len)
{
ESP_RETURN_ON_FALSE(data, ESP_ERR_INVALID_ARG, TAG, "Invalid data");
return esp_lcd_panel_io_rx_param(tp->io, reg, data, len);
}
components/esp_lcd_touch_cst820/include/esp_lcd_touch_cst820.h
+61
View File
@@ -0,0 +1,61 @@
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief ESP LCD touch: CST820
*/
#pragma once
#include "esp_lcd_touch.h"
#ifdef __cplusplus
extern "C" {
#endif
#define ESP_LCD_TOUCH_CST820_VER_MAJOR (1)
#define ESP_LCD_TOUCH_CST820_VER_MINOR (0)
#define ESP_LCD_TOUCH_CST820_VER_PATCH (3)
/**
* @brief Create a new CST820 touch driver
*
* @note The I2C communication should be initialized before use this function.
*
* @param io LCD panel IO handle, it should be created by `esp_lcd_new_panel_io_i2c()`
* @param config Touch panel configuration
* @param tp Touch panel handle
* @return
* - ESP_OK: on success
*/
esp_err_t esp_lcd_touch_new_i2c_cst820(const esp_lcd_panel_io_handle_t io, const esp_lcd_touch_config_t *config, esp_lcd_touch_handle_t *tp);
/**
* @brief I2C address of the CST820 controller
*
*/
#define ESP_LCD_TOUCH_IO_I2C_CST820_ADDRESS (0x15) // CST820
/**
* @brief Touch IO configuration structure
*
*/
#define ESP_LCD_TOUCH_IO_I2C_CST820_CONFIG() \
{ \
.dev_addr = ESP_LCD_TOUCH_IO_I2C_CST820_ADDRESS, \
.control_phase_bytes = 1, \
.dc_bit_offset = 0, \
.lcd_cmd_bits = 8, \
.flags = \
{ \
.disable_control_phase = 1, \
} \
}
#ifdef __cplusplus
}
#endif
components/i2c_bsp/CMakeLists.txt
+4
View File
@@ -0,0 +1,4 @@
idf_component_register(
SRCS "i2c_bsp.c"
REQUIRES driver
INCLUDE_DIRS "./")
components/i2c_bsp/i2c_bsp.c
+56
View File
@@ -0,0 +1,56 @@
#include <stdio.h>
#include "i2c_bsp.h"
#define TEST_I2C_PORT I2C_NUM_0
//#define EXAMPLE_USE_TOUCH //触控屏的实现
#ifndef EXAMPLE_USE_TOUCH
#define I2C_MASTER_SCL_IO 39
#define I2C_MASTER_SDA_IO 40
void I2C_master_Init(void)
{
i2c_config_t conf =
{
.mode = I2C_MODE_MASTER,
.sda_io_num = I2C_MASTER_SDA_IO, // 配置 SDA 的 GPIO
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_io_num = I2C_MASTER_SCL_IO, // 配置 SCL 的 GPIO
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master.clk_speed = 300 * 1000, // 为项目选择频率
.clk_flags = 0, // 可选项，可以使用 I2C_SCLK_SRC_FLAG_* 标志来选择 I2C 源时钟
};
ESP_ERROR_CHECK(i2c_param_config(TEST_I2C_PORT, &conf));
ESP_ERROR_CHECK(i2c_driver_install(TEST_I2C_PORT, conf.mode,0,0,0));
}
#endif
uint8_t I2C_writr_buff(uint8_t addr,uint8_t reg,uint8_t *buf,uint8_t len)
{
uint8_t ret;
uint8_t *pbuf = (uint8_t*)malloc(len+1);
pbuf[0] = reg;
for(uint8_t i = 0; i<len; i++)
{
pbuf[i+1] = buf[i];
}
ret = i2c_master_write_to_device(TEST_I2C_PORT,addr,pbuf,len+1,1000);
free(pbuf);
pbuf = NULL;
return ret;
}
uint8_t I2C_read_buff(uint8_t addr,uint8_t reg,uint8_t *buf,uint8_t len)
{
uint8_t ret;
ret = i2c_master_write_read_device(TEST_I2C_PORT,addr,&reg,1,buf,len,1000);
return ret;
}
uint8_t I2C_master_write_read_device(uint8_t addr,uint8_t *writeBuf,uint8_t writeLen,uint8_t *readBuf,uint8_t readLen)
{
uint8_t ret;
ret = i2c_master_write_read_device(TEST_I2C_PORT,addr,writeBuf,writeLen,readBuf,readLen,1000);
return ret;
}
components/i2c_bsp/i2c_bsp.h
+10
View File
@@ -0,0 +1,10 @@
#ifndef I2C_BSP_H
#define I2C_BSP_H
#include "driver/i2c.h"
void I2C_master_Init(void);
uint8_t I2C_writr_buff(uint8_t addr,uint8_t reg,uint8_t *buf,uint8_t len);
uint8_t I2C_read_buff(uint8_t addr,uint8_t reg,uint8_t *buf,uint8_t len);
uint8_t I2C_master_write_read_device(uint8_t addr,uint8_t *writeBuf,uint8_t writeLen,uint8_t *readBuf,uint8_t readLen);
#endif