Add LVGL QSPI LCD with RAM example and SH8601 driver

Introduced the 05_LVGL_WITH_RAM example project for ESP32 targets, including support for QSPI LCD panels (SPD1020, GC9B71, SH8601) and touch controllers. Added SH8601 LCD driver component, related documentation, initialization code, and test applications. Updated .gitignore to allow tracking of the new example directory.
This commit is contained in:
2026-01-14 21:02:52 +05:30
parent a87cf44759
commit e8d1ad6d94
76 changed files with 10484 additions and 3 deletions

3
.gitignore vendored
View File

@@ -2,5 +2,4 @@
/managed_components
.vscode/settings.json
/ref_demo
/.cache
/05_LVGL_WITH_RAM
/.cache

View File

@@ -0,0 +1,8 @@
# For more information about build system see
# https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
# The following five lines of boilerplate have to be in your project's
# CMakeLists in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
add_compile_options("-Wno-format")
project(example_qspi_with_ram)

102
05_LVGL_WITH_RAM/README.md Normal file
View File

@@ -0,0 +1,102 @@
| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C6 | ESP32-H2 | ESP32-S2 | ESP32-S3 |
| ----------------- | ----- | -------- | -------- | -------- | -------- | -------- | -------- |
| Supported LCD Controllers | SPD2010 | GC9B71 | SH8601 |
| ------------------------- | ------- | ------ | ------ |
# QSPI LCD (with RAM) and Touch Panel Example
[esp_lcd](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/lcd.html) provides several panel drivers out-of box, e.g. ST7789, SSD1306, NT35510. However, there're a lot of other panels on the market, it's beyond `esp_lcd` component's responsibility to include them all.
`esp_lcd` allows user to add their own panel drivers in the project scope (i.e. panel driver can live outside of esp-idf), so that the upper layer code like LVGL porting code can be reused without any modifications, as long as user-implemented panel driver follows the interface defined in the `esp_lcd` component.
This example shows how to use SPD1020, GC9B71 or SH8601 display driver from Component manager in esp-idf project. These components are using API provided by `esp_lcd` component. This example will draw a fancy dash board with the LVGL library.
This example uses the [esp_timer](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/esp_timer.html) to generate the ticks needed by LVGL and uses a dedicated task to run the `lv_timer_handler()`. Since the LVGL APIs are not thread-safe, this example uses a mutex which be invoked before the call of `lv_timer_handler()` and released after it. The same mutex needs to be used in other tasks and threads around every LVGL (lv_...) related function call and code. For more porting guides, please refer to [LVGL porting doc](https://docs.lvgl.io/master/porting/index.html).
## Touch controller
In this example you can enable touch controller SPD2010 or CST816 connected via I2C.
## How to use the example
### Hardware Required
* An ESP development board
* A SPD1020, GC9B71 or SH8601 LCD panel, with QSPI interface (with/without touch)
* An USB cable for power supply and programming
### Hardware Connection
The connection between ESP Board and the LCD is as follows:
```
ESP Board SPD1020, GC9B71 or SH8601 Panel (QSPI)
┌──────────────────────┐ ┌────────────────────┐
│ GND ├─────────────►│ GND │
│ │ │ │
│ 3V3 ├─────────────►│ VCC │
│ │ │ │
│ CS ├─────────────►│ CS │
│ │ │ │
│ SCK ├─────────────►│ CLK │
│ │ │ │
│ D3 ├─────────────►│ IO3 │
│ │ │ │
│ D2 ├─────────────►│ IO2 │
│ │ │ │
│ D1 ├─────────────►│ IO1 │
│ │ │ │
│ D0 ├─────────────►│ IO0 │
│ │ │ │
│ RST ├─────────────►│ RSTN │
│ │ │ │
│ (SCL) ├─────────────►│ TP_SCL │
│ │ │ │
│ (SDA) ├─────────────►│ TP_SDA │
│ │ │ │
│ (TP_INT) ├─────────────►│ TP_INT │
│ │ │ │
│ (3V3) ├─────────────►│ TP_RST │
│ │ │ │
└──────────────────────┘ └────────────────────┘
```
The GPIO number used by this example can be changed in [example_qspi_with_ram.c](main/example_qspi_with_ram.c).
Especially, please pay attention to the level used to turn on the LCD backlight, some LCD module needs a low level to turn it on, while others take a high level. You can change the backlight level macro `EXAMPLE_LCD_BK_LIGHT_ON_LEVEL` in [example_qspi_with_ram.c](main/example_qspi_with_ram.c).
The LCD vendor specific initialization can be different between manufacturers and should consult the LCD supplier for initialization sequence code.
### Build and Flash
Run `idf.py -p PORT build flash monitor` to build, flash and monitor the project. A fancy animation will show up on the LCD as expected.
The first time you run `idf.py` for the example will cost extra time as the build system needs to address the component dependencies and downloads the missing components from registry into `managed_components` folder.
(To exit the serial monitor, type ``Ctrl-]``.)
See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
### Example Output
```bash
...
I (415) example: Turn off LCD backlight
I (420) gpio: GPIO[0]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
I (429) example: Initialize SPI bus
I (434) example: Install panel IO
I (438) example: Install SPD2010 panel driver
I (442) gpio: GPIO[17]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
I (452) spd2010: LCD panel create success, version: 0.0.1
I (741) example: Turn on LCD backlight
I (741) example: Initialize LVGL library
I (741) example: Register display driver to LVGL
I (746) example: Install LVGL tick timer
I (748) example: Starting LVGL task
I (795) example: Display LVGL demos
I (1038) main_task: Returned from app_main()
...
```
## Troubleshooting
For any technical queries, please open an [issue] (https://github.com/espressif/esp-iot-solution/issues) on GitHub. We will get back to you soon.

View File

@@ -0,0 +1 @@
9597cce74af4bae0ec423ee819a2916b995ff3e5bb8d590bdb0a27fa9e715dab

View File

@@ -0,0 +1,24 @@
# ChangeLog
## v0.0.1 - 2023-08-22
### Enhancements:
* Implement the driver for the SH8601 LCD controller
* Support SPI and QSPI interface
## v0.0.2 - 2023-10-07
### Enhancements:
* Support to use ESP-IDF release/v5.0
## v1.0.0 - 2023-11-03
### bugfix
* Fix the incompatible dependent version of ESP-IDF
* Remove LCD command `29h` from the initialization sequence
* Increase `pclk_hz` to 40MHz in default panel IO configuration
* Add parameter `max_trans_sz` in default bus configuration macro
* Add check for conflicting commands between initialization sequence and driver

View File

@@ -0,0 +1,4 @@
idf_component_register(SRCS "esp_lcd_sh8601.c" INCLUDE_DIRS "include" PRIV_REQUIRES "driver" REQUIRES "esp_lcd")
include(package_manager)
cu_pkg_define_version(${CMAKE_CURRENT_LIST_DIR})

View File

@@ -0,0 +1,147 @@
# ESP LCD SH8601
[![Component Registry](https://components.espressif.com/components/espressif/esp_lcd_sh8601/badge.svg)](https://components.espressif.com/components/espressif/esp_lcd_sh8601)
Implementation of the SH8601 LCD controller with [esp_lcd](https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-reference/peripherals/lcd.html) component.
| LCD controller | Communication interface | Component name | Link to datasheet |
| :------------: | :---------------------: | :------------: | :---------------------------------------------------------------------------: |
| SH8601 | SPI/QSPI | esp_lcd_sh8601 | [PDF](https://dl.espressif.com/AE/esp-iot-solution/SH8601A0_DataSheet_Preliminary_V0.0_UCS__191107_1_.pdf) |
## 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 "espressif/esp_lcd_sh8601"
```
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).
## Initialization Code
### SPI Interface
```c
ESP_LOGI(TAG, "Initialize SPI bus");
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_BUS_QSPI_CONFIG(EXAMPLE_PIN_NUM_LCD_PCLK,
EXAMPLE_PIN_NUM_LCD_DATA0,
EXAMPLE_PIN_NUM_LCD_DATA1,
EXAMPLE_PIN_NUM_LCD_DATA2,
EXAMPLE_PIN_NUM_LCD_DATA3,
EXAMPLE_LCD_H_RES * 80 * sizeof(uint16_t));
ESP_ERROR_CHECK(spi_bus_initialize(EXAMPLE_LCD_HOST, &bus_config, SPI_DMA_CH_AUTO));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_panel_io_handle_t io_handle = NULL;
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_SPI_CONFIG(EXAMPLE_PIN_NUM_LCD_CS, EXAMPLE_PIN_NUM_LCD_DC,
callback, &callback_data);
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)EXAMPLE_LCD_HOST, &io_config, &io_handle));
/**
* Uncomment these line if use custom initialization commands.
* The array should be declared as static const and positioned outside the function.
*/
// static const sh8601_lcd_init_cmd_t lcd_init_cmds[] = {
// // {cmd, { data }, data_size, delay_ms}
// {0x44, (uint8_t []){0x00, 0xc8}, 2, 0},
// {0x35, (uint8_t []){0x00}, 0, 0},
// {0x53, (uint8_t []){0x20}, 1, 25},
// {0x29, (uint8_t []){0x00}, 0, 120},
// ...
// };
ESP_LOGI(TAG, "Install SH8601 panel driver");
esp_lcd_panel_handle_t panel_handle = NULL;
const sh8601_vendor_config_t vendor_config = {
// .init_cmds = lcd_init_cmds, // Uncomment these line if use custom initialization commands
// .init_cmds_size = sizeof(lcd_init_cmds) / sizeof(sh8601_lcd_init_cmd_t),
.flags = {
.use_qspi_interface = 0,
},
};
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = EXAMPLE_PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB, // Implemented by LCD command `36h`
.bits_per_pixel = 16, // Implemented by LCD command `3Ah` (16/18/24)
.vendor_config = &vendor_config,
};
ESP_ERROR_CHECK(esp_lcd_new_panel_sh8601(io_handle, &panel_config, &panel_handle));
esp_lcd_panel_reset(panel_handle);
esp_lcd_panel_init(panel_handle);
esp_lcd_panel_disp_on_off(panel_handle, true);
```
### QSPI Interface
```c
ESP_LOGI(TAG, "Initialize QSPI bus");
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_BUS_QSPI_CONFIG(EXAMPLE_PIN_NUM_LCD_PCLK,
EXAMPLE_PIN_NUM_LCD_DATA0,
EXAMPLE_PIN_NUM_LCD_DATA1,
EXAMPLE_PIN_NUM_LCD_DATA2,
EXAMPLE_PIN_NUM_LCD_DATA3,
EXAMPLE_LCD_H_RES * 80 * sizeof(uint16_t));
ESP_ERROR_CHECK(spi_bus_initialize(EXAMPLE_LCD_HOST, &buscfg, SPI_DMA_CH_AUTO));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_panel_io_handle_t io_handle = NULL;
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG(EXAMPLE_PIN_NUM_LCD_CS, callback, &callback_data);
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)EXAMPLE_LCD_HOST, &io_config, &io_handle));
/**
* Uncomment these line if use custom initialization commands.
* The array should be declared as static const and positioned outside the function.
*/
// static const sh8601_lcd_init_cmd_t lcd_init_cmds[] = {
// // {cmd, { data }, data_size, delay_ms}
// {0x44, (uint8_t []){0x00, 0xc8}, 2, 0},
// {0x35, (uint8_t []){0x00}, 0, 0},
// {0x53, (uint8_t []){0x20}, 1, 25},
// {0x29, (uint8_t []){0x00}, 0, 120},
// ...
// };
ESP_LOGI(TAG, "Install SH8601 panel driver");
esp_lcd_panel_handle_t panel_handle = NULL;
const sh8601_vendor_config_t vendor_config = {
// .init_cmds = lcd_init_cmds, // Uncomment these line if use custom initialization commands
// .init_cmds_size = sizeof(lcd_init_cmds) / sizeof(sh8601_lcd_init_cmd_t),
.flags = {
.use_qspi_interface = 1,
},
};
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = EXAMPLE_PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB, // Implemented by LCD command `36h`
.bits_per_pixel = 16, // Implemented by LCD command `3Ah`
.vendor_config = &vendor_config,
};
ESP_ERROR_CHECK(esp_lcd_new_panel_sh8601(io_handle, &panel_config, &panel_handle));
esp_lcd_panel_reset(panel_handle);
esp_lcd_panel_init(panel_handle);
esp_lcd_panel_disp_on_off(panel_handle, true);
```
## Notes
* When utilizing `esp_panel_lcd_draw_bitmap()` to refresh the screen, ensure that `x_start`, `y_start`, `x_end` and `y_end` are divisible by `2`. This is a requirement of SH8610. For LVGL, register the following function into `rounder_cb` of `lv_disp_drv_t` to round the coordinates.
```c
void lvgl_port_rounder_callback(struct _lv_disp_drv_t * disp_drv, lv_area_t * area)
{
uint16_t x1 = area->x1;
uint16_t x2 = area->x2;
uint16_t y1 = area->y1;
uint16_t y2 = area->y2;
// round the start of area down to the nearest even number
area->x1 = (x1 >> 1) << 1;
area->y1 = (y1 >> 1) << 1;
// round the end of area up to the nearest odd number
area->x2 = ((x2 >> 1) << 1) + 1;
area->y2 = ((y2 >> 1) << 1) + 1;
}
```

View File

@@ -0,0 +1,347 @@
/*
* 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_sh8601.h"
#define LCD_OPCODE_WRITE_CMD (0x02ULL)
#define LCD_OPCODE_READ_CMD (0x03ULL)
#define LCD_OPCODE_WRITE_COLOR (0x32ULL)
static const char *TAG = "sh8601";
static esp_err_t panel_sh8601_del(esp_lcd_panel_t *panel);
static esp_err_t panel_sh8601_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_sh8601_init(esp_lcd_panel_t *panel);
static esp_err_t panel_sh8601_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_sh8601_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_sh8601_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_sh8601_swap_xy(esp_lcd_panel_t *panel, bool swap_axes);
static esp_err_t panel_sh8601_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap);
static esp_err_t panel_sh8601_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 sh8601_lcd_init_cmd_t *init_cmds;
uint16_t init_cmds_size;
struct {
unsigned int use_qspi_interface: 1;
unsigned int reset_level: 1;
} flags;
} sh8601_panel_t;
esp_err_t esp_lcd_new_panel_sh8601(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;
sh8601_panel_t *sh8601 = NULL;
sh8601 = calloc(1, sizeof(sh8601_panel_t));
ESP_GOTO_ON_FALSE(sh8601, ESP_ERR_NO_MEM, err, TAG, "no mem for sh8601 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:
sh8601->madctl_val = 0;
break;
case LCD_RGB_ELEMENT_ORDER_BGR:
sh8601->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
sh8601->colmod_val = 0x55;
fb_bits_per_pixel = 16;
break;
case 18: // RGB666
sh8601->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 = 24;
break;
case 24: // RGB888
sh8601->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;
}
sh8601->io = io;
sh8601->reset_gpio_num = panel_dev_config->reset_gpio_num;
sh8601->fb_bits_per_pixel = fb_bits_per_pixel;
sh8601_vendor_config_t *vendor_config = (sh8601_vendor_config_t *)panel_dev_config->vendor_config;
if (vendor_config) {
sh8601->init_cmds = vendor_config->init_cmds;
sh8601->init_cmds_size = vendor_config->init_cmds_size;
sh8601->flags.use_qspi_interface = vendor_config->flags.use_qspi_interface;
}
sh8601->flags.reset_level = panel_dev_config->flags.reset_active_high;
sh8601->base.del = panel_sh8601_del;
sh8601->base.reset = panel_sh8601_reset;
sh8601->base.init = panel_sh8601_init;
sh8601->base.draw_bitmap = panel_sh8601_draw_bitmap;
sh8601->base.invert_color = panel_sh8601_invert_color;
sh8601->base.set_gap = panel_sh8601_set_gap;
sh8601->base.mirror = panel_sh8601_mirror;
sh8601->base.swap_xy = panel_sh8601_swap_xy;
sh8601->base.disp_on_off = panel_sh8601_disp_on_off;
*ret_panel = &(sh8601->base);
ESP_LOGD(TAG, "new sh8601 panel @%p", sh8601);
ESP_LOGI(TAG, "LCD panel create success, version: %d.%d.%d", ESP_LCD_SH8601_VER_MAJOR, ESP_LCD_SH8601_VER_MINOR,
ESP_LCD_SH8601_VER_PATCH);
return ESP_OK;
err:
if (sh8601) {
if (panel_dev_config->reset_gpio_num >= 0) {
gpio_reset_pin(panel_dev_config->reset_gpio_num);
}
free(sh8601);
}
return ret;
}
static esp_err_t tx_param(sh8601_panel_t *sh8601, esp_lcd_panel_io_handle_t io, int lcd_cmd, const void *param, size_t param_size)
{
if (sh8601->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(sh8601_panel_t *sh8601, esp_lcd_panel_io_handle_t io, int lcd_cmd, const void *param, size_t param_size)
{
if (sh8601->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_sh8601_del(esp_lcd_panel_t *panel)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_panel_t, base);
if (sh8601->reset_gpio_num >= 0) {
gpio_reset_pin(sh8601->reset_gpio_num);
}
ESP_LOGD(TAG, "del sh8601 panel @%p", sh8601);
free(sh8601);
return ESP_OK;
}
static esp_err_t panel_sh8601_reset(esp_lcd_panel_t *panel)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_panel_t, base);
esp_lcd_panel_io_handle_t io = sh8601->io;
// Perform hardware reset
if (sh8601->reset_gpio_num >= 0) {
gpio_set_level(sh8601->reset_gpio_num, sh8601->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
gpio_set_level(sh8601->reset_gpio_num, !sh8601->flags.reset_level);
vTaskDelay(pdMS_TO_TICKS(150));
} else { // Perform software reset
ESP_RETURN_ON_ERROR(tx_param(sh8601, io, LCD_CMD_SWRESET, NULL, 0), TAG, "send command failed");
vTaskDelay(pdMS_TO_TICKS(80));
}
return ESP_OK;
}
static const sh8601_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_sh8601_init(esp_lcd_panel_t *panel)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_panel_t, base);
esp_lcd_panel_io_handle_t io = sh8601->io;
const sh8601_lcd_init_cmd_t *init_cmds = NULL;
uint16_t init_cmds_size = 0;
bool is_cmd_overwritten = false;
ESP_RETURN_ON_ERROR(tx_param(sh8601, io, LCD_CMD_MADCTL, (uint8_t[]) {
sh8601->madctl_val,
}, 1), TAG, "send command failed");
ESP_RETURN_ON_ERROR(tx_param(sh8601, io, LCD_CMD_COLMOD, (uint8_t[]) {
sh8601->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 (sh8601->init_cmds) {
init_cmds = sh8601->init_cmds;
init_cmds_size = sh8601->init_cmds_size;
} else {
init_cmds = vendor_specific_init_default;
init_cmds_size = sizeof(vendor_specific_init_default) / sizeof(sh8601_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;
sh8601->madctl_val = ((uint8_t *)init_cmds[i].data)[0];
break;
case LCD_CMD_COLMOD:
is_cmd_overwritten = true;
sh8601->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(sh8601, 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;
}
static esp_err_t panel_sh8601_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_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 = sh8601->io;
x_start += sh8601->x_gap;
x_end += sh8601->x_gap;
y_start += sh8601->y_gap;
y_end += sh8601->y_gap;
// define an area of frame memory where MCU can access
ESP_RETURN_ON_ERROR(tx_param(sh8601, 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(sh8601, 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) * sh8601->fb_bits_per_pixel / 8;
tx_color(sh8601, io, LCD_CMD_RAMWR, color_data, len);
return ESP_OK;
}
static esp_err_t panel_sh8601_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_panel_t, base);
esp_lcd_panel_io_handle_t io = sh8601->io;
int command = 0;
if (invert_color_data) {
command = LCD_CMD_INVON;
} else {
command = LCD_CMD_INVOFF;
}
ESP_RETURN_ON_ERROR(tx_param(sh8601, io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}
static esp_err_t panel_sh8601_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_panel_t, base);
esp_lcd_panel_io_handle_t io = sh8601->io;
esp_err_t ret = ESP_OK;
if (mirror_x) {
sh8601->madctl_val |= BIT(6);
} else {
sh8601->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(sh8601, io, LCD_CMD_MADCTL, (uint8_t[]) {
sh8601->madctl_val
}, 1), TAG, "send command failed");
return ret;
}
static esp_err_t panel_sh8601_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_sh8601_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_panel_t, base);
sh8601->x_gap = x_gap;
sh8601->y_gap = y_gap;
return ESP_OK;
}
static esp_err_t panel_sh8601_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
{
sh8601_panel_t *sh8601 = __containerof(panel, sh8601_panel_t, base);
esp_lcd_panel_io_handle_t io = sh8601->io;
int command = 0;
if (on_off) {
command = LCD_CMD_DISPON;
} else {
command = LCD_CMD_DISPOFF;
}
ESP_RETURN_ON_ERROR(tx_param(sh8601, io, command, NULL, 0), TAG, "send command failed");
return ESP_OK;
}

View File

@@ -0,0 +1,10 @@
dependencies:
cmake_utilities:
version: 0.*
idf:
version: '>5.0.4,!=5.1.1'
description: ESP LCD SH8601
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_sh8601
version: 1.0.0

View File

@@ -0,0 +1,115 @@
/*
* 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"
#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 */
} sh8601_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 sh8601_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;
} sh8601_vendor_config_t;
/**
* @brief Create LCD panel for model SH8601
*
* @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_sh8601(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);
/**
* @brief LCD panel bus configuration structure
*
*/
#define SH8601_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 SH8601_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 SH8601_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 SH8601_PANEL_IO_QSPI_CONFIG(cs, cb, cb_ctx) \
{ \
.cs_gpio_num = cs, \
.dc_gpio_num = -1, \
.spi_mode = 0, \
.pclk_hz = 40 * 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

View File

@@ -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.

View File

@@ -0,0 +1,6 @@
# The following lines of boilerplate have to be in your project's CMakeLists
# in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
set(EXTRA_COMPONENT_DIRS "$ENV{IDF_PATH}/tools/unit-test-app/components")
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(test_esp_lcd_gc9b71)

View File

@@ -0,0 +1 @@
idf_component_register(SRCS "test_esp_lcd_sh8601.c")

View File

@@ -0,0 +1,6 @@
## IDF Component Manager Manifest File
dependencies:
idf: ">=5.0.4"
esp_lcd_sh8601:
version: "*"
override_path: "../../../esp_lcd_sh8601"

View File

@@ -0,0 +1,198 @@
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/spi_master.h"
#include "driver/gpio.h"
#include "esp_heap_caps.h"
#include "esp_log.h"
#include "esp_lcd_panel_io_interface.h"
#include "esp_lcd_panel_ops.h"
#include "unity.h"
#include "unity_test_runner.h"
#include "unity_test_utils_memory.h"
#include "esp_lcd_sh8601.h"
#define TEST_LCD_HOST SPI2_HOST
#define TEST_LCD_H_RES (368)
#define TEST_LCD_V_RES (448)
#define TEST_LCD_BIT_PER_PIXEL (16)
#define TEST_PIN_NUM_LCD_CS (GPIO_NUM_9)
#define TEST_PIN_NUM_LCD_PCLK (GPIO_NUM_10)
#define TEST_PIN_NUM_LCD_DATA0 (GPIO_NUM_11)
#define TEST_PIN_NUM_LCD_DATA1 (GPIO_NUM_12)
#define TEST_PIN_NUM_LCD_DATA2 (GPIO_NUM_13)
#define TEST_PIN_NUM_LCD_DATA3 (GPIO_NUM_14)
#define TEST_PIN_NUM_LCD_RST (GPIO_NUM_21)
#define TEST_PIN_NUM_LCD_DC (GPIO_NUM_8)
#define TEST_DELAY_TIME_MS (3000)
static char *TAG = "sh8601_test";
static SemaphoreHandle_t refresh_finish = NULL;
static const sh8601_lcd_init_cmd_t lcd_init_cmds[] = {
{0x11, (uint8_t []){0x00}, 0, 120},
{0x44, (uint8_t []){0x01, 0xD1}, 2, 0},
{0x35, (uint8_t []){0x00}, 1, 0},
{0x53, (uint8_t []){0x20}, 1, 10},
{0x51, (uint8_t []){0x00}, 1, 10},
{0x29, (uint8_t []){0x00}, 0, 10},
{0x51, (uint8_t []){0xFF}, 1, 0},
};
IRAM_ATTR static bool test_notify_refresh_ready(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
{
BaseType_t need_yield = pdFALSE;
xSemaphoreGiveFromISR(refresh_finish, &need_yield);
return (need_yield == pdTRUE);
}
static void test_draw_bitmap(esp_lcd_panel_handle_t panel_handle)
{
refresh_finish = xSemaphoreCreateBinary();
TEST_ASSERT_NOT_NULL(refresh_finish);
uint16_t row_line = ((TEST_LCD_V_RES / TEST_LCD_BIT_PER_PIXEL) << 1) >> 1;
uint8_t byte_per_pixel = TEST_LCD_BIT_PER_PIXEL / 8;
uint8_t *color = (uint8_t *)heap_caps_calloc(1, row_line * TEST_LCD_H_RES * byte_per_pixel, MALLOC_CAP_DMA);
TEST_ASSERT_NOT_NULL(color);
for (int j = 0; j < TEST_LCD_BIT_PER_PIXEL; j++) {
for (int i = 0; i < row_line * TEST_LCD_H_RES; i++) {
for (int k = 0; k < byte_per_pixel; k++) {
color[i * byte_per_pixel + k] = (SPI_SWAP_DATA_TX(BIT(j), TEST_LCD_BIT_PER_PIXEL) >> (k * 8)) & 0xff;
}
}
TEST_ESP_OK(esp_lcd_panel_draw_bitmap(panel_handle, 0, j * row_line, TEST_LCD_H_RES, (j + 1) * row_line, color));
xSemaphoreTake(refresh_finish, portMAX_DELAY);
}
free(color);
vSemaphoreDelete(refresh_finish);
vTaskDelay(pdMS_TO_TICKS(TEST_DELAY_TIME_MS));
}
TEST_CASE("test sh8601 to draw color bar with SPI interface", "[sh8601][spi]")
{
ESP_LOGI(TAG, "Initialize SPI bus");
const spi_bus_config_t buscfg = SH8601_PANEL_BUS_SPI_CONFIG(TEST_PIN_NUM_LCD_PCLK,
TEST_PIN_NUM_LCD_DATA0,
TEST_LCD_H_RES * TEST_LCD_V_RES * TEST_LCD_BIT_PER_PIXEL / 8);
TEST_ESP_OK(spi_bus_initialize(TEST_LCD_HOST, &buscfg, SPI_DMA_CH_AUTO));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_panel_io_handle_t io_handle = NULL;
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_SPI_CONFIG(TEST_PIN_NUM_LCD_CS, TEST_PIN_NUM_LCD_DC,
test_notify_refresh_ready, NULL);
// Attach the LCD to the SPI bus
TEST_ESP_OK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)TEST_LCD_HOST, &io_config, &io_handle));
ESP_LOGI(TAG, "Install LCD driver of sh8601");
esp_lcd_panel_handle_t panel_handle = NULL;
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = TEST_PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = TEST_LCD_BIT_PER_PIXEL,
};
TEST_ESP_OK(esp_lcd_new_panel_sh8601(io_handle, &panel_config, &panel_handle));
esp_lcd_panel_reset(panel_handle);
esp_lcd_panel_init(panel_handle);
esp_lcd_panel_disp_on_off(panel_handle, true);
test_draw_bitmap(panel_handle);
TEST_ESP_OK(esp_lcd_panel_del(panel_handle));
TEST_ESP_OK(esp_lcd_panel_io_del(io_handle));
TEST_ESP_OK(spi_bus_free(TEST_LCD_HOST));
}
TEST_CASE("test sh8601 to draw color bar with QSPI interface", "[sh8601][qspi]")
{
ESP_LOGI(TAG, "Initialize SPI bus");
const spi_bus_config_t buscfg = SH8601_PANEL_BUS_QSPI_CONFIG(TEST_PIN_NUM_LCD_PCLK,
TEST_PIN_NUM_LCD_DATA0,
TEST_PIN_NUM_LCD_DATA1,
TEST_PIN_NUM_LCD_DATA2,
TEST_PIN_NUM_LCD_DATA3,
TEST_LCD_H_RES * TEST_LCD_V_RES * TEST_LCD_BIT_PER_PIXEL / 8);
TEST_ESP_OK(spi_bus_initialize(TEST_LCD_HOST, &buscfg, SPI_DMA_CH_AUTO));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_panel_io_handle_t io_handle = NULL;
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG(TEST_PIN_NUM_LCD_CS, test_notify_refresh_ready, NULL);
// Attach the LCD to the SPI bus
TEST_ESP_OK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)TEST_LCD_HOST, &io_config, &io_handle));
ESP_LOGI(TAG, "Install LCD driver of sh8601");
esp_lcd_panel_handle_t panel_handle = NULL;
const sh8601_vendor_config_t vendor_config = {
.init_cmds = lcd_init_cmds,
.init_cmds_size = sizeof(lcd_init_cmds) / sizeof(lcd_init_cmds[0]),
.flags = {
.use_qspi_interface = 1,
},
};
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = TEST_PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = TEST_LCD_BIT_PER_PIXEL,
.vendor_config = (void *)&vendor_config,
};
TEST_ESP_OK(esp_lcd_new_panel_sh8601(io_handle, &panel_config, &panel_handle));
esp_lcd_panel_reset(panel_handle);
esp_lcd_panel_init(panel_handle);
esp_lcd_panel_disp_on_off(panel_handle, true);
test_draw_bitmap(panel_handle);
TEST_ESP_OK(esp_lcd_panel_del(panel_handle));
TEST_ESP_OK(esp_lcd_panel_io_del(io_handle));
TEST_ESP_OK(spi_bus_free(TEST_LCD_HOST));
}
// Some resources are lazy allocated in the LCD driver, the threadhold is left for that case
#define TEST_MEMORY_LEAK_THRESHOLD (300)
static size_t before_free_8bit;
static size_t before_free_32bit;
void setUp(void)
{
before_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
before_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
}
void tearDown(void)
{
size_t after_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
size_t after_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
unity_utils_check_leak(before_free_8bit, after_free_8bit, "8BIT", TEST_MEMORY_LEAK_THRESHOLD);
unity_utils_check_leak(before_free_32bit, after_free_32bit, "32BIT", TEST_MEMORY_LEAK_THRESHOLD);
}
void app_main(void)
{
/**
* __ ___ __ ___ _
* / _\ /\ /( _ ) / /_ / _ \/ |
* \ \ / /_/ / _ \| '_ \| | | | |
* _\ \/ __ / (_) | (_) | |_| | |
* \__/\/ /_/ \___/ \___/ \___/|_|
*/
printf(" __ ___ __ ___ _\r\n");
printf("/ _\\ /\\ /( _ ) / /_ / _ \\/ |\r\n");
printf("\\ \\ / /_/ / _ \\| '_ \\| | | | |\r\n");
printf("_\\ \\/ __ / (_) | (_) | |_| | |\r\n");
printf("\\__/\\/ /_/ \\___/ \\___/ \\___/|_|\r\n");
unity_run_menu();
}

View File

@@ -0,0 +1,10 @@
# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import pytest
from pytest_embedded import Dut
@pytest.mark.target('esp32s3')
@pytest.mark.env('esp32_s3_lcd_ev_board')
def test_usb_stream(dut: Dut)-> None:
dut.run_all_single_board_cases()

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,10 @@
# For IDF 5.0
CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
CONFIG_FREERTOS_HZ=1000
CONFIG_ESP_TASK_WDT_EN=n
CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=4096
# For IDF4.4
CONFIG_ESP32S2_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP_TASK_WDT=n

View File

@@ -0,0 +1 @@
351350613ceafba240b761b4ea991e0f231ac7a9f59a9ee901f751bddc0bb18f

View File

@@ -0,0 +1,89 @@
## v0.5.3 - 2023-09-15
* fix `add_dependencies called with incorrect number of arguments` in `relinker.cmake`
* `include(cmake_utilities)` is not suggested now, to avoid cmake_utilities dependency issue
## v0.5.2 - 2023-09-15
* Support work on older ESP-IDF, eg: 4.3.x
## v0.5.1 - 2023-08-22
* Add string 1-byte align support
## v0.5.0 - 2023-08-02
* Add GCC LTO support
## v0.4.8 - 2023-05-24
* Add unit test app
### Bugfix:
* fix customer target redefinition issue
## v0.4.7 - 2023-04-21
* gen_compressed_ota: support the addition of a v2 compressed OTA header to compressed firmware.
## v0.4.6 - 2023-04-20
* relinker: add IDF v4.3.x support
## v0.4.5 - 2023-04-17
* gen_compressed_ota: remove slash use in gen_custom_ota.py so that the script can be used in the Windows cmd terminal.
## v0.4.4 - 2023-04-07
* relinker: suppressing the creation of `__pycache__`
* relinker: support same name objects in one library
## v0.4.3 - 2023-03-24
* relinker: support decoding to get IRAM excluded libraries
## v0.4.2 - 2023-03-20
### Bugfix:
* gen_compressed_ota: Fix the number of bytes reserved in the v3 compressed image header
* gen_compressed_ota: Fix definition of MD5 length in compressed image header for different versions.
## v0.4.1 - 2023-03-15
* relinker: add option to use customized configuration files
* relinker: add option to print error information instead of throwing exception when missing function
* relinker: move functions of SPI flash from IRAM to flash only when enable CONFIG_SPI_FLASH_ROM_IMPL
* relinker: move some functions of esp_timer from IRAM to flash only when disable CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
## v0.4.0 - 2023-03-13
### Feature:
* Add command `idf.py gen_single_bin` to generate merged bin file
* Add command `idf.py flash_single_bin` to flash generated merged bin
* Add config `Color in diagnostics` to control the GCC color output
## v0.3.0 - 2023-03-10
* Add gen_compressed_ota functionality, please refer to [gen_compressed_ota.md](https://github.com/espressif/esp-iot-solution/tree/master/tools/cmake_utilities/docs/gen_compressed_ota.md)
## v0.2.1 - 2023-03-09
### Bugfix:
* package manager: Fix the compile issue when the name of the component has `-`, just like esp-xxx
## v0.2.0 - 2023-02-23
* Add relinker functionality, please refer to [relinker.md](https://github.com/espressif/esp-iot-solution/tree/master/tools/cmake_utilities/docs/relinker.md)
## v0.1.0 - 2023-01-12
### Feature:
* Add function cu_pkg_get_version
* Add macro cu_pkg_define_version
* Add cmake script to CMAKE_MODULE_PATH

View File

@@ -0,0 +1 @@
idf_component_register()

View File

@@ -0,0 +1,65 @@
menu "CMake Utilities"
config CU_RELINKER_ENABLE
bool "Enable relinker"
default n
help
"Enable relinker to linker some IRAM functions to Flash"
if CU_RELINKER_ENABLE
config CU_RELINKER_ENABLE_PRINT_ERROR_INFO_WHEN_MISSING_FUNCTION
bool "Print error information when missing function"
default y
help
"Enable this option to print error information instead of
throwing exception when missing function"
config CU_RELINKER_ENABLE_CUSTOMIZED_CONFIGURATION_FILES
bool "Enable customized relinker configuration files"
default n
help
"Enable this option to use customized relinker configuration
files instead of default ones"
if CU_RELINKER_ENABLE_CUSTOMIZED_CONFIGURATION_FILES
config CU_RELINKER_CUSTOMIZED_CONFIGURATION_FILES_PATH
string "Customized relinker configuration files path"
default ""
help
"Customized relinker configuration files path. This path is
evaluated relative to the project root directory."
endif
endif
choice CU_DIAGNOSTICS_COLOR
prompt "Color in diagnostics"
default CU_DIAGNOSTICS_COLOR_ALWAYS
help
Use color in diagnostics. "never", "always", or "auto". If "always", GCC will output
with color defined in GCC_COLORS environment variable. If "never", only output plain
text. If "auto", only output with color when the standard error is a terminal and when
not executing in an emacs shell.
config CU_DIAGNOSTICS_COLOR_NEVER
bool "never"
config CU_DIAGNOSTICS_COLOR_ALWAYS
bool "always"
config CU_DIAGNOSTICS_COLOR_AUTO
bool "auto"
endchoice
config CU_GCC_LTO_ENABLE
bool "Enable GCC link time optimization(LTO)"
default n
help
"Enable this option, users can enable GCC link time optimization(LTO)
feature for target components or dependencies.
config CU_GCC_STRING_1BYTE_ALIGN
bool "GCC string 1-byte align"
default n
help
"Enable this option, user can make string in designated components align
by 1-byte instead 1-word(4-byte), this can reduce unnecessary filled data
so that to reduce firmware size."
endmenu

View File

@@ -0,0 +1,31 @@
# Cmake utilities
[![Component Registry](https://components.espressif.com/components/espressif/cmake_utilities/badge.svg)](https://components.espressif.com/components/espressif/cmake_utilities)
This component is aiming to provide some useful CMake utilities outside of ESP-IDF.
## Use
1. Add dependency of this component in your component or project's idf_component.yml.
```yml
dependencies:
espressif/cmake_utilities: "0.*"
```
2. Include the CMake file you need in your component's CMakeLists.txt after `idf_component_register`, or in your project's CMakeLists.txt
```cmake
// Note: should remove .cmake postfix when using include(), otherwise the requested file will not found
// Note: should place this line after `idf_component_register` function
// only include the one you needed.
include(package_manager)
```
3. Then you can use the corresponding CMake function which is provided by the CMake file.
## Supported features
1. [relinker](https://github.com/espressif/esp-iot-solution/blob/master/tools/cmake_utilities/docs/relinker.md)
2. [gen_compressed_ota](https://github.com/espressif/esp-iot-solution/blob/master/tools/cmake_utilities/docs/gen_compressed_ota.md)
3. [GCC Optimization](https://github.com/espressif/esp-iot-solution/blob/master/tools/cmake_utilities/docs/gcc.md)

View File

@@ -0,0 +1,7 @@
# Include all cmake modules
include(gcc)
include(gen_compressed_ota)
include(gen_single_bin)
include(package_manager)
include(relinker)

View File

@@ -0,0 +1,108 @@
# Link Time Optimization(LTO)
Link time optimization(LTO) improves the optimization effect of GCC, such as reducing binary size, increasing performance, and so on. For more details please refer to related [GCC documents](https://gcc.gnu.org/onlinedocs/gccint/LTO.html).
## Use
To use this feature, you need to include the required CMake file in your project's CMakeLists.txt after `project(XXXX)`.
```cmake
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(XXXX)
include(gcc)
```
The LTO feature is disabled by default. To use it, you should enable the option `CU_GCC_LTO_ENABLE` in menuconfig. Then specify target components or dependencies to be optimized by LTO after `include(gcc)` as follows:
```cmake
include(gcc)
cu_gcc_lto_set(COMPONENTS component_a component_b
DEPENDS dependence_a dependence_b)
cu_gcc_string_1byte_align(COMPONENTS component_c component_d
DEPENDS dependence_c dependence_d)
```
Based on your requirement, set compiling optimization level in the option `COMPILER_OPTIMIZATION`.
* Note
```
1. Reducing firmware size may decrease performance
2. Increasing performance may increase firmware size
3. Enable LTO cause compiling time cost increases a lot
4. Enable LTO may increase task stack cost
5. Enable string 1-byte align may decrease string process speed
```
## Limitation
At the linking stage, the LTO generates new function indexes instead of the file path as follows:
- LTO
```txt
.text 0x00000000420016f4 0x6 /tmp/ccdjwYMH.ltrans51.ltrans.o
0x00000000420016f4 app_main
```
- Without LTO
```txt
.text.app_main 0x00000000420016f4 0x6 esp-idf/main/libmain.a(app_main.c.obj)
0x00000000420016f4 app_main
```
So tools used to relink functions between flash and IRAM can't affect these optimized components and dependencies again. It is recommended that users had better optimize application components and dependencies than kernel and hardware driver ones.
## Example
The example applies LTO in `light` of `esp-matter` because its application code is much larger. Add LTO configuration into project script `CMakeLists.txt` as follows:
```cmake
project(light)
include(gcc)
# Add
set(app_lto_components main chip esp_matter)
# Add
set(idf_lto_components lwip wpa_supplicant nvs_flash)
# Add
set(lto_depends mbedcrypto)
# Add
cu_gcc_lto_set(COMPONENTS ${app_lto_components} ${idf_lto_components}
DEPENDS ${lto_depends})
```
Configure `ESP32-C2` as the target platform, enable `CU_GCC_LTO_ENABLE` and `CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE`, set `COMPILER_OPTIMIZATION` to be `-Os`.
Increase the `main` task stack size to `5120` by option `ESP_MAIN_TASK_STACK_SIZE`.
Compile the project, and then you can see the firmware size decrease a lot:
Option | Firmware size | Stask cost
|:-:|:-:|:-:|
-Os | 1,113,376 | 2508
-Os + LTO | 1,020,640 | 4204
Then add `cu_gcc_string_1byte_align` after `cu_gcc_lto_set`:
```cmake
# Add
cu_gcc_lto_set(COMPONENTS ${app_lto_components} ${idf_lto_components}
DEPENDS ${lto_depends})
cu_gcc_string_1byte_align(COMPONENTS ${app_lto_components} ${idf_lto_components}
DEPENDS ${lto_depends})
```
Build the project and the firmware size is:
Option | Firmware size |
|:-:|:-:|
-Os + LTO | 1,020,640 |
-Os + LTO + string 1-byte align | 1,018,340 |

View File

@@ -0,0 +1,41 @@
# Gen Compressed OTA
When using the compressed OTA, we need to generate the compressed app firmware. This document mainly describes how to generate the compressed app firmware.
For more information about compressed OTA, refer to [bootloader_support_plus](https://github.com/espressif/esp-iot-solution/tree/master/components/bootloader_support_plus).
## Use
In order to use this feature, you need to include the needed CMake file in your project's CMakeLists.txt after `project(XXXX)`.
```cmake
project(XXXX)
include(gen_compressed_ota)
```
Generate the compressed app firmware in an ESP-IDF "project" directory by running:
```plaintext
idf.py gen_compressed_ota
```
This command will compile your project first, then it will generate the compressed app firmware. For example, run the command under the project `simple_ota_examples` folder. If there are no errors, the `custom_ota_binaries` folder will be created and contains the following files:
```plaintext
simple_ota.bin.xz
simple_ota.bin.xz.packed
```
The file named `simple_ota.bin.xz.packed` is the actual compressed app binary file to be transferred.
In addition, if [secure boot](https://docs.espressif.com/projects/esp-idf/en/latest/esp32c3/security/secure-boot-v2.html) is enabled, the command will generate the signed compressed app binary file:
```plaintext
simple_ota.bin.xz.packed.signed
```
you can also use the script [gen_custom_ota.py](https://github.com/espressif/esp-iot-solution/tree/master/tools/cmake_utilities/scripts/gen_custom_ota.py) to compress the specified app:
```plaintext
python3 gen_custom_ota.py -i simple_ota.bin
```

View File

@@ -0,0 +1,66 @@
# Relinker
In ESP-IDF, some functions are put in SRAM when link stage, the reason is that some functions are critical, we need to put them in SRAM to speed up the program, or the functions will be executed when the cache is disabled. But actually, some functions can be put into Flash, here, we provide a script to let the user set the functions which are located in SRAM by default to put them into Flash, in order to save more SRAM which can be used as heap region later. This happens in the linker stage, so we call it as relinker.
## Use
In order to use this feature, you need to include the needed CMake file in your project's CMakeLists.txt after `project(XXXX)`.
```cmake
project(XXXX)
include(relinker)
```
The relinker feature is disabled by default, in order to use it, you need to enable the option `CU_RELINKER_ENABLE` in menuconfig.
Here are the default configuration files in the folder `cmake_utilities/scripts/relinker/examples/esp32c2`, it's just used as a reference. If you would like to use your own configuration files, please enable option `CU_RELINKER_ENABLE_CUSTOMIZED_CONFIGURATION_FILES` and set the path of your configuration files as following, this path is evaluated relative to the project root directory:
```
[*] Enable customized relinker configuration files
(path of your configuration files) Customized relinker configuration files path
```
> Note: Currently only esp32c2 is supported.
## Configuration Files
You can refer to the files in the directory of `cmake_utilities/scripts/relinker/examples/esp32c2`:
- library.csv
- object.csv
- function.csv
For example, if you want to link function `__getreent` from SRAM to Flash, firstly you should add it to `function.csv` file as following:
```
libfreertos.a,tasks.c.obj,__getreent,
```
This means function `__getreent` is in object file `tasks.c.obj`, and object file `tasks.c.obj` is in library `libfreertos.a`.
If function `__getreent` depends on the option `FREERTOS_PLACE_FUNCTIONS_INTO_FLASH` in menuconfig, then it should be:
```
libfreertos.a,tasks.c.obj,__getreent,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
```
This means when only `FREERTOS_PLACE_FUNCTIONS_INTO_FLASH` is enabled in menuconfig, function `__getreent` will be linked from SRAM to Flash.
Next step you should add the path of the object file to `object.csv`:
```
libfreertos.a,tasks.c.obj,esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/tasks.c.obj
```
This means the object file `tasks.c.obj` is in library `libfreertos.a` and its location is `esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/tasks.c.obj` relative to directory of `build`.
Next step you should add path of library to `library.csv`:
```
libfreertos.a,./esp-idf/freertos/libfreertos.a
```
This means library `libfreertos.a`'s location is `./esp-idf/freertos/libfreertos.a` relative to `build`.
If above related data has exists in corresponding files, please don't add this repeatedly.

View File

@@ -0,0 +1,84 @@
if(CONFIG_CU_GCC_LTO_ENABLE)
# Enable cmake interprocedural optimization(IPO) support to check if GCC supports link time optimization(LTO)
cmake_policy(SET CMP0069 NEW)
include(CheckIPOSupported)
# Compare to "ar" and "ranlib", "gcc-ar" and "gcc-ranlib" integrate GCC LTO plugin
set(CMAKE_AR ${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar)
set(CMAKE_RANLIB ${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib)
macro(cu_gcc_lto_set)
check_ipo_supported(RESULT result)
if(result)
message(STATUS "GCC link time optimization(LTO) is enable")
set(multi_value COMPONENTS DEPENDS)
cmake_parse_arguments(LTO "" "" "${multi_value}" ${ARGN})
# Use full format LTO object file
set(GCC_LTO_OBJECT_TYPE "-ffat-lto-objects")
# Set compression level 9(min:0, max:9)
set(GCC_LTO_COMPRESSION_LEVEL "-flto-compression-level=9")
# Set partition level max to removed used symbol
set(GCC_LTO_PARTITION_LEVEL "-flto-partition=max")
# Set mode "auto" to increase compiling speed
set(GCC_LTO_COMPILE_OPTIONS "-flto=auto"
${GCC_LTO_OBJECT_TYPE}
${GCC_LTO_COMPRESSION_LEVEL})
# Enable GCC LTO and plugin when linking stage
set(GCC_LTO_LINK_OPTIONS "-flto"
"-fuse-linker-plugin"
${GCC_LTO_OBJECT_TYPE}
${GCC_LTO_PARTITION_LEVEL})
message(STATUS "GCC LTO for components: ${LTO_COMPONENTS}")
foreach(c ${LTO_COMPONENTS})
idf_component_get_property(t ${c} COMPONENT_LIB)
target_compile_options(${t} PRIVATE ${GCC_LTO_COMPILE_OPTIONS})
endforeach()
message(STATUS "GCC LTO for dependencies: ${LTO_DEPENDS}")
foreach(d ${LTO_DEPENDS})
target_compile_options(${d} PRIVATE ${GCC_LTO_COMPILE_OPTIONS})
endforeach()
if("${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}" VERSION_GREATER_EQUAL "4.4")
target_link_libraries(${project_elf} PRIVATE ${GCC_LTO_LINK_OPTIONS})
else()
target_link_libraries(${project_elf} ${GCC_LTO_LINK_OPTIONS})
endif()
else()
message(FATAL_ERROR "GCC link time optimization(LTO) is not supported")
endif()
endmacro()
else()
macro(cu_gcc_lto_set)
message(STATUS "GCC link time optimization(LTO) is not enable")
endmacro()
endif()
if(CONFIG_CU_GCC_STRING_1BYTE_ALIGN)
macro(cu_gcc_string_1byte_align)
message(STATUS "GCC string 1-byte align is enable")
set(multi_value COMPONENTS DEPENDS)
cmake_parse_arguments(STR_ALIGN "" "" "${multi_value}" ${ARGN})
message(STATUS "GCC string 1-byte align for components: ${STR_ALIGN_COMPONENTS}")
foreach(c ${STR_ALIGN_COMPONENTS})
idf_component_get_property(t ${c} COMPONENT_LIB)
target_compile_options(${t} PRIVATE "-malign-data=natural")
endforeach()
message(STATUS "GCC string 1-byte align for dependencies: ${STR_ALIGN_DEPENDS}")
foreach(d ${STR_ALIGN_DEPENDS})
target_compile_options(${d} PRIVATE "-malign-data=natural")
endforeach()
endmacro()
else()
macro(cu_gcc_string_1byte_align)
message(STATUS "GCC string 1-byte align is not enable")
endmacro()
endif()

View File

@@ -0,0 +1,18 @@
if (NOT TARGET gen_compressed_ota)
add_custom_target(gen_compressed_ota)
if (CONFIG_SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT OR CONFIG_SECURE_BOOT_V2_ENABLED)
set(COMPRESSED_OTA_BIN_SIGN_PARA --sign_key ${PROJECT_DIR}/${CONFIG_SECURE_BOOT_SIGNING_KEY})
else()
set(COMPRESSED_OTA_BIN_SIGN_PARA )
endif()
set(GEN_COMPRESSED_BIN_CMD ${CMAKE_CURRENT_LIST_DIR}/scripts/gen_custom_ota.py ${COMPRESSED_OTA_BIN_SIGN_PARA} --add_app_header)
add_custom_command(TARGET gen_compressed_ota
POST_BUILD
COMMAND ${PYTHON} ${GEN_COMPRESSED_BIN_CMD}
COMMENT "The gen compresssed bin cmd is: ${GEN_COMPRESSED_BIN_CMD}"
)
add_dependencies(gen_compressed_ota gen_project_binary)
endif()

View File

@@ -0,0 +1,27 @@
# Extend command to idf.py
# Generate single bin with name ${CMAKE_PROJECT_NAME}_merged.bin
if (NOT TARGET gen_single_bin)
add_custom_target(
gen_single_bin
COMMAND ${CMAKE_COMMAND} -E echo "Merge bin files to ${CMAKE_PROJECT_NAME}_merged.bin"
COMMAND ${ESPTOOLPY} --chip ${IDF_TARGET} merge_bin -o ${CMAKE_PROJECT_NAME}_merged.bin @flash_args
COMMAND ${CMAKE_COMMAND} -E echo "Merge bin done"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
DEPENDS gen_project_binary bootloader
VERBATIM USES_TERMINAL
)
endif()
# Flash bin ${CMAKE_PROJECT_NAME}_merged.bin to target chip
if (NOT TARGET flash_single_bin)
add_custom_target(
flash_single_bin
COMMAND ${CMAKE_COMMAND} -E echo "Flash merged bin ${CMAKE_PROJECT_NAME}_merged.bin to address 0x0"
COMMAND ${ESPTOOLPY} --chip ${IDF_TARGET} write_flash 0x0 ${CMAKE_PROJECT_NAME}_merged.bin
COMMAND ${CMAKE_COMMAND} -E echo "Flash merged bin done"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
DEPENDS gen_single_bin
VERBATIM USES_TERMINAL
)
endif()

View File

@@ -0,0 +1,7 @@
dependencies:
idf:
version: '>=4.1'
description: A collection of useful cmake utilities
issues: https://github.com/espressif/esp-iot-solution/issues
url: https://github.com/espressif/esp-iot-solution/tree/master/tools/cmake_utilities
version: 0.5.3

View File

@@ -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.

View File

@@ -0,0 +1,45 @@
# cu_pkg_get_version
#
# @brief Get the package's version information, the package is installed by component manager.
#
# @param[in] pkg_path the package's path, normally it's ${CMAKE_CURRENT_LIST_DIR}.
#
# @param[out] ver_major the major version of the package
# @param[out] ver_minor the minor version of the package
# @param[out] ver_patch the patch version of the package
function(cu_pkg_get_version pkg_path ver_major ver_minor ver_patch)
set(yml_file "${pkg_path}/idf_component.yml")
if(EXISTS ${yml_file})
file(READ ${yml_file} ver)
string(REGEX MATCH "(^|\n)version: \"?([0-9]+).([0-9]+).([0-9]+)\"?" _ ${ver})
set(${ver_major} ${CMAKE_MATCH_2} PARENT_SCOPE)
set(${ver_minor} ${CMAKE_MATCH_3} PARENT_SCOPE)
set(${ver_patch} ${CMAKE_MATCH_4} PARENT_SCOPE)
else()
message(WARNING " ${yml_file} not exist")
endif()
endfunction()
# cu_pkg_define_version
#
# @brief Add the package's version definitions using format ${NAME}_VER_MAJOR ${NAME}_VER_MINOR ${NAME}_VER_PATCH,
# the ${NAME} will be inferred from package path, and namespace like `espressif__` will be removed if the package download from esp-registry
# eg. espressif__usb_stream and usb_stream will generate same version definitions USB_STREAM_VER_MAJOR ...
#
# @param[in] pkg_path the package's path, normally it's ${CMAKE_CURRENT_LIST_DIR}.
#
macro(cu_pkg_define_version pkg_path)
cu_pkg_get_version(${pkg_path} ver_major ver_minor ver_patch)
get_filename_component(pkg_name ${pkg_path} NAME)
string(FIND ${pkg_name} "__" pkg_name_pos)
if(pkg_name_pos GREATER -1)
math(EXPR pkg_name_pos "${pkg_name_pos} + 2")
string(SUBSTRING ${pkg_name} ${pkg_name_pos} -1 pkg_name)
endif()
string(TOUPPER ${pkg_name} pkg_name)
string(REPLACE "-" "_" pkg_name ${pkg_name})
message(STATUS "${pkg_name}: ${ver_major}.${ver_minor}.${ver_patch}")
list(LENGTH pkg_name_list len)
target_compile_options(${COMPONENT_LIB} PUBLIC
-D${pkg_name}_VER_MAJOR=${ver_major} -D${pkg_name}_VER_MINOR=${ver_minor} -D${pkg_name}_VER_PATCH=${ver_patch})
endmacro()

View File

@@ -0,0 +1,9 @@
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_MODULE_PATH})
if(CONFIG_CU_DIAGNOSTICS_COLOR_ALWAYS)
add_compile_options(-fdiagnostics-color=always)
elseif(CONFIG_CU_DIAGNOSTICS_COLOR_AUTO)
add_compile_options(-fdiagnostics-color=auto)
elseif(CONFIG_CU_DIAGNOSTICS_COLOR_NEVER)
add_compile_options(-fdiagnostics-color=never)
endif()

View File

@@ -0,0 +1,73 @@
# @brief Link designated functions from SRAM to Flash to save SRAM
if(CONFIG_CU_RELINKER_ENABLE)
# project_elf variable is only in project.cmake
if(NOT TARGET customer_sections AND DEFINED project_elf)
message(STATUS "Relinker is enabled.")
if(CONFIG_IDF_TARGET_ESP32C2)
set(target "esp32c2")
else()
message(FATAL_ERROR "Other targets are not supported.")
endif()
if(CONFIG_CU_RELINKER_ENABLE_CUSTOMIZED_CONFIGURATION_FILES)
idf_build_get_property(project_dir PROJECT_DIR)
get_filename_component(cfg_file_path "${CONFIG_CU_RELINKER_CUSTOMIZED_CONFIGURATION_FILES_PATH}"
ABSOLUTE BASE_DIR "${project_dir}")
if(NOT EXISTS "${cfg_file_path}")
message(FATAL_ERROR "Relinker Configuration files path ${cfg_file_path} is not found.")
endif()
else()
set(cfg_file_path ${PROJECT_DIR}/relinker/${target})
if(NOT EXISTS ${cfg_file_path})
set(cfg_file_path ${CMAKE_CURRENT_LIST_DIR}/scripts/relinker/examples/${target})
endif()
endif()
message(STATUS "Relinker configuration files: ${cfg_file_path}")
set(library_file "${cfg_file_path}/library.csv")
set(object_file "${cfg_file_path}/object.csv")
set(function_file "${cfg_file_path}/function.csv")
set(relinker_script "${CMAKE_CURRENT_LIST_DIR}/scripts/relinker/relinker.py")
set(cmake_objdump "${CMAKE_OBJDUMP}")
set(link_path "${CMAKE_BINARY_DIR}/esp-idf/esp_system/ld")
set(link_src_file "${link_path}/sections.ld")
set(link_dst_file "${link_path}/customer_sections.ld")
set(relinker_opts --input ${link_src_file}
--output ${link_dst_file}
--library ${library_file}
--object ${object_file}
--function ${function_file}
--sdkconfig ${sdkconfig}
--objdump ${cmake_objdump})
if(CONFIG_CU_RELINKER_ENABLE_PRINT_ERROR_INFO_WHEN_MISSING_FUNCTION)
list(APPEND relinker_opts --missing_function_info True)
endif()
idf_build_get_property(link_depends __LINK_DEPENDS)
add_custom_command(OUTPUT ${link_dst_file}
COMMAND ${python} -B ${relinker_script}
${relinker_opts}
COMMAND ${CMAKE_COMMAND} -E copy
${link_dst_file}
${link_src_file}
COMMAND ${CMAKE_COMMAND} -E echo
/*relinker*/ >>
${link_dst_file}
DEPENDS "${link_depends}"
"${library_file}"
"${object_file}"
"${function_file}"
VERBATIM)
add_custom_target(customer_sections DEPENDS ${link_dst_file})
add_dependencies(${project_elf} customer_sections)
endif()
else()
message(STATUS "Relinker isn't enabled.")
endif()

View File

@@ -0,0 +1,243 @@
#!/usr/bin/env python
#
# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
#
# SPDX-License-Identifier: Apache-2.0
import sys
import struct
import argparse
import binascii
import hashlib
import os
import subprocess
import shutil
import json
import lzma
# src_file = 'hello-world.bin'
# compressed_file = 'hello-world.bin.xz'
# packed_compressed_file = 'hello-world.bin.xz.packed'
# siged_packed_compressed_file = 'hello-world.bin.xz.packed.signed'
binary_compress_type = {'none': 0, 'xz':1}
header_version = {'v1': 1, 'v2': 2, 'v3': 3}
SCRIPT_VERSION = '1.0.0'
ORIGIN_APP_IMAGE_HEADER_LEN = 288 # sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t). See esp_app_format.h
# At present, we calculate the checksum of the first 4KB data of the old app.
OLD_APP_CHECK_DATA_SIZE = 4096
# v1 compressed data header:
# Note: Encryption_type field is deprecated, the field is reserved for compatibility.
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|--------------|------------|
# | | Magic | header | Compress | delta | Encryption | Reserved | Firmware | The length of | The MD5 of | The CRC32 for| compressed |
# | | number | version | type | type | type | | version | compressed data| compressed data| the header | data |
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|--------------|------------|
# | Size | 4 bytes | 1 byte | 4 bits | 4 bits | 1 bytes | 1 bytes | 32 bytes | 4 bytes | 32 bytes | 4 bytes | |
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|--------------|------------|
# | Data | String | | | | | | String | little-endian | byte string | little-endian| |
# | type | ended | | | | | | ended | integer | | integer | |
# | |with ‘\0’| | | | | | with ‘\0’| | | | Binary data|
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|--------------|------------|
# | Data | “ESP” | 1 | 0/1 | 0/1 | | | | | | | |
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|--------------|------------|
# v2 compressed data header
# Note: Encryption_type field is deprecated, the field is reserved for compatibility.
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|---------------|---------------|--------------|------------|
# | | Magic | header | Compress | delta | Encryption | Reserved | Firmware | The length of | The MD5 of | base app check| The CRC32 for | The CRC32 for| compressed |
# | | number | version | type | type | type | | version | compressed data| compressed data| data len | base app data | the header | data |
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|---------------|---------------|--------------|------------|
# | Size | 4 bytes | 1 byte | 4 bits | 4 bits | 1 bytes | 1 bytes | 32 bytes | 4 bytes | 32 bytes | 4 bytes | 4 bytes | 4 bytes | |
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|---------------|---------------|--------------|------------|
# | Data | String | | | | | | String | little-endian | byte string | little-endian | little-endian | little-endian| |
# | type | ended | | | | | | ended | integer | | integer | integer | integer | |
# | |with ‘\0’| | | | | | with ‘\0’| | | | | | Binary data|
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|---------------|---------------|--------------|------------|
# | Data | “ESP” | 1 | 0/1 | 0/1 | | | | | | | | | |
# |------|---------|---------|----------|------------|------------|-----------|----------|----------------|----------------|---------------|---------------|--------------|------------|
# v3 compressed data header:
# |------|---------|---------|----------|------------|-----------|----------------|----------------|--------------|------------|
# | | Magic | header | Compress | Reserved | Reserved | The length of | The MD5 of | The CRC32 for| compressed |
# | | number | version | type | | | compressed data| compressed data| the header | data |
# |------|---------|---------|----------|------------|-----------|----------------|----------------|--------------|------------|
# | Size | 4 bytes | 1 byte | 4 bits | 4 bits | 8 bytes | 4 bytes | 16 bytes | 4 bytes | |
# |------|---------|---------|----------|------------|-----------|----------------|----------------|--------------|------------|
# | Data | String | integer | | | | little-endian | byte string | little-endian| |
# | type | ended | | | | | integer | | integer | |
# | |with ‘\0’| | | | | | | | Binary data|
# |------|---------|---------|----------|------------|-----------|----------------|----------------|--------------|------------|
# | Data | “ESP” | 3 | 0/1 | | | | | | |
# |------|---------|---------|----------|------------|-----------|----------------|----------------|--------------|------------|
def xz_compress(store_directory, in_file):
compressed_file = ''.join([in_file,'.xz'])
if(os.path.exists(compressed_file)):
os.remove(compressed_file)
xz_compressor_filter = [
{"id": lzma.FILTER_LZMA2, "preset": 6, "dict_size": 64*1024},
]
with open(in_file, 'rb') as src_f:
data = src_f.read()
with lzma.open(compressed_file, "wb", format=lzma.FORMAT_XZ, check=lzma.CHECK_CRC32, filters=xz_compressor_filter) as f:
f.write(data)
f.close()
if not os.path.exists(os.path.join(store_directory, os.path.split(compressed_file)[1])):
shutil.copy(compressed_file, store_directory)
print('copy xz file done')
def secure_boot_sign(sign_key, in_file, out_file):
ret = subprocess.call('espsecure.py sign_data --version 2 --keyfile {} --output {} {}'.format(sign_key, out_file, in_file), shell = True)
if ret:
raise Exception('sign failed')
def get_app_name():
with open('flasher_args.json') as f:
try:
flasher_args = json.load(f)
return flasher_args['app']['file']
except Exception as e:
print(e)
return ''
def get_script_version():
return SCRIPT_VERSION
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-hv', '--header_ver', nargs='?', choices = ['v1', 'v2', 'v3'],
default='v3', help='the version of the packed file header [default:v3]')
parser.add_argument('-c', '--compress_type', nargs= '?', choices = ['none', 'xz'],
default='xz', help='compressed type [default:xz]')
parser.add_argument('-i', '--in_file', nargs = '?',
default='', help='the new app firmware')
parser.add_argument('--sign_key', nargs = '?',
default='', help='the sign key used for secure boot')
parser.add_argument('-fv', '--fw_ver', nargs='?',
default='', help='the version of the compressed data(this field is deprecated in v3)')
parser.add_argument('--add_app_header', action="store_true", help='add app header to use native esp_ota_* & esp_https_ota_* APIs')
parser.add_argument('-v', '--version', action='version', version=get_script_version(), help='the version of the script')
args = parser.parse_args()
compress_type = args.compress_type
firmware_ver = args.fw_ver
src_file = args.in_file
sign_key = args.sign_key
header_ver = args.header_ver
add_app_header = args.add_app_header
if src_file == '':
origin_app_name = get_app_name()
if(origin_app_name == ''):
print('get origin app name fail')
return
if os.path.exists(origin_app_name):
src_file = origin_app_name
else:
print('origin app.bin not found')
return
print('src file is: {}'.format(src_file))
# rebuild the cpmpressed_app directroy
cpmoressed_app_directory = 'custom_ota_binaries'
if os.path.exists(cpmoressed_app_directory):
shutil.rmtree(cpmoressed_app_directory)
os.mkdir(cpmoressed_app_directory)
print('The compressed file will store in {}'.format(cpmoressed_app_directory))
#step1: compress
if compress_type == 'xz':
xz_compress(cpmoressed_app_directory, os.path.abspath(src_file))
origin_app_name = os.path.split(src_file)[1]
compressed_file_name = ''.join([origin_app_name, '.xz'])
compressed_file = os.path.join(cpmoressed_app_directory, compressed_file_name)
else:
compressed_file = ''.join(src_file)
print('compressed file is: {}'.format(compressed_file))
#step2: packet the compressed image header
with open(src_file, 'rb') as s_f:
src_image_header = bytearray(s_f.read(ORIGIN_APP_IMAGE_HEADER_LEN))
src_image_header[1] = 0x00
packed_file = ''.join([compressed_file,'.packed'])
with open(compressed_file, 'rb') as src_f:
data = src_f.read()
f_len = src_f.tell()
# magic number
bin_data = struct.pack('4s', b'ESP')
# header version
bin_data += struct.pack('B', header_version[header_ver])
# Compress type
bin_data += struct.pack('B', binary_compress_type[compress_type])
print('compressed type: {}'.format(binary_compress_type[compress_type]))
# in header v1/v2, there is a field "Encryption type", this field has been deprecated in v3
if (header_version[header_ver] < 3):
bin_data += struct.pack('B', 0)
# Reserved
bin_data += struct.pack('?', 0)
# Firmware version
bin_data += struct.pack('32s', firmware_ver.encode())
else:
# Reserved
bin_data += struct.pack('10s', b'0')
# The length of the compressed data
bin_data += struct.pack('<I', f_len)
print('compressed data len: {}'.format(f_len))
# The MD5 for the compressed data
if (header_version[header_ver] < 3):
bin_data += struct.pack('32s', hashlib.md5(data).digest())
if (header_version[header_ver] == 2):
# Todo, if it's diff OTA, write base app check data len
bin_data += struct.pack('<I', 0)
# Todo, if it's diff OTA, write base app crc32 checksum
bin_data += struct.pack('<I', 0)
else:
bin_data += struct.pack('16s', hashlib.md5(data).digest())
# The CRC32 for the header
bin_data += struct.pack('<I', binascii.crc32(bin_data, 0x0))
# write compressed data
bin_data += data
with open(packed_file, 'wb') as dst_f:
# write compressed image header and compressed dada
dst_f.write(bin_data)
print('packed file is: {}'.format(packed_file))
#step3: if need sign, then sign the packed image
if sign_key != '':
signed_file = ''.join([packed_file,'.signed'])
secure_boot_sign(sign_key, packed_file, signed_file)
print('signed_file is: {}'.format(signed_file))
else:
signed_file = ''.join(packed_file)
if (header_version[header_ver] == 3) and add_app_header:
with open(signed_file, 'rb+') as src_f:
packed_data = src_f.read()
src_f.seek(0)
# write origin app image header
src_f.write(src_image_header)
# write compressed image header and compressed dada
src_f.write(packed_data)
print('app image header has been added')
if __name__ == '__main__':
try:
main()
except Exception as e:
print(e)
sys.exit(2)

View File

@@ -0,0 +1,211 @@
#!/usr/bin/env python3
#
# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import argparse
import csv
import os
import subprocess
import sys
import re
from io import StringIO
OPT_MIN_LEN = 7
espidf_objdump = None
espidf_missing_function_info = True
class sdkconfig_c:
def __init__(self, path):
lines = open(path).read().splitlines()
config = dict()
for l in lines:
if len(l) > OPT_MIN_LEN and l[0] != '#':
mo = re.match( r'(.*)=(.*)', l, re.M|re.I)
if mo:
config[mo.group(1)]=mo.group(2).replace('"', '')
self.config = config
def index(self, i):
return self.config[i]
def check(self, options):
options = options.replace(' ', '')
if '&&' in options:
for i in options.split('&&'):
if i[0] == '!':
i = i[1:]
if i in self.config:
return False
else:
if i not in self.config:
return False
else:
i = options
if i[0] == '!':
i = i[1:]
if i in self.config:
return False
else:
if i not in self.config:
return False
return True
class object_c:
def read_dump_info(self, pathes):
new_env = os.environ.copy()
new_env['LC_ALL'] = 'C'
dumps = list()
print('pathes:', pathes)
for path in pathes:
try:
dump = StringIO(subprocess.check_output([espidf_objdump, '-t', path], env=new_env).decode())
dumps.append(dump.readlines())
except subprocess.CalledProcessError as e:
raise RuntimeError('cmd:%s result:%s'%(e.cmd, e.returncode))
return dumps
def get_func_section(self, dumps, func):
for dump in dumps:
for l in dump:
if ' %s'%(func) in l and '*UND*' not in l:
m = re.match(r'(\S*)\s*([glw])\s*([F|O])\s*(\S*)\s*(\S*)\s*(\S*)\s*', l, re.M|re.I)
if m and m[6] == func:
return m[4].replace('.text.', '')
if espidf_missing_function_info:
print('%s failed to find section'%(func))
return None
else:
raise RuntimeError('%s failed to find section'%(func))
def __init__(self, name, pathes, libray):
self.name = name
self.libray = libray
self.funcs = dict()
self.pathes = pathes
self.dumps = self.read_dump_info(pathes)
def append(self, func):
section = self.get_func_section(self.dumps, func)
if section != None:
self.funcs[func] = section
def functions(self):
nlist = list()
for i in self.funcs:
nlist.append(i)
return nlist
def sections(self):
nlist = list()
for i in self.funcs:
nlist.append(self.funcs[i])
return nlist
class library_c:
def __init__(self, name, path):
self.name = name
self.path = path
self.objs = dict()
def append(self, obj, path, func):
if obj not in self.objs:
self.objs[obj] = object_c(obj, path, self.name)
self.objs[obj].append(func)
class libraries_c:
def __init__(self):
self.libs = dict()
def append(self, lib, lib_path, obj, obj_path, func):
if lib not in self.libs:
self.libs[lib] = library_c(lib, lib_path)
self.libs[lib].append(obj, obj_path, func)
def dump(self):
for libname in self.libs:
lib = self.libs[libname]
for objname in lib.objs:
obj = lib.objs[objname]
print('%s, %s, %s, %s'%(libname, objname, obj.path, obj.funcs))
class paths_c:
def __init__(self):
self.paths = dict()
def append(self, lib, obj, path):
if '$IDF_PATH' in path:
path = path.replace('$IDF_PATH', os.environ['IDF_PATH'])
if lib not in self.paths:
self.paths[lib] = dict()
if obj not in self.paths[lib]:
self.paths[lib][obj] = list()
self.paths[lib][obj].append(path)
def index(self, lib, obj):
if lib not in self.paths:
return None
if '*' in self.paths[lib]:
obj = '*'
return self.paths[lib][obj]
def generator(library_file, object_file, function_file, sdkconfig_file, missing_function_info, objdump='riscv32-esp-elf-objdump'):
global espidf_objdump, espidf_missing_function_info
espidf_objdump = objdump
espidf_missing_function_info = missing_function_info
sdkconfig = sdkconfig_c(sdkconfig_file)
lib_paths = paths_c()
for p in csv.DictReader(open(library_file, 'r')):
lib_paths.append(p['library'], '*', p['path'])
obj_paths = paths_c()
for p in csv.DictReader(open(object_file, 'r')):
obj_paths.append(p['library'], p['object'], p['path'])
libraries = libraries_c()
for d in csv.DictReader(open(function_file, 'r')):
if d['option'] and sdkconfig.check(d['option']) == False:
print('skip %s(%s)'%(d['function'], d['option']))
continue
lib_path = lib_paths.index(d['library'], '*')
obj_path = obj_paths.index(d['library'], d['object'])
if not obj_path:
obj_path = lib_path
libraries.append(d['library'], lib_path[0], d['object'], obj_path, d['function'])
return libraries
def main():
argparser = argparse.ArgumentParser(description='Libraries management')
argparser.add_argument(
'--library', '-l',
help='Library description file',
type=str)
argparser.add_argument(
'--object', '-b',
help='Object description file',
type=str)
argparser.add_argument(
'--function', '-f',
help='Function description file',
type=str)
argparser.add_argument(
'--sdkconfig', '-s',
help='sdkconfig file',
type=str)
args = argparser.parse_args()
libraries = generator(args.library, args.object, args.function, args.sdkconfig)
# libraries.dump()
if __name__ == '__main__':
main()

View File

@@ -0,0 +1,365 @@
library,object,function,option
libble_app.a,ble_hw.c.o,r_ble_hw_resolv_list_get_cur_entry,
libble_app.a,ble_ll_adv.c.o,r_ble_ll_adv_set_sched,
libble_app.a,ble_ll_adv.c.o,r_ble_ll_adv_sync_pdu_make,
libble_app.a,ble_ll_adv.c.o,r_ble_ll_adv_sync_calculate,
libble_app.a,ble_ll_conn.c.o,r_ble_ll_conn_is_dev_connected,
libble_app.a,ble_ll_ctrl.c.o,r_ble_ll_ctrl_tx_done,
libble_app.a,ble_lll_adv.c.o,r_ble_lll_adv_aux_scannable_pdu_payload_len,
libble_app.a,ble_lll_adv.c.o,r_ble_lll_adv_halt,
libble_app.a,ble_lll_adv.c.o,r_ble_lll_adv_periodic_schedule_next,
libble_app.a,ble_lll_conn.c.o,r_ble_lll_conn_cth_flow_free_credit,
libble_app.a,ble_lll_conn.c.o,r_ble_lll_conn_update_encryption,
libble_app.a,ble_lll_conn.c.o,r_ble_lll_conn_set_slave_flow_control,
libble_app.a,ble_lll_conn.c.o,r_ble_lll_init_rx_pkt_isr,
libble_app.a,ble_lll_conn.c.o,r_ble_lll_conn_get_rx_mbuf,
libble_app.a,ble_lll_rfmgmt.c.o,r_ble_lll_rfmgmt_enable,
libble_app.a,ble_lll_rfmgmt.c.o,r_ble_lll_rfmgmt_timer_reschedule,
libble_app.a,ble_lll_rfmgmt.c.o,r_ble_lll_rfmgmt_timer_exp,
libble_app.a,ble_lll_scan.c.o,r_ble_lll_scan_targeta_is_matched,
libble_app.a,ble_lll_scan.c.o,r_ble_lll_scan_rx_isr_on_legacy,
libble_app.a,ble_lll_scan.c.o,r_ble_lll_scan_rx_isr_on_aux,
libble_app.a,ble_lll_scan.c.o,r_ble_lll_scan_process_rsp_in_isr,
libble_app.a,ble_lll_scan.c.o,r_ble_lll_scan_rx_pkt_isr,
libble_app.a,ble_lll_sched.c.o,r_ble_lll_sched_execute_check,
libble_app.a,ble_lll_sync.c.o,r_ble_lll_sync_event_start_cb,
libble_app.a,ble_phy.c.o,r_ble_phy_set_rxhdr,
libble_app.a,ble_phy.c.o,r_ble_phy_update_conn_sequence,
libble_app.a,ble_phy.c.o,r_ble_phy_set_sequence_mode,
libble_app.a,ble_phy.c.o,r_ble_phy_txpower_round,
libble_app.a,os_mempool.c.obj,r_os_memblock_put,
libbootloader_support.a,bootloader_flash.c.obj,bootloader_read_flash_id,
libbootloader_support.a,flash_encrypt.c.obj,esp_flash_encryption_enabled,
libbt.a,bt_osi_mem.c.obj,bt_osi_mem_calloc,CONFIG_BT_ENABLED
libbt.a,bt_osi_mem.c.obj,bt_osi_mem_malloc,CONFIG_BT_ENABLED
libbt.a,bt_osi_mem.c.obj,bt_osi_mem_malloc_internal,CONFIG_BT_ENABLED
libbt.a,bt_osi_mem.c.obj,bt_osi_mem_free,CONFIG_BT_ENABLED
libbt.a,bt.c.obj,esp_reset_rpa_moudle,CONFIG_BT_ENABLED
libbt.a,bt.c.obj,osi_assert_wrapper,CONFIG_BT_ENABLED
libbt.a,bt.c.obj,osi_random_wrapper,CONFIG_BT_ENABLED
libbt.a,nimble_port.c.obj,nimble_port_run,CONFIG_BT_NIMBLE_ENABLED
libbt.a,nimble_port.c.obj,nimble_port_get_dflt_eventq,CONFIG_BT_NIMBLE_ENABLED
libbt.a,npl_os_freertos.c.obj,os_callout_timer_cb,CONFIG_BT_ENABLED && !CONFIG_BT_NIMBLE_USE_ESP_TIMER
libbt.a,npl_os_freertos.c.obj,npl_freertos_event_run,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_stop,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_time_get,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_reset,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_is_active,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_get_ticks,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_remaining_ticks,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_time_delay,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_eventq_is_empty,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_mutex_pend,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_mutex_release,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_sem_init,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_sem_pend,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_sem_release,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_init,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_deinit,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_event_is_queued,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_event_get_arg,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_time_ms_to_ticks32,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_time_ticks_to_ms32,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_hw_is_in_critical,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_get_time_forever,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_os_started,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_get_current_task_id,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_event_reset,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_mem_reset,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_event_init,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_sem_get_count,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_eventq_remove,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_hw_exit_critical,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_mutex_init,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_hw_enter_critical,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_eventq_put,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_eventq_get,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_sem_deinit,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_mutex_deinit,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_eventq_deinit,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_eventq_init,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_event_deinit,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_time_ticks_to_ms,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_time_ms_to_ticks,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_callout_set_arg,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_event_set_arg,CONFIG_BT_ENABLED
libbt.a,npl_os_freertos.c.obj,npl_freertos_eventq_put,CONFIG_BT_ENABLED
libdriver.a,gpio.c.obj,gpio_intr_service,
libesp_app_format.a,esp_app_desc.c.obj,esp_app_get_elf_sha256,
libesp_hw_support.a,cpu.c.obj,esp_cpu_wait_for_intr,
libesp_hw_support.a,cpu.c.obj,esp_cpu_reset,
libesp_hw_support.a,esp_clk.c.obj,esp_clk_cpu_freq,
libesp_hw_support.a,esp_clk.c.obj,esp_clk_apb_freq,
libesp_hw_support.a,esp_clk.c.obj,esp_clk_xtal_freq,
libesp_hw_support.a,esp_memory_utils.c.obj,esp_ptr_byte_accessible,
libesp_hw_support.a,hw_random.c.obj,esp_random,
libesp_hw_support.a,intr_alloc.c.obj,shared_intr_isr,
libesp_hw_support.a,intr_alloc.c.obj,esp_intr_noniram_disable,
libesp_hw_support.a,intr_alloc.c.obj,esp_intr_noniram_enable,
libesp_hw_support.a,intr_alloc.c.obj,esp_intr_enable,
libesp_hw_support.a,intr_alloc.c.obj,esp_intr_disable,
libesp_hw_support.a,periph_ctrl.c.obj,wifi_bt_common_module_enable,
libesp_hw_support.a,periph_ctrl.c.obj,wifi_bt_common_module_disable,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_ctrl_read_reg,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_ctrl_read_reg_mask,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_ctrl_write_reg,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_ctrl_write_reg_mask,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_enter_critical,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_exit_critical,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_analog_cali_reg_read,
libesp_hw_support.a,regi2c_ctrl.c.obj,regi2c_analog_cali_reg_write,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_32k_enable_external,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_fast_src_set,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_slow_freq_get_hz,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_slow_src_get,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_slow_src_set,
libesp_hw_support.a,rtc_clk.c.obj,rtc_dig_clk8m_disable,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_set_config_fast,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_8m_enable,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_8md256_enabled,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_bbpll_configure,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_bbpll_enable,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_get_config,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_mhz_to_config,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_set_config,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_to_8m,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_to_pll_mhz,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_set_xtal,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_xtal_freq_get,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_cpu_freq_to_xtal,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_bbpll_disable,
libesp_hw_support.a,rtc_clk.c.obj,rtc_clk_apb_freq_update,
libesp_hw_support.a,rtc_clk.c.obj,clk_ll_rtc_slow_get_src,FALSE
libesp_hw_support.a,rtc_init.c.obj,rtc_vddsdio_set_config,
libesp_hw_support.a,rtc_module.c.obj,rtc_isr,
libesp_hw_support.a,rtc_module.c.obj,rtc_isr_noniram_disable,
libesp_hw_support.a,rtc_module.c.obj,rtc_isr_noniram_enable,
libesp_hw_support.a,rtc_sleep.c.obj,rtc_sleep_pu,
libesp_hw_support.a,rtc_sleep.c.obj,rtc_sleep_finish,
libesp_hw_support.a,rtc_sleep.c.obj,rtc_sleep_get_default_config,
libesp_hw_support.a,rtc_sleep.c.obj,rtc_sleep_init,
libesp_hw_support.a,rtc_sleep.c.obj,rtc_sleep_low_init,
libesp_hw_support.a,rtc_sleep.c.obj,rtc_sleep_start,
libesp_hw_support.a,rtc_time.c.obj,rtc_clk_cal,
libesp_hw_support.a,rtc_time.c.obj,rtc_clk_cal_internal,
libesp_hw_support.a,rtc_time.c.obj,rtc_time_get,
libesp_hw_support.a,rtc_time.c.obj,rtc_time_us_to_slowclk,
libesp_hw_support.a,rtc_time.c.obj,rtc_time_slowclk_to_us,
libesp_hw_support.a,sleep_modes.c.obj,periph_ll_periph_enabled,
libesp_hw_support.a,sleep_modes.c.obj,flush_uarts,
libesp_hw_support.a,sleep_modes.c.obj,suspend_uarts,
libesp_hw_support.a,sleep_modes.c.obj,resume_uarts,
libesp_hw_support.a,sleep_modes.c.obj,esp_sleep_start,
libesp_hw_support.a,sleep_modes.c.obj,esp_deep_sleep_start,
libesp_hw_support.a,sleep_modes.c.obj,esp_light_sleep_inner,
libesp_phy.a,phy_init.c.obj,esp_phy_common_clock_enable,
libesp_phy.a,phy_init.c.obj,esp_phy_common_clock_disable,
libesp_phy.a,phy_init.c.obj,esp_wifi_bt_power_domain_on,
libesp_phy.a,phy_override.c.obj,phy_i2c_enter_critical,
libesp_phy.a,phy_override.c.obj,phy_i2c_exit_critical,
libesp_pm.a,pm_locks.c.obj,esp_pm_lock_acquire,
libesp_pm.a,pm_locks.c.obj,esp_pm_lock_release,
libesp_pm.a,pm_impl.c.obj,get_lowest_allowed_mode,
libesp_pm.a,pm_impl.c.obj,esp_pm_impl_switch_mode,
libesp_pm.a,pm_impl.c.obj,on_freq_update,
libesp_pm.a,pm_impl.c.obj,vApplicationSleep,CONFIG_FREERTOS_USE_TICKLESS_IDLE
libesp_pm.a,pm_impl.c.obj,do_switch,
libesp_ringbuf.a,ringbuf.c.obj,prvCheckItemAvail,
libesp_ringbuf.a,ringbuf.c.obj,prvGetFreeSize,
libesp_ringbuf.a,ringbuf.c.obj,prvReceiveGenericFromISR,
libesp_ringbuf.a,ringbuf.c.obj,xRingbufferGetMaxItemSize,
libesp_rom.a,esp_rom_systimer.c.obj,systimer_hal_init,
libesp_rom.a,esp_rom_systimer.c.obj,systimer_hal_set_alarm_period,
libesp_rom.a,esp_rom_systimer.c.obj,systimer_hal_set_alarm_target,
libesp_rom.a,esp_rom_systimer.c.obj,systimer_hal_set_tick_rate_ops,
libesp_rom.a,esp_rom_uart.c.obj,esp_rom_uart_set_clock_baudrate,
libesp_system.a,brownout.c.obj,rtc_brownout_isr_handler,
libesp_system.a,cache_err_int.c.obj,esp_cache_err_get_cpuid,
libesp_system.a,cpu_start.c.obj,call_start_cpu0,
libesp_system.a,crosscore_int.c.obj,esp_crosscore_int_send,
libesp_system.a,crosscore_int.c.obj,esp_crosscore_int_send_yield,
libesp_system.a,esp_system.c.obj,esp_restart,
libesp_system.a,esp_system.c.obj,esp_system_abort,
libesp_system.a,reset_reason.c.obj,esp_reset_reason_set_hint,
libesp_system.a,reset_reason.c.obj,esp_reset_reason_get_hint,
libesp_system.a,ubsan.c.obj,__ubsan_include,
libesp_timer.a,esp_timer.c.obj,esp_timer_get_next_alarm_for_wake_up,
libesp_timer.a,esp_timer.c.obj,timer_list_unlock,!CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
libesp_timer.a,esp_timer.c.obj,timer_list_lock,!CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
libesp_timer.a,esp_timer.c.obj,timer_armed,
libesp_timer.a,esp_timer.c.obj,timer_remove,
libesp_timer.a,esp_timer.c.obj,timer_insert,!CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
libesp_timer.a,esp_timer.c.obj,esp_timer_start_once,
libesp_timer.a,esp_timer.c.obj,esp_timer_start_periodic,
libesp_timer.a,esp_timer.c.obj,esp_timer_stop,
libesp_timer.a,esp_timer.c.obj,esp_timer_get_expiry_time,
libesp_timer.a,esp_timer_impl_systimer.c.obj,esp_timer_impl_get_time,!CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
libesp_timer.a,esp_timer_impl_systimer.c.obj,esp_timer_impl_set_alarm_id,!CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
libesp_timer.a,esp_timer_impl_systimer.c.obj,esp_timer_impl_update_apb_freq,
libesp_timer.a,esp_timer_impl_systimer.c.obj,esp_timer_impl_get_min_period_us,
libesp_timer.a,ets_timer_legacy.c.obj,timer_initialized,
libesp_timer.a,ets_timer_legacy.c.obj,ets_timer_arm_us,
libesp_timer.a,ets_timer_legacy.c.obj,ets_timer_arm,
libesp_timer.a,ets_timer_legacy.c.obj,ets_timer_disarm,
libesp_timer.a,system_time.c.obj,esp_system_get_time,
libesp_wifi.a,esp_adapter.c.obj,semphr_take_from_isr_wrapper,
libesp_wifi.a,esp_adapter.c.obj,wifi_realloc,
libesp_wifi.a,esp_adapter.c.obj,coex_event_duration_get_wrapper,
libesp_wifi.a,esp_adapter.c.obj,coex_schm_interval_set_wrapper,
libesp_wifi.a,esp_adapter.c.obj,esp_empty_wrapper,
libesp_wifi.a,esp_adapter.c.obj,wifi_calloc,
libesp_wifi.a,esp_adapter.c.obj,wifi_zalloc_wrapper,
libesp_wifi.a,esp_adapter.c.obj,env_is_chip_wrapper,
libesp_wifi.a,esp_adapter.c.obj,is_from_isr_wrapper,
libesp_wifi.a,esp_adapter.c.obj,semphr_give_from_isr_wrapper,
libesp_wifi.a,esp_adapter.c.obj,mutex_lock_wrapper,
libesp_wifi.a,esp_adapter.c.obj,mutex_unlock_wrapper,
libesp_wifi.a,esp_adapter.c.obj,task_ms_to_tick_wrapper,
libesp_wifi.a,esp_adapter.c.obj,wifi_apb80m_request_wrapper,
libesp_wifi.a,esp_adapter.c.obj,wifi_apb80m_release_wrapper,
libesp_wifi.a,esp_adapter.c.obj,timer_arm_wrapper,
libesp_wifi.a,esp_adapter.c.obj,wifi_malloc,
libesp_wifi.a,esp_adapter.c.obj,timer_disarm_wrapper,
libesp_wifi.a,esp_adapter.c.obj,timer_arm_us_wrapper,
libesp_wifi.a,esp_adapter.c.obj,wifi_rtc_enable_iso_wrapper,
libesp_wifi.a,esp_adapter.c.obj,wifi_rtc_disable_iso_wrapper,
libesp_wifi.a,esp_adapter.c.obj,malloc_internal_wrapper,
libesp_wifi.a,esp_adapter.c.obj,realloc_internal_wrapper,
libesp_wifi.a,esp_adapter.c.obj,calloc_internal_wrapper,
libesp_wifi.a,esp_adapter.c.obj,zalloc_internal_wrapper,
libesp_wifi.a,esp_adapter.c.obj,coex_status_get_wrapper,
libesp_wifi.a,esp_adapter.c.obj,coex_wifi_release_wrapper,
libfreertos.a,list.c.obj,uxListRemove,FALSE
libfreertos.a,list.c.obj,vListInitialise,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,list.c.obj,vListInitialiseItem,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,list.c.obj,vListInsert,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,list.c.obj,vListInsertEnd,FALSE
libfreertos.a,port.c.obj,vApplicationStackOverflowHook,FALSE
libfreertos.a,port.c.obj,vPortYieldOtherCore,FALSE
libfreertos.a,port.c.obj,vPortYield,
libfreertos.a,port_common.c.obj,xPortcheckValidStackMem,
libfreertos.a,port_common.c.obj,vApplicationGetTimerTaskMemory,
libfreertos.a,port_common.c.obj,esp_startup_start_app_common,
libfreertos.a,port_common.c.obj,xPortCheckValidTCBMem,
libfreertos.a,port_common.c.obj,vApplicationGetIdleTaskMemory,
libfreertos.a,port_systick.c.obj,vPortSetupTimer,
libfreertos.a,port_systick.c.obj,xPortSysTickHandler,FALSE
libfreertos.a,queue.c.obj,prvCopyDataFromQueue,
libfreertos.a,queue.c.obj,prvGetDisinheritPriorityAfterTimeout,
libfreertos.a,queue.c.obj,prvIsQueueEmpty,
libfreertos.a,queue.c.obj,prvNotifyQueueSetContainer,
libfreertos.a,queue.c.obj,xQueueReceive,
libfreertos.a,queue.c.obj,prvUnlockQueue,
libfreertos.a,queue.c.obj,xQueueSemaphoreTake,
libfreertos.a,queue.c.obj,xQueueReceiveFromISR,
libfreertos.a,queue.c.obj,uxQueueMessagesWaitingFromISR,
libfreertos.a,queue.c.obj,xQueueIsQueueEmptyFromISR,
libfreertos.a,queue.c.obj,xQueueGiveFromISR,
libfreertos.a,tasks.c.obj,__getreent,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,pcTaskGetName,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,prvAddCurrentTaskToDelayedList,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,prvDeleteTLS,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,pvTaskIncrementMutexHeldCount,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,taskSelectHighestPriorityTaskSMP,FALSE
libfreertos.a,tasks.c.obj,taskYIELD_OTHER_CORE,FALSE
libfreertos.a,tasks.c.obj,vTaskGetSnapshot,CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH
libfreertos.a,tasks.c.obj,vTaskInternalSetTimeOutState,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,vTaskPlaceOnEventList,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,vTaskPlaceOnEventListRestricted,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,vTaskPlaceOnUnorderedEventList,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,vTaskPriorityDisinheritAfterTimeout,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,vTaskReleaseEventListLock,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,vTaskTakeEventListLock,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,xTaskCheckForTimeOut,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,xTaskGetCurrentTaskHandle,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,xTaskGetSchedulerState,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,xTaskGetTickCount,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,xTaskPriorityDisinherit,FALSE
libfreertos.a,tasks.c.obj,xTaskPriorityInherit,CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
libfreertos.a,tasks.c.obj,prvGetExpectedIdleTime,FALSE
libfreertos.a,tasks.c.obj,vTaskStepTick,FALSE
libhal.a,brownout_hal.c.obj,brownout_hal_intr_clear,
libhal.a,efuse_hal.c.obj,efuse_hal_chip_revision,
libhal.a,efuse_hal.c.obj,efuse_hal_get_major_chip_version,
libhal.a,efuse_hal.c.obj,efuse_hal_get_minor_chip_version,
libheap.a,heap_caps.c.obj,dram_alloc_to_iram_addr,
libheap.a,heap_caps.c.obj,heap_caps_free,
libheap.a,heap_caps.c.obj,heap_caps_realloc_base,
libheap.a,heap_caps.c.obj,heap_caps_realloc,
libheap.a,heap_caps.c.obj,heap_caps_calloc_base,
libheap.a,heap_caps.c.obj,heap_caps_calloc,
libheap.a,heap_caps.c.obj,heap_caps_malloc_base,
libheap.a,heap_caps.c.obj,heap_caps_malloc,
libheap.a,heap_caps.c.obj,heap_caps_malloc_default,
libheap.a,heap_caps.c.obj,heap_caps_realloc_default,
libheap.a,heap_caps.c.obj,find_containing_heap,
libheap.a,multi_heap.c.obj,_multi_heap_lock,
libheap.a,multi_heap.c.obj,multi_heap_in_rom_init,
liblog.a,log_freertos.c.obj,esp_log_timestamp,
liblog.a,log_freertos.c.obj,esp_log_impl_lock,
liblog.a,log_freertos.c.obj,esp_log_impl_unlock,
liblog.a,log_freertos.c.obj,esp_log_impl_lock_timeout,
liblog.a,log_freertos.c.obj,esp_log_early_timestamp,
liblog.a,log.c.obj,esp_log_write,
libmbedcrypto.a,esp_mem.c.obj,esp_mbedtls_mem_calloc,!CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC
libmbedcrypto.a,esp_mem.c.obj,esp_mbedtls_mem_free,!CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC
libnewlib.a,assert.c.obj,__assert_func,
libnewlib.a,assert.c.obj,newlib_include_assert_impl,
libnewlib.a,heap.c.obj,_calloc_r,
libnewlib.a,heap.c.obj,_free_r,
libnewlib.a,heap.c.obj,_malloc_r,
libnewlib.a,heap.c.obj,_realloc_r,
libnewlib.a,heap.c.obj,calloc,
libnewlib.a,heap.c.obj,cfree,
libnewlib.a,heap.c.obj,free,
libnewlib.a,heap.c.obj,malloc,
libnewlib.a,heap.c.obj,newlib_include_heap_impl,
libnewlib.a,heap.c.obj,realloc,
libnewlib.a,locks.c.obj,_lock_try_acquire_recursive,
libnewlib.a,locks.c.obj,lock_release_generic,
libnewlib.a,locks.c.obj,_lock_release,
libnewlib.a,locks.c.obj,_lock_release_recursive,
libnewlib.a,locks.c.obj,__retarget_lock_init,
libnewlib.a,locks.c.obj,__retarget_lock_init_recursive,
libnewlib.a,locks.c.obj,__retarget_lock_close,
libnewlib.a,locks.c.obj,__retarget_lock_close_recursive,
libnewlib.a,locks.c.obj,check_lock_nonzero,
libnewlib.a,locks.c.obj,__retarget_lock_acquire,
libnewlib.a,locks.c.obj,lock_init_generic,
libnewlib.a,locks.c.obj,__retarget_lock_acquire_recursive,
libnewlib.a,locks.c.obj,__retarget_lock_try_acquire,
libnewlib.a,locks.c.obj,__retarget_lock_try_acquire_recursive,
libnewlib.a,locks.c.obj,__retarget_lock_release,
libnewlib.a,locks.c.obj,__retarget_lock_release_recursive,
libnewlib.a,locks.c.obj,_lock_close,
libnewlib.a,locks.c.obj,lock_acquire_generic,
libnewlib.a,locks.c.obj,_lock_acquire,
libnewlib.a,locks.c.obj,_lock_acquire_recursive,
libnewlib.a,locks.c.obj,_lock_try_acquire,
libnewlib.a,reent_init.c.obj,esp_reent_init,
libnewlib.a,time.c.obj,_times_r,
libnewlib.a,time.c.obj,_gettimeofday_r,
libpp.a,pp_debug.o,wifi_gpio_debug,
libpthread.a,pthread.c.obj,pthread_mutex_lock_internal,
libpthread.a,pthread.c.obj,pthread_mutex_lock,
libpthread.a,pthread.c.obj,pthread_mutex_unlock,
libriscv.a,interrupt.c.obj,intr_handler_get,
libriscv.a,interrupt.c.obj,intr_handler_set,
libriscv.a,interrupt.c.obj,intr_matrix_route,
libspi_flash.a,flash_brownout_hook.c.obj,spi_flash_needs_reset_check,FALSE
libspi_flash.a,flash_brownout_hook.c.obj,spi_flash_set_erasing_flag,FALSE
libspi_flash.a,flash_ops.c.obj,spi_flash_guard_set,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,flash_ops.c.obj,spi_flash_malloc_internal,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,flash_ops.c.obj,spi_flash_rom_impl_init,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,flash_ops.c.obj,esp_mspi_pin_init,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,flash_ops.c.obj,spi_flash_init_chip_state,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_app.c.obj,delay_us,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_app.c.obj,get_buffer_malloc,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_app.c.obj,release_buffer_malloc,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_app.c.obj,main_flash_region_protected,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_app.c.obj,main_flash_op_status,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_app.c.obj,spi1_flash_os_check_yield,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_app.c.obj,spi1_flash_os_yield,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_noos.c.obj,start,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_noos.c.obj,end,CONFIG_SPI_FLASH_ROM_IMPL
libspi_flash.a,spi_flash_os_func_noos.c.obj,delay_us,CONFIG_SPI_FLASH_ROM_IMPL
1 library object function option
2 libble_app.a ble_hw.c.o r_ble_hw_resolv_list_get_cur_entry
3 libble_app.a ble_ll_adv.c.o r_ble_ll_adv_set_sched
4 libble_app.a ble_ll_adv.c.o r_ble_ll_adv_sync_pdu_make
5 libble_app.a ble_ll_adv.c.o r_ble_ll_adv_sync_calculate
6 libble_app.a ble_ll_conn.c.o r_ble_ll_conn_is_dev_connected
7 libble_app.a ble_ll_ctrl.c.o r_ble_ll_ctrl_tx_done
8 libble_app.a ble_lll_adv.c.o r_ble_lll_adv_aux_scannable_pdu_payload_len
9 libble_app.a ble_lll_adv.c.o r_ble_lll_adv_halt
10 libble_app.a ble_lll_adv.c.o r_ble_lll_adv_periodic_schedule_next
11 libble_app.a ble_lll_conn.c.o r_ble_lll_conn_cth_flow_free_credit
12 libble_app.a ble_lll_conn.c.o r_ble_lll_conn_update_encryption
13 libble_app.a ble_lll_conn.c.o r_ble_lll_conn_set_slave_flow_control
14 libble_app.a ble_lll_conn.c.o r_ble_lll_init_rx_pkt_isr
15 libble_app.a ble_lll_conn.c.o r_ble_lll_conn_get_rx_mbuf
16 libble_app.a ble_lll_rfmgmt.c.o r_ble_lll_rfmgmt_enable
17 libble_app.a ble_lll_rfmgmt.c.o r_ble_lll_rfmgmt_timer_reschedule
18 libble_app.a ble_lll_rfmgmt.c.o r_ble_lll_rfmgmt_timer_exp
19 libble_app.a ble_lll_scan.c.o r_ble_lll_scan_targeta_is_matched
20 libble_app.a ble_lll_scan.c.o r_ble_lll_scan_rx_isr_on_legacy
21 libble_app.a ble_lll_scan.c.o r_ble_lll_scan_rx_isr_on_aux
22 libble_app.a ble_lll_scan.c.o r_ble_lll_scan_process_rsp_in_isr
23 libble_app.a ble_lll_scan.c.o r_ble_lll_scan_rx_pkt_isr
24 libble_app.a ble_lll_sched.c.o r_ble_lll_sched_execute_check
25 libble_app.a ble_lll_sync.c.o r_ble_lll_sync_event_start_cb
26 libble_app.a ble_phy.c.o r_ble_phy_set_rxhdr
27 libble_app.a ble_phy.c.o r_ble_phy_update_conn_sequence
28 libble_app.a ble_phy.c.o r_ble_phy_set_sequence_mode
29 libble_app.a ble_phy.c.o r_ble_phy_txpower_round
30 libble_app.a os_mempool.c.obj r_os_memblock_put
31 libbootloader_support.a bootloader_flash.c.obj bootloader_read_flash_id
32 libbootloader_support.a flash_encrypt.c.obj esp_flash_encryption_enabled
33 libbt.a bt_osi_mem.c.obj bt_osi_mem_calloc CONFIG_BT_ENABLED
34 libbt.a bt_osi_mem.c.obj bt_osi_mem_malloc CONFIG_BT_ENABLED
35 libbt.a bt_osi_mem.c.obj bt_osi_mem_malloc_internal CONFIG_BT_ENABLED
36 libbt.a bt_osi_mem.c.obj bt_osi_mem_free CONFIG_BT_ENABLED
37 libbt.a bt.c.obj esp_reset_rpa_moudle CONFIG_BT_ENABLED
38 libbt.a bt.c.obj osi_assert_wrapper CONFIG_BT_ENABLED
39 libbt.a bt.c.obj osi_random_wrapper CONFIG_BT_ENABLED
40 libbt.a nimble_port.c.obj nimble_port_run CONFIG_BT_NIMBLE_ENABLED
41 libbt.a nimble_port.c.obj nimble_port_get_dflt_eventq CONFIG_BT_NIMBLE_ENABLED
42 libbt.a npl_os_freertos.c.obj os_callout_timer_cb CONFIG_BT_ENABLED && !CONFIG_BT_NIMBLE_USE_ESP_TIMER
43 libbt.a npl_os_freertos.c.obj npl_freertos_event_run CONFIG_BT_ENABLED
44 libbt.a npl_os_freertos.c.obj npl_freertos_callout_stop CONFIG_BT_ENABLED
45 libbt.a npl_os_freertos.c.obj npl_freertos_time_get CONFIG_BT_ENABLED
46 libbt.a npl_os_freertos.c.obj npl_freertos_callout_reset CONFIG_BT_ENABLED
47 libbt.a npl_os_freertos.c.obj npl_freertos_callout_is_active CONFIG_BT_ENABLED
48 libbt.a npl_os_freertos.c.obj npl_freertos_callout_get_ticks CONFIG_BT_ENABLED
49 libbt.a npl_os_freertos.c.obj npl_freertos_callout_remaining_ticks CONFIG_BT_ENABLED
50 libbt.a npl_os_freertos.c.obj npl_freertos_time_delay CONFIG_BT_ENABLED
51 libbt.a npl_os_freertos.c.obj npl_freertos_eventq_is_empty CONFIG_BT_ENABLED
52 libbt.a npl_os_freertos.c.obj npl_freertos_mutex_pend CONFIG_BT_ENABLED
53 libbt.a npl_os_freertos.c.obj npl_freertos_mutex_release CONFIG_BT_ENABLED
54 libbt.a npl_os_freertos.c.obj npl_freertos_sem_init CONFIG_BT_ENABLED
55 libbt.a npl_os_freertos.c.obj npl_freertos_sem_pend CONFIG_BT_ENABLED
56 libbt.a npl_os_freertos.c.obj npl_freertos_sem_release CONFIG_BT_ENABLED
57 libbt.a npl_os_freertos.c.obj npl_freertos_callout_init CONFIG_BT_ENABLED
58 libbt.a npl_os_freertos.c.obj npl_freertos_callout_deinit CONFIG_BT_ENABLED
59 libbt.a npl_os_freertos.c.obj npl_freertos_event_is_queued CONFIG_BT_ENABLED
60 libbt.a npl_os_freertos.c.obj npl_freertos_event_get_arg CONFIG_BT_ENABLED
61 libbt.a npl_os_freertos.c.obj npl_freertos_time_ms_to_ticks32 CONFIG_BT_ENABLED
62 libbt.a npl_os_freertos.c.obj npl_freertos_time_ticks_to_ms32 CONFIG_BT_ENABLED
63 libbt.a npl_os_freertos.c.obj npl_freertos_hw_is_in_critical CONFIG_BT_ENABLED
64 libbt.a npl_os_freertos.c.obj npl_freertos_get_time_forever CONFIG_BT_ENABLED
65 libbt.a npl_os_freertos.c.obj npl_freertos_os_started CONFIG_BT_ENABLED
66 libbt.a npl_os_freertos.c.obj npl_freertos_get_current_task_id CONFIG_BT_ENABLED
67 libbt.a npl_os_freertos.c.obj npl_freertos_event_reset CONFIG_BT_ENABLED
68 libbt.a npl_os_freertos.c.obj npl_freertos_callout_mem_reset CONFIG_BT_ENABLED
69 libbt.a npl_os_freertos.c.obj npl_freertos_event_init CONFIG_BT_ENABLED
70 libbt.a npl_os_freertos.c.obj npl_freertos_sem_get_count CONFIG_BT_ENABLED
71 libbt.a npl_os_freertos.c.obj npl_freertos_eventq_remove CONFIG_BT_ENABLED
72 libbt.a npl_os_freertos.c.obj npl_freertos_hw_exit_critical CONFIG_BT_ENABLED
73 libbt.a npl_os_freertos.c.obj npl_freertos_mutex_init CONFIG_BT_ENABLED
74 libbt.a npl_os_freertos.c.obj npl_freertos_hw_enter_critical CONFIG_BT_ENABLED
75 libbt.a npl_os_freertos.c.obj npl_freertos_eventq_put CONFIG_BT_ENABLED
76 libbt.a npl_os_freertos.c.obj npl_freertos_eventq_get CONFIG_BT_ENABLED
77 libbt.a npl_os_freertos.c.obj npl_freertos_sem_deinit CONFIG_BT_ENABLED
78 libbt.a npl_os_freertos.c.obj npl_freertos_mutex_deinit CONFIG_BT_ENABLED
79 libbt.a npl_os_freertos.c.obj npl_freertos_eventq_deinit CONFIG_BT_ENABLED
80 libbt.a npl_os_freertos.c.obj npl_freertos_eventq_init CONFIG_BT_ENABLED
81 libbt.a npl_os_freertos.c.obj npl_freertos_event_deinit CONFIG_BT_ENABLED
82 libbt.a npl_os_freertos.c.obj npl_freertos_time_ticks_to_ms CONFIG_BT_ENABLED
83 libbt.a npl_os_freertos.c.obj npl_freertos_time_ms_to_ticks CONFIG_BT_ENABLED
84 libbt.a npl_os_freertos.c.obj npl_freertos_callout_set_arg CONFIG_BT_ENABLED
85 libbt.a npl_os_freertos.c.obj npl_freertos_event_set_arg CONFIG_BT_ENABLED
86 libbt.a npl_os_freertos.c.obj npl_freertos_eventq_put CONFIG_BT_ENABLED
87 libdriver.a gpio.c.obj gpio_intr_service
88 libesp_app_format.a esp_app_desc.c.obj esp_app_get_elf_sha256
89 libesp_hw_support.a cpu.c.obj esp_cpu_wait_for_intr
90 libesp_hw_support.a cpu.c.obj esp_cpu_reset
91 libesp_hw_support.a esp_clk.c.obj esp_clk_cpu_freq
92 libesp_hw_support.a esp_clk.c.obj esp_clk_apb_freq
93 libesp_hw_support.a esp_clk.c.obj esp_clk_xtal_freq
94 libesp_hw_support.a esp_memory_utils.c.obj esp_ptr_byte_accessible
95 libesp_hw_support.a hw_random.c.obj esp_random
96 libesp_hw_support.a intr_alloc.c.obj shared_intr_isr
97 libesp_hw_support.a intr_alloc.c.obj esp_intr_noniram_disable
98 libesp_hw_support.a intr_alloc.c.obj esp_intr_noniram_enable
99 libesp_hw_support.a intr_alloc.c.obj esp_intr_enable
100 libesp_hw_support.a intr_alloc.c.obj esp_intr_disable
101 libesp_hw_support.a periph_ctrl.c.obj wifi_bt_common_module_enable
102 libesp_hw_support.a periph_ctrl.c.obj wifi_bt_common_module_disable
103 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_ctrl_read_reg
104 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_ctrl_read_reg_mask
105 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_ctrl_write_reg
106 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_ctrl_write_reg_mask
107 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_enter_critical
108 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_exit_critical
109 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_analog_cali_reg_read
110 libesp_hw_support.a regi2c_ctrl.c.obj regi2c_analog_cali_reg_write
111 libesp_hw_support.a rtc_clk.c.obj rtc_clk_32k_enable_external
112 libesp_hw_support.a rtc_clk.c.obj rtc_clk_fast_src_set
113 libesp_hw_support.a rtc_clk.c.obj rtc_clk_slow_freq_get_hz
114 libesp_hw_support.a rtc_clk.c.obj rtc_clk_slow_src_get
115 libesp_hw_support.a rtc_clk.c.obj rtc_clk_slow_src_set
116 libesp_hw_support.a rtc_clk.c.obj rtc_dig_clk8m_disable
117 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_set_config_fast
118 libesp_hw_support.a rtc_clk.c.obj rtc_clk_8m_enable
119 libesp_hw_support.a rtc_clk.c.obj rtc_clk_8md256_enabled
120 libesp_hw_support.a rtc_clk.c.obj rtc_clk_bbpll_configure
121 libesp_hw_support.a rtc_clk.c.obj rtc_clk_bbpll_enable
122 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_get_config
123 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_mhz_to_config
124 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_set_config
125 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_to_8m
126 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_to_pll_mhz
127 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_set_xtal
128 libesp_hw_support.a rtc_clk.c.obj rtc_clk_xtal_freq_get
129 libesp_hw_support.a rtc_clk.c.obj rtc_clk_cpu_freq_to_xtal
130 libesp_hw_support.a rtc_clk.c.obj rtc_clk_bbpll_disable
131 libesp_hw_support.a rtc_clk.c.obj rtc_clk_apb_freq_update
132 libesp_hw_support.a rtc_clk.c.obj clk_ll_rtc_slow_get_src FALSE
133 libesp_hw_support.a rtc_init.c.obj rtc_vddsdio_set_config
134 libesp_hw_support.a rtc_module.c.obj rtc_isr
135 libesp_hw_support.a rtc_module.c.obj rtc_isr_noniram_disable
136 libesp_hw_support.a rtc_module.c.obj rtc_isr_noniram_enable
137 libesp_hw_support.a rtc_sleep.c.obj rtc_sleep_pu
138 libesp_hw_support.a rtc_sleep.c.obj rtc_sleep_finish
139 libesp_hw_support.a rtc_sleep.c.obj rtc_sleep_get_default_config
140 libesp_hw_support.a rtc_sleep.c.obj rtc_sleep_init
141 libesp_hw_support.a rtc_sleep.c.obj rtc_sleep_low_init
142 libesp_hw_support.a rtc_sleep.c.obj rtc_sleep_start
143 libesp_hw_support.a rtc_time.c.obj rtc_clk_cal
144 libesp_hw_support.a rtc_time.c.obj rtc_clk_cal_internal
145 libesp_hw_support.a rtc_time.c.obj rtc_time_get
146 libesp_hw_support.a rtc_time.c.obj rtc_time_us_to_slowclk
147 libesp_hw_support.a rtc_time.c.obj rtc_time_slowclk_to_us
148 libesp_hw_support.a sleep_modes.c.obj periph_ll_periph_enabled
149 libesp_hw_support.a sleep_modes.c.obj flush_uarts
150 libesp_hw_support.a sleep_modes.c.obj suspend_uarts
151 libesp_hw_support.a sleep_modes.c.obj resume_uarts
152 libesp_hw_support.a sleep_modes.c.obj esp_sleep_start
153 libesp_hw_support.a sleep_modes.c.obj esp_deep_sleep_start
154 libesp_hw_support.a sleep_modes.c.obj esp_light_sleep_inner
155 libesp_phy.a phy_init.c.obj esp_phy_common_clock_enable
156 libesp_phy.a phy_init.c.obj esp_phy_common_clock_disable
157 libesp_phy.a phy_init.c.obj esp_wifi_bt_power_domain_on
158 libesp_phy.a phy_override.c.obj phy_i2c_enter_critical
159 libesp_phy.a phy_override.c.obj phy_i2c_exit_critical
160 libesp_pm.a pm_locks.c.obj esp_pm_lock_acquire
161 libesp_pm.a pm_locks.c.obj esp_pm_lock_release
162 libesp_pm.a pm_impl.c.obj get_lowest_allowed_mode
163 libesp_pm.a pm_impl.c.obj esp_pm_impl_switch_mode
164 libesp_pm.a pm_impl.c.obj on_freq_update
165 libesp_pm.a pm_impl.c.obj vApplicationSleep CONFIG_FREERTOS_USE_TICKLESS_IDLE
166 libesp_pm.a pm_impl.c.obj do_switch
167 libesp_ringbuf.a ringbuf.c.obj prvCheckItemAvail
168 libesp_ringbuf.a ringbuf.c.obj prvGetFreeSize
169 libesp_ringbuf.a ringbuf.c.obj prvReceiveGenericFromISR
170 libesp_ringbuf.a ringbuf.c.obj xRingbufferGetMaxItemSize
171 libesp_rom.a esp_rom_systimer.c.obj systimer_hal_init
172 libesp_rom.a esp_rom_systimer.c.obj systimer_hal_set_alarm_period
173 libesp_rom.a esp_rom_systimer.c.obj systimer_hal_set_alarm_target
174 libesp_rom.a esp_rom_systimer.c.obj systimer_hal_set_tick_rate_ops
175 libesp_rom.a esp_rom_uart.c.obj esp_rom_uart_set_clock_baudrate
176 libesp_system.a brownout.c.obj rtc_brownout_isr_handler
177 libesp_system.a cache_err_int.c.obj esp_cache_err_get_cpuid
178 libesp_system.a cpu_start.c.obj call_start_cpu0
179 libesp_system.a crosscore_int.c.obj esp_crosscore_int_send
180 libesp_system.a crosscore_int.c.obj esp_crosscore_int_send_yield
181 libesp_system.a esp_system.c.obj esp_restart
182 libesp_system.a esp_system.c.obj esp_system_abort
183 libesp_system.a reset_reason.c.obj esp_reset_reason_set_hint
184 libesp_system.a reset_reason.c.obj esp_reset_reason_get_hint
185 libesp_system.a ubsan.c.obj __ubsan_include
186 libesp_timer.a esp_timer.c.obj esp_timer_get_next_alarm_for_wake_up
187 libesp_timer.a esp_timer.c.obj timer_list_unlock !CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
188 libesp_timer.a esp_timer.c.obj timer_list_lock !CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
189 libesp_timer.a esp_timer.c.obj timer_armed
190 libesp_timer.a esp_timer.c.obj timer_remove
191 libesp_timer.a esp_timer.c.obj timer_insert !CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
192 libesp_timer.a esp_timer.c.obj esp_timer_start_once
193 libesp_timer.a esp_timer.c.obj esp_timer_start_periodic
194 libesp_timer.a esp_timer.c.obj esp_timer_stop
195 libesp_timer.a esp_timer.c.obj esp_timer_get_expiry_time
196 libesp_timer.a esp_timer_impl_systimer.c.obj esp_timer_impl_get_time !CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
197 libesp_timer.a esp_timer_impl_systimer.c.obj esp_timer_impl_set_alarm_id !CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
198 libesp_timer.a esp_timer_impl_systimer.c.obj esp_timer_impl_update_apb_freq
199 libesp_timer.a esp_timer_impl_systimer.c.obj esp_timer_impl_get_min_period_us
200 libesp_timer.a ets_timer_legacy.c.obj timer_initialized
201 libesp_timer.a ets_timer_legacy.c.obj ets_timer_arm_us
202 libesp_timer.a ets_timer_legacy.c.obj ets_timer_arm
203 libesp_timer.a ets_timer_legacy.c.obj ets_timer_disarm
204 libesp_timer.a system_time.c.obj esp_system_get_time
205 libesp_wifi.a esp_adapter.c.obj semphr_take_from_isr_wrapper
206 libesp_wifi.a esp_adapter.c.obj wifi_realloc
207 libesp_wifi.a esp_adapter.c.obj coex_event_duration_get_wrapper
208 libesp_wifi.a esp_adapter.c.obj coex_schm_interval_set_wrapper
209 libesp_wifi.a esp_adapter.c.obj esp_empty_wrapper
210 libesp_wifi.a esp_adapter.c.obj wifi_calloc
211 libesp_wifi.a esp_adapter.c.obj wifi_zalloc_wrapper
212 libesp_wifi.a esp_adapter.c.obj env_is_chip_wrapper
213 libesp_wifi.a esp_adapter.c.obj is_from_isr_wrapper
214 libesp_wifi.a esp_adapter.c.obj semphr_give_from_isr_wrapper
215 libesp_wifi.a esp_adapter.c.obj mutex_lock_wrapper
216 libesp_wifi.a esp_adapter.c.obj mutex_unlock_wrapper
217 libesp_wifi.a esp_adapter.c.obj task_ms_to_tick_wrapper
218 libesp_wifi.a esp_adapter.c.obj wifi_apb80m_request_wrapper
219 libesp_wifi.a esp_adapter.c.obj wifi_apb80m_release_wrapper
220 libesp_wifi.a esp_adapter.c.obj timer_arm_wrapper
221 libesp_wifi.a esp_adapter.c.obj wifi_malloc
222 libesp_wifi.a esp_adapter.c.obj timer_disarm_wrapper
223 libesp_wifi.a esp_adapter.c.obj timer_arm_us_wrapper
224 libesp_wifi.a esp_adapter.c.obj wifi_rtc_enable_iso_wrapper
225 libesp_wifi.a esp_adapter.c.obj wifi_rtc_disable_iso_wrapper
226 libesp_wifi.a esp_adapter.c.obj malloc_internal_wrapper
227 libesp_wifi.a esp_adapter.c.obj realloc_internal_wrapper
228 libesp_wifi.a esp_adapter.c.obj calloc_internal_wrapper
229 libesp_wifi.a esp_adapter.c.obj zalloc_internal_wrapper
230 libesp_wifi.a esp_adapter.c.obj coex_status_get_wrapper
231 libesp_wifi.a esp_adapter.c.obj coex_wifi_release_wrapper
232 libfreertos.a list.c.obj uxListRemove FALSE
233 libfreertos.a list.c.obj vListInitialise CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
234 libfreertos.a list.c.obj vListInitialiseItem CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
235 libfreertos.a list.c.obj vListInsert CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
236 libfreertos.a list.c.obj vListInsertEnd FALSE
237 libfreertos.a port.c.obj vApplicationStackOverflowHook FALSE
238 libfreertos.a port.c.obj vPortYieldOtherCore FALSE
239 libfreertos.a port.c.obj vPortYield
240 libfreertos.a port_common.c.obj xPortcheckValidStackMem
241 libfreertos.a port_common.c.obj vApplicationGetTimerTaskMemory
242 libfreertos.a port_common.c.obj esp_startup_start_app_common
243 libfreertos.a port_common.c.obj xPortCheckValidTCBMem
244 libfreertos.a port_common.c.obj vApplicationGetIdleTaskMemory
245 libfreertos.a port_systick.c.obj vPortSetupTimer
246 libfreertos.a port_systick.c.obj xPortSysTickHandler FALSE
247 libfreertos.a queue.c.obj prvCopyDataFromQueue
248 libfreertos.a queue.c.obj prvGetDisinheritPriorityAfterTimeout
249 libfreertos.a queue.c.obj prvIsQueueEmpty
250 libfreertos.a queue.c.obj prvNotifyQueueSetContainer
251 libfreertos.a queue.c.obj xQueueReceive
252 libfreertos.a queue.c.obj prvUnlockQueue
253 libfreertos.a queue.c.obj xQueueSemaphoreTake
254 libfreertos.a queue.c.obj xQueueReceiveFromISR
255 libfreertos.a queue.c.obj uxQueueMessagesWaitingFromISR
256 libfreertos.a queue.c.obj xQueueIsQueueEmptyFromISR
257 libfreertos.a queue.c.obj xQueueGiveFromISR
258 libfreertos.a tasks.c.obj __getreent CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
259 libfreertos.a tasks.c.obj pcTaskGetName CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
260 libfreertos.a tasks.c.obj prvAddCurrentTaskToDelayedList CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
261 libfreertos.a tasks.c.obj prvDeleteTLS CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
262 libfreertos.a tasks.c.obj pvTaskIncrementMutexHeldCount CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
263 libfreertos.a tasks.c.obj taskSelectHighestPriorityTaskSMP FALSE
264 libfreertos.a tasks.c.obj taskYIELD_OTHER_CORE FALSE
265 libfreertos.a tasks.c.obj vTaskGetSnapshot CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH
266 libfreertos.a tasks.c.obj vTaskInternalSetTimeOutState CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
267 libfreertos.a tasks.c.obj vTaskPlaceOnEventList CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
268 libfreertos.a tasks.c.obj vTaskPlaceOnEventListRestricted CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
269 libfreertos.a tasks.c.obj vTaskPlaceOnUnorderedEventList CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
270 libfreertos.a tasks.c.obj vTaskPriorityDisinheritAfterTimeout CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
271 libfreertos.a tasks.c.obj vTaskReleaseEventListLock CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
272 libfreertos.a tasks.c.obj vTaskTakeEventListLock CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
273 libfreertos.a tasks.c.obj xTaskCheckForTimeOut CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
274 libfreertos.a tasks.c.obj xTaskGetCurrentTaskHandle CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
275 libfreertos.a tasks.c.obj xTaskGetSchedulerState CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
276 libfreertos.a tasks.c.obj xTaskGetTickCount CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
277 libfreertos.a tasks.c.obj xTaskPriorityDisinherit FALSE
278 libfreertos.a tasks.c.obj xTaskPriorityInherit CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
279 libfreertos.a tasks.c.obj prvGetExpectedIdleTime FALSE
280 libfreertos.a tasks.c.obj vTaskStepTick FALSE
281 libhal.a brownout_hal.c.obj brownout_hal_intr_clear
282 libhal.a efuse_hal.c.obj efuse_hal_chip_revision
283 libhal.a efuse_hal.c.obj efuse_hal_get_major_chip_version
284 libhal.a efuse_hal.c.obj efuse_hal_get_minor_chip_version
285 libheap.a heap_caps.c.obj dram_alloc_to_iram_addr
286 libheap.a heap_caps.c.obj heap_caps_free
287 libheap.a heap_caps.c.obj heap_caps_realloc_base
288 libheap.a heap_caps.c.obj heap_caps_realloc
289 libheap.a heap_caps.c.obj heap_caps_calloc_base
290 libheap.a heap_caps.c.obj heap_caps_calloc
291 libheap.a heap_caps.c.obj heap_caps_malloc_base
292 libheap.a heap_caps.c.obj heap_caps_malloc
293 libheap.a heap_caps.c.obj heap_caps_malloc_default
294 libheap.a heap_caps.c.obj heap_caps_realloc_default
295 libheap.a heap_caps.c.obj find_containing_heap
296 libheap.a multi_heap.c.obj _multi_heap_lock
297 libheap.a multi_heap.c.obj multi_heap_in_rom_init
298 liblog.a log_freertos.c.obj esp_log_timestamp
299 liblog.a log_freertos.c.obj esp_log_impl_lock
300 liblog.a log_freertos.c.obj esp_log_impl_unlock
301 liblog.a log_freertos.c.obj esp_log_impl_lock_timeout
302 liblog.a log_freertos.c.obj esp_log_early_timestamp
303 liblog.a log.c.obj esp_log_write
304 libmbedcrypto.a esp_mem.c.obj esp_mbedtls_mem_calloc !CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC
305 libmbedcrypto.a esp_mem.c.obj esp_mbedtls_mem_free !CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC
306 libnewlib.a assert.c.obj __assert_func
307 libnewlib.a assert.c.obj newlib_include_assert_impl
308 libnewlib.a heap.c.obj _calloc_r
309 libnewlib.a heap.c.obj _free_r
310 libnewlib.a heap.c.obj _malloc_r
311 libnewlib.a heap.c.obj _realloc_r
312 libnewlib.a heap.c.obj calloc
313 libnewlib.a heap.c.obj cfree
314 libnewlib.a heap.c.obj free
315 libnewlib.a heap.c.obj malloc
316 libnewlib.a heap.c.obj newlib_include_heap_impl
317 libnewlib.a heap.c.obj realloc
318 libnewlib.a locks.c.obj _lock_try_acquire_recursive
319 libnewlib.a locks.c.obj lock_release_generic
320 libnewlib.a locks.c.obj _lock_release
321 libnewlib.a locks.c.obj _lock_release_recursive
322 libnewlib.a locks.c.obj __retarget_lock_init
323 libnewlib.a locks.c.obj __retarget_lock_init_recursive
324 libnewlib.a locks.c.obj __retarget_lock_close
325 libnewlib.a locks.c.obj __retarget_lock_close_recursive
326 libnewlib.a locks.c.obj check_lock_nonzero
327 libnewlib.a locks.c.obj __retarget_lock_acquire
328 libnewlib.a locks.c.obj lock_init_generic
329 libnewlib.a locks.c.obj __retarget_lock_acquire_recursive
330 libnewlib.a locks.c.obj __retarget_lock_try_acquire
331 libnewlib.a locks.c.obj __retarget_lock_try_acquire_recursive
332 libnewlib.a locks.c.obj __retarget_lock_release
333 libnewlib.a locks.c.obj __retarget_lock_release_recursive
334 libnewlib.a locks.c.obj _lock_close
335 libnewlib.a locks.c.obj lock_acquire_generic
336 libnewlib.a locks.c.obj _lock_acquire
337 libnewlib.a locks.c.obj _lock_acquire_recursive
338 libnewlib.a locks.c.obj _lock_try_acquire
339 libnewlib.a reent_init.c.obj esp_reent_init
340 libnewlib.a time.c.obj _times_r
341 libnewlib.a time.c.obj _gettimeofday_r
342 libpp.a pp_debug.o wifi_gpio_debug
343 libpthread.a pthread.c.obj pthread_mutex_lock_internal
344 libpthread.a pthread.c.obj pthread_mutex_lock
345 libpthread.a pthread.c.obj pthread_mutex_unlock
346 libriscv.a interrupt.c.obj intr_handler_get
347 libriscv.a interrupt.c.obj intr_handler_set
348 libriscv.a interrupt.c.obj intr_matrix_route
349 libspi_flash.a flash_brownout_hook.c.obj spi_flash_needs_reset_check FALSE
350 libspi_flash.a flash_brownout_hook.c.obj spi_flash_set_erasing_flag FALSE
351 libspi_flash.a flash_ops.c.obj spi_flash_guard_set CONFIG_SPI_FLASH_ROM_IMPL
352 libspi_flash.a flash_ops.c.obj spi_flash_malloc_internal CONFIG_SPI_FLASH_ROM_IMPL
353 libspi_flash.a flash_ops.c.obj spi_flash_rom_impl_init CONFIG_SPI_FLASH_ROM_IMPL
354 libspi_flash.a flash_ops.c.obj esp_mspi_pin_init CONFIG_SPI_FLASH_ROM_IMPL
355 libspi_flash.a flash_ops.c.obj spi_flash_init_chip_state CONFIG_SPI_FLASH_ROM_IMPL
356 libspi_flash.a spi_flash_os_func_app.c.obj delay_us CONFIG_SPI_FLASH_ROM_IMPL
357 libspi_flash.a spi_flash_os_func_app.c.obj get_buffer_malloc CONFIG_SPI_FLASH_ROM_IMPL
358 libspi_flash.a spi_flash_os_func_app.c.obj release_buffer_malloc CONFIG_SPI_FLASH_ROM_IMPL
359 libspi_flash.a spi_flash_os_func_app.c.obj main_flash_region_protected CONFIG_SPI_FLASH_ROM_IMPL
360 libspi_flash.a spi_flash_os_func_app.c.obj main_flash_op_status CONFIG_SPI_FLASH_ROM_IMPL
361 libspi_flash.a spi_flash_os_func_app.c.obj spi1_flash_os_check_yield CONFIG_SPI_FLASH_ROM_IMPL
362 libspi_flash.a spi_flash_os_func_app.c.obj spi1_flash_os_yield CONFIG_SPI_FLASH_ROM_IMPL
363 libspi_flash.a spi_flash_os_func_noos.c.obj start CONFIG_SPI_FLASH_ROM_IMPL
364 libspi_flash.a spi_flash_os_func_noos.c.obj end CONFIG_SPI_FLASH_ROM_IMPL
365 libspi_flash.a spi_flash_os_func_noos.c.obj delay_us CONFIG_SPI_FLASH_ROM_IMPL

View File

@@ -0,0 +1,24 @@
library,path
libble_app.a,$IDF_PATH/components/bt/controller/lib_esp32c2/esp32c2-bt-lib/libble_app.a
libpp.a,$IDF_PATH/components/esp_wifi/lib/esp32c2/libpp.a
libbootloader_support.a,./esp-idf/bootloader_support/libbootloader_support.a
libbt.a,./esp-idf/bt/libbt.a
libdriver.a,./esp-idf/driver/libdriver.a
libesp_app_format.a,./esp-idf/esp_app_format/libesp_app_format.a
libesp_hw_support.a,./esp-idf/esp_hw_support/libesp_hw_support.a
libesp_phy.a,./esp-idf/esp_phy/libesp_phy.a
libesp_pm.a,./esp-idf/esp_pm/libesp_pm.a
libesp_ringbuf.a,./esp-idf/esp_ringbuf/libesp_ringbuf.a
libesp_rom.a,./esp-idf/esp_rom/libesp_rom.a
libesp_system.a,./esp-idf/esp_system/libesp_system.a
libesp_timer.a,./esp-idf/esp_timer/libesp_timer.a
libesp_wifi.a,./esp-idf/esp_wifi/libesp_wifi.a
libfreertos.a,./esp-idf/freertos/libfreertos.a
libhal.a,./esp-idf/hal/libhal.a
libheap.a,./esp-idf/heap/libheap.a
liblog.a,./esp-idf/log/liblog.a
libmbedcrypto.a,./esp-idf/mbedtls/mbedtls/library/libmbedcrypto.a
libnewlib.a,./esp-idf/newlib/libnewlib.a
libpthread.a,./esp-idf/pthread/libpthread.a
libriscv.a,./esp-idf/riscv/libriscv.a
libspi_flash.a,./esp-idf/spi_flash/libspi_flash.a
1 library path
2 libble_app.a $IDF_PATH/components/bt/controller/lib_esp32c2/esp32c2-bt-lib/libble_app.a
3 libpp.a $IDF_PATH/components/esp_wifi/lib/esp32c2/libpp.a
4 libbootloader_support.a ./esp-idf/bootloader_support/libbootloader_support.a
5 libbt.a ./esp-idf/bt/libbt.a
6 libdriver.a ./esp-idf/driver/libdriver.a
7 libesp_app_format.a ./esp-idf/esp_app_format/libesp_app_format.a
8 libesp_hw_support.a ./esp-idf/esp_hw_support/libesp_hw_support.a
9 libesp_phy.a ./esp-idf/esp_phy/libesp_phy.a
10 libesp_pm.a ./esp-idf/esp_pm/libesp_pm.a
11 libesp_ringbuf.a ./esp-idf/esp_ringbuf/libesp_ringbuf.a
12 libesp_rom.a ./esp-idf/esp_rom/libesp_rom.a
13 libesp_system.a ./esp-idf/esp_system/libesp_system.a
14 libesp_timer.a ./esp-idf/esp_timer/libesp_timer.a
15 libesp_wifi.a ./esp-idf/esp_wifi/libesp_wifi.a
16 libfreertos.a ./esp-idf/freertos/libfreertos.a
17 libhal.a ./esp-idf/hal/libhal.a
18 libheap.a ./esp-idf/heap/libheap.a
19 liblog.a ./esp-idf/log/liblog.a
20 libmbedcrypto.a ./esp-idf/mbedtls/mbedtls/library/libmbedcrypto.a
21 libnewlib.a ./esp-idf/newlib/libnewlib.a
22 libpthread.a ./esp-idf/pthread/libpthread.a
23 libriscv.a ./esp-idf/riscv/libriscv.a
24 libspi_flash.a ./esp-idf/spi_flash/libspi_flash.a

View File

@@ -0,0 +1,66 @@
library,object,path
libbootloader_support.a,bootloader_flash.c.obj,esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/bootloader_flash/src/bootloader_flash.c.obj
libbootloader_support.a,flash_encrypt.c.obj,esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/flash_encrypt.c.obj
libbt.a,bt_osi_mem.c.obj,esp-idf/bt/CMakeFiles/__idf_bt.dir/porting/mem/bt_osi_mem.c.obj
libbt.a,bt.c.obj,esp-idf/bt/CMakeFiles/__idf_bt.dir/controller/esp32c2/bt.c.obj
libbt.a,npl_os_freertos.c.obj,esp-idf/bt/CMakeFiles/__idf_bt.dir/porting/npl/freertos/src/npl_os_freertos.c.obj
libbt.a,nimble_port.c.obj,esp-idf/bt/CMakeFiles/__idf_bt.dir/host/nimble/nimble/porting/nimble/src/nimble_port.c.obj
libdriver.a,gpio.c.obj,esp-idf/driver/CMakeFiles/__idf_driver.dir/gpio/gpio.c.obj
libesp_app_format.a,esp_app_desc.c.obj,esp-idf/esp_app_format/CMakeFiles/__idf_esp_app_format.dir/esp_app_desc.c.obj
libesp_hw_support.a,cpu.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/cpu.c.obj
libesp_hw_support.a,esp_clk.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/esp_clk.c.obj
libesp_hw_support.a,esp_memory_utils.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/esp_memory_utils.c.obj
libesp_hw_support.a,hw_random.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/hw_random.c.obj
libesp_hw_support.a,intr_alloc.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/intr_alloc.c.obj
libesp_hw_support.a,periph_ctrl.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/periph_ctrl.c.obj
libesp_hw_support.a,regi2c_ctrl.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/regi2c_ctrl.c.obj
libesp_hw_support.a,rtc_clk.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_clk.c.obj
libesp_hw_support.a,rtc_init.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_init.c.obj
libesp_hw_support.a,rtc_module.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/rtc_module.c.obj
libesp_hw_support.a,rtc_sleep.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_sleep.c.obj
libesp_hw_support.a,rtc_time.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_time.c.obj
libesp_hw_support.a,sleep_modes.c.obj,esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/sleep_modes.c.obj
libesp_phy.a,phy_init.c.obj,esp-idf/esp_phy/CMakeFiles/__idf_esp_phy.dir/src/phy_init.c.obj
libesp_phy.a,phy_override.c.obj,esp-idf/esp_phy/CMakeFiles/__idf_esp_phy.dir/src/phy_override.c.obj
libesp_pm.a,pm_locks.c.obj,esp-idf/esp_pm/CMakeFiles/__idf_esp_pm.dir/pm_locks.c.obj
libesp_pm.a,pm_impl.c.obj,esp-idf/esp_pm/CMakeFiles/__idf_esp_pm.dir/pm_impl.c.obj
libesp_ringbuf.a,ringbuf.c.obj,esp-idf/esp_ringbuf/CMakeFiles/__idf_esp_ringbuf.dir/ringbuf.c.obj
libesp_rom.a,esp_rom_systimer.c.obj,esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_systimer.c.obj
libesp_rom.a,esp_rom_uart.c.obj,esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_uart.c.obj
libesp_system.a,brownout.c.obj,esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/brownout.c.obj
libesp_system.a,cache_err_int.c.obj,esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/soc/esp32c2/cache_err_int.c.obj
libesp_system.a,cpu_start.c.obj,esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/cpu_start.c.obj
libesp_system.a,crosscore_int.c.obj,esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/crosscore_int.c.obj
libesp_system.a,esp_system.c.obj,esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/esp_system.c.obj
libesp_system.a,reset_reason.c.obj,esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/soc/esp32c2/reset_reason.c.obj
libesp_system.a,ubsan.c.obj,esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/ubsan.c.obj
libesp_timer.a,esp_timer.c.obj,esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/esp_timer.c.obj
libesp_timer.a,esp_timer_impl_systimer.c.obj,esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/esp_timer_impl_systimer.c.obj
libesp_timer.a,ets_timer_legacy.c.obj,esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/ets_timer_legacy.c.obj
libesp_timer.a,system_time.c.obj,esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/system_time.c.obj
libesp_wifi.a,esp_adapter.c.obj,esp-idf/esp_wifi/CMakeFiles/__idf_esp_wifi.dir/esp32c2/esp_adapter.c.obj
libfreertos.a,list.c.obj,esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/list.c.obj
libfreertos.a,port.c.obj,esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/portable/riscv/port.c.obj
libfreertos.a,port_common.c.obj,esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/portable/port_common.c.obj
libfreertos.a,port_systick.c.obj,esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/portable/port_systick.c.obj
libfreertos.a,queue.c.obj,esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/queue.c.obj
libfreertos.a,tasks.c.obj,esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/tasks.c.obj
libhal.a,brownout_hal.c.obj,esp-idf/hal/CMakeFiles/__idf_hal.dir/esp32c2/brownout_hal.c.obj
libhal.a,efuse_hal.c.obj,esp-idf/hal/CMakeFiles/__idf_hal.dir/efuse_hal.c.obj
libhal.a,efuse_hal.c.obj,esp-idf/hal/CMakeFiles/__idf_hal.dir/esp32c2/efuse_hal.c.obj
libheap.a,heap_caps.c.obj,esp-idf/heap/CMakeFiles/__idf_heap.dir/heap_caps.c.obj
libheap.a,multi_heap.c.obj,./esp-idf/heap/CMakeFiles/__idf_heap.dir/multi_heap.c.obj
liblog.a,log_freertos.c.obj,esp-idf/log/CMakeFiles/__idf_log.dir/log_freertos.c.obj
liblog.a,log.c.obj,esp-idf/log/CMakeFiles/__idf_log.dir/log.c.obj
libmbedcrypto.a,esp_mem.c.obj,esp-idf/mbedtls/mbedtls/library/CMakeFiles/mbedcrypto.dir/$IDF_PATH/components/mbedtls/port/esp_mem.c.obj
libnewlib.a,assert.c.obj,esp-idf/newlib/CMakeFiles/__idf_newlib.dir/assert.c.obj
libnewlib.a,heap.c.obj,esp-idf/newlib/CMakeFiles/__idf_newlib.dir/heap.c.obj
libnewlib.a,locks.c.obj,esp-idf/newlib/CMakeFiles/__idf_newlib.dir/locks.c.obj
libnewlib.a,reent_init.c.obj,esp-idf/newlib/CMakeFiles/__idf_newlib.dir/reent_init.c.obj
libnewlib.a,time.c.obj,esp-idf/newlib/CMakeFiles/__idf_newlib.dir/time.c.obj
libpthread.a,pthread.c.obj,esp-idf/pthread/CMakeFiles/__idf_pthread.dir/pthread.c.obj
libriscv.a,interrupt.c.obj,esp-idf/riscv/CMakeFiles/__idf_riscv.dir/interrupt.c.obj
libspi_flash.a,flash_brownout_hook.c.obj,esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/flash_brownout_hook.c.obj
libspi_flash.a,flash_ops.c.obj,esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/flash_ops.c.obj
libspi_flash.a,spi_flash_os_func_app.c.obj,esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/spi_flash_os_func_app.c.obj
libspi_flash.a,spi_flash_os_func_noos.c.obj,esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/spi_flash_os_func_noos.c.obj
1 library object path
2 libbootloader_support.a bootloader_flash.c.obj esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/bootloader_flash/src/bootloader_flash.c.obj
3 libbootloader_support.a flash_encrypt.c.obj esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/flash_encrypt.c.obj
4 libbt.a bt_osi_mem.c.obj esp-idf/bt/CMakeFiles/__idf_bt.dir/porting/mem/bt_osi_mem.c.obj
5 libbt.a bt.c.obj esp-idf/bt/CMakeFiles/__idf_bt.dir/controller/esp32c2/bt.c.obj
6 libbt.a npl_os_freertos.c.obj esp-idf/bt/CMakeFiles/__idf_bt.dir/porting/npl/freertos/src/npl_os_freertos.c.obj
7 libbt.a nimble_port.c.obj esp-idf/bt/CMakeFiles/__idf_bt.dir/host/nimble/nimble/porting/nimble/src/nimble_port.c.obj
8 libdriver.a gpio.c.obj esp-idf/driver/CMakeFiles/__idf_driver.dir/gpio/gpio.c.obj
9 libesp_app_format.a esp_app_desc.c.obj esp-idf/esp_app_format/CMakeFiles/__idf_esp_app_format.dir/esp_app_desc.c.obj
10 libesp_hw_support.a cpu.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/cpu.c.obj
11 libesp_hw_support.a esp_clk.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/esp_clk.c.obj
12 libesp_hw_support.a esp_memory_utils.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/esp_memory_utils.c.obj
13 libesp_hw_support.a hw_random.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/hw_random.c.obj
14 libesp_hw_support.a intr_alloc.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/intr_alloc.c.obj
15 libesp_hw_support.a periph_ctrl.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/periph_ctrl.c.obj
16 libesp_hw_support.a regi2c_ctrl.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/regi2c_ctrl.c.obj
17 libesp_hw_support.a rtc_clk.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_clk.c.obj
18 libesp_hw_support.a rtc_init.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_init.c.obj
19 libesp_hw_support.a rtc_module.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/rtc_module.c.obj
20 libesp_hw_support.a rtc_sleep.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_sleep.c.obj
21 libesp_hw_support.a rtc_time.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32c2/rtc_time.c.obj
22 libesp_hw_support.a sleep_modes.c.obj esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/sleep_modes.c.obj
23 libesp_phy.a phy_init.c.obj esp-idf/esp_phy/CMakeFiles/__idf_esp_phy.dir/src/phy_init.c.obj
24 libesp_phy.a phy_override.c.obj esp-idf/esp_phy/CMakeFiles/__idf_esp_phy.dir/src/phy_override.c.obj
25 libesp_pm.a pm_locks.c.obj esp-idf/esp_pm/CMakeFiles/__idf_esp_pm.dir/pm_locks.c.obj
26 libesp_pm.a pm_impl.c.obj esp-idf/esp_pm/CMakeFiles/__idf_esp_pm.dir/pm_impl.c.obj
27 libesp_ringbuf.a ringbuf.c.obj esp-idf/esp_ringbuf/CMakeFiles/__idf_esp_ringbuf.dir/ringbuf.c.obj
28 libesp_rom.a esp_rom_systimer.c.obj esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_systimer.c.obj
29 libesp_rom.a esp_rom_uart.c.obj esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_uart.c.obj
30 libesp_system.a brownout.c.obj esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/brownout.c.obj
31 libesp_system.a cache_err_int.c.obj esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/soc/esp32c2/cache_err_int.c.obj
32 libesp_system.a cpu_start.c.obj esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/cpu_start.c.obj
33 libesp_system.a crosscore_int.c.obj esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/crosscore_int.c.obj
34 libesp_system.a esp_system.c.obj esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/esp_system.c.obj
35 libesp_system.a reset_reason.c.obj esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/port/soc/esp32c2/reset_reason.c.obj
36 libesp_system.a ubsan.c.obj esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/ubsan.c.obj
37 libesp_timer.a esp_timer.c.obj esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/esp_timer.c.obj
38 libesp_timer.a esp_timer_impl_systimer.c.obj esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/esp_timer_impl_systimer.c.obj
39 libesp_timer.a ets_timer_legacy.c.obj esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/ets_timer_legacy.c.obj
40 libesp_timer.a system_time.c.obj esp-idf/esp_timer/CMakeFiles/__idf_esp_timer.dir/src/system_time.c.obj
41 libesp_wifi.a esp_adapter.c.obj esp-idf/esp_wifi/CMakeFiles/__idf_esp_wifi.dir/esp32c2/esp_adapter.c.obj
42 libfreertos.a list.c.obj esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/list.c.obj
43 libfreertos.a port.c.obj esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/portable/riscv/port.c.obj
44 libfreertos.a port_common.c.obj esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/portable/port_common.c.obj
45 libfreertos.a port_systick.c.obj esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/portable/port_systick.c.obj
46 libfreertos.a queue.c.obj esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/queue.c.obj
47 libfreertos.a tasks.c.obj esp-idf/freertos/CMakeFiles/__idf_freertos.dir/FreeRTOS-Kernel/tasks.c.obj
48 libhal.a brownout_hal.c.obj esp-idf/hal/CMakeFiles/__idf_hal.dir/esp32c2/brownout_hal.c.obj
49 libhal.a efuse_hal.c.obj esp-idf/hal/CMakeFiles/__idf_hal.dir/efuse_hal.c.obj
50 libhal.a efuse_hal.c.obj esp-idf/hal/CMakeFiles/__idf_hal.dir/esp32c2/efuse_hal.c.obj
51 libheap.a heap_caps.c.obj esp-idf/heap/CMakeFiles/__idf_heap.dir/heap_caps.c.obj
52 libheap.a multi_heap.c.obj ./esp-idf/heap/CMakeFiles/__idf_heap.dir/multi_heap.c.obj
53 liblog.a log_freertos.c.obj esp-idf/log/CMakeFiles/__idf_log.dir/log_freertos.c.obj
54 liblog.a log.c.obj esp-idf/log/CMakeFiles/__idf_log.dir/log.c.obj
55 libmbedcrypto.a esp_mem.c.obj esp-idf/mbedtls/mbedtls/library/CMakeFiles/mbedcrypto.dir/$IDF_PATH/components/mbedtls/port/esp_mem.c.obj
56 libnewlib.a assert.c.obj esp-idf/newlib/CMakeFiles/__idf_newlib.dir/assert.c.obj
57 libnewlib.a heap.c.obj esp-idf/newlib/CMakeFiles/__idf_newlib.dir/heap.c.obj
58 libnewlib.a locks.c.obj esp-idf/newlib/CMakeFiles/__idf_newlib.dir/locks.c.obj
59 libnewlib.a reent_init.c.obj esp-idf/newlib/CMakeFiles/__idf_newlib.dir/reent_init.c.obj
60 libnewlib.a time.c.obj esp-idf/newlib/CMakeFiles/__idf_newlib.dir/time.c.obj
61 libpthread.a pthread.c.obj esp-idf/pthread/CMakeFiles/__idf_pthread.dir/pthread.c.obj
62 libriscv.a interrupt.c.obj esp-idf/riscv/CMakeFiles/__idf_riscv.dir/interrupt.c.obj
63 libspi_flash.a flash_brownout_hook.c.obj esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/flash_brownout_hook.c.obj
64 libspi_flash.a flash_ops.c.obj esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/flash_ops.c.obj
65 libspi_flash.a spi_flash_os_func_app.c.obj esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/spi_flash_os_func_app.c.obj
66 libspi_flash.a spi_flash_os_func_noos.c.obj esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/spi_flash_os_func_noos.c.obj

View File

@@ -0,0 +1,311 @@
#!/usr/bin/env python3
#
# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
import logging
import argparse
import csv
import os
import subprocess
import sys
import re
from io import StringIO
import configuration
sys.path.append(os.environ['IDF_PATH'] + '/tools/ldgen')
sys.path.append(os.environ['IDF_PATH'] + '/tools/ldgen/ldgen')
from entity import EntityDB
espidf_objdump = None
def lib_secs(lib, file, lib_path):
new_env = os.environ.copy()
new_env['LC_ALL'] = 'C'
dump = StringIO(subprocess.check_output([espidf_objdump, '-h', lib_path], env=new_env).decode())
dump.name = lib
sections_infos = EntityDB()
sections_infos.add_sections_info(dump)
secs = sections_infos.get_sections(lib, file.split('.')[0] + '.c')
if len(secs) == 0:
secs = sections_infos.get_sections(lib, file.split('.')[0])
if len(secs) == 0:
raise ValueError('Failed to get sections from lib %s'%(lib_path))
return secs
def filter_secs(secs_a, secs_b):
new_secs = list()
for s_a in secs_a:
for s_b in secs_b:
if s_b in s_a:
new_secs.append(s_a)
return new_secs
def strip_secs(secs_a, secs_b):
secs = list(set(secs_a) - set(secs_b))
secs.sort()
return secs
def func2sect(func):
if ' ' in func:
func_l = func.split(' ')
else:
func_l = list()
func_l.append(func)
secs = list()
for l in func_l:
if '.iram1.' not in l:
secs.append('.literal.%s'%(l,))
secs.append('.text.%s'%(l, ))
else:
secs.append(l)
return secs
class filter_c:
def __init__(self, file):
lines = open(file).read().splitlines()
self.libs_desc = ''
self.libs = ''
for l in lines:
if ') .iram1 EXCLUDE_FILE(*' in l and ') .iram1.*)' in l:
desc = '\(EXCLUDE_FILE\((.*)\) .iram1 '
self.libs_desc = re.search(desc, l)[1]
self.libs = self.libs_desc.replace('*', '')
return
def match(self, lib):
if lib in self.libs:
print('Remove lib %s'%(lib))
return True
return False
def add(self):
return self.libs_desc
class target_c:
def __init__(self, lib, lib_path, file, fsecs):
self.lib = lib
self.file = file
self.lib_path = lib_path
self.fsecs = func2sect(fsecs)
self.desc = '*%s:%s.*'%(lib, file.split('.')[0])
secs = lib_secs(lib, file, lib_path)
if '.iram1.' in self.fsecs[0]:
self.secs = filter_secs(secs, ('.iram1.', ))
else:
self.secs = filter_secs(secs, ('.iram1.', '.text.', '.literal.'))
self.isecs = strip_secs(self.secs, self.fsecs)
def __str__(self):
s = 'lib=%s\nfile=%s\lib_path=%s\ndesc=%s\nsecs=%s\nfsecs=%s\nisecs=%s\n'%(\
self.lib, self.file, self.lib_path, self.desc, self.secs, self.fsecs,\
self.isecs)
return s
class relink_c:
def __init__(self, input, library_file, object_file, function_file, sdkconfig_file, missing_function_info):
self.filter = filter_c(input)
libraries = configuration.generator(library_file, object_file, function_file, sdkconfig_file, missing_function_info, espidf_objdump)
self.targets = list()
for i in libraries.libs:
lib = libraries.libs[i]
if self.filter.match(lib.name):
continue
for j in lib.objs:
obj = lib.objs[j]
self.targets.append(target_c(lib.name, lib.path, obj.name,
' '.join(obj.sections())))
# for i in self.targets:
# print(i)
self.__transform__()
def __transform__(self):
iram1_exclude = list()
iram1_include = list()
flash_include = list()
for t in self.targets:
secs = filter_secs(t.fsecs, ('.iram1.', ))
if len(secs) > 0:
iram1_exclude.append(t.desc)
secs = filter_secs(t.isecs, ('.iram1.', ))
if len(secs) > 0:
iram1_include.append(' %s(%s)'%(t.desc, ' '.join(secs)))
secs = t.fsecs
if len(secs) > 0:
flash_include.append(' %s(%s)'%(t.desc, ' '.join(secs)))
self.iram1_exclude = ' *(EXCLUDE_FILE(%s %s) .iram1.*) *(EXCLUDE_FILE(%s %s) .iram1)' % \
(self.filter.add(), ' '.join(iram1_exclude), \
self.filter.add(), ' '.join(iram1_exclude))
self.iram1_include = '\n'.join(iram1_include)
self.flash_include = '\n'.join(flash_include)
logging.debug('IRAM1 Exclude: %s'%(self.iram1_exclude))
logging.debug('IRAM1 Include: %s'%(self.iram1_include))
logging.debug('Flash Include: %s'%(self.flash_include))
def __replace__(self, lines):
def is_iram_desc(l):
if '*(.iram1 .iram1.*)' in l or (') .iram1 EXCLUDE_FILE(*' in l and ') .iram1.*)' in l):
return True
return False
iram_start = False
flash_done = False
for i in range(0, len(lines) - 1):
l = lines[i]
if '.iram0.text :' in l:
logging.debug('start to process .iram0.text')
iram_start = True
elif '.dram0.data :' in l:
logging.debug('end to process .iram0.text')
iram_start = False
elif is_iram_desc(l):
if iram_start:
lines[i] = '%s\n%s\n'%(self.iram1_exclude, self.iram1_include)
elif '(.stub .gnu.warning' in l:
if not flash_done:
lines[i] = '%s\n\n%s'%(self.flash_include, l)
elif self.flash_include in l:
flash_done = True
else:
if iram_start:
new_l = self._replace_func(l)
if new_l:
lines[i] = new_l
return lines
def _replace_func(self, l):
for t in self.targets:
if t.desc in l:
S = '.literal .literal.* .text .text.*'
if S in l:
if len(t.isecs) > 0:
return l.replace(S, ' '.join(t.isecs))
else:
return ' '
S = '%s(%s)'%(t.desc, ' '.join(t.fsecs))
if S in l:
return ' '
replaced = False
for s in t.fsecs:
s2 = s + ' '
if s2 in l:
l = l.replace(s2, '')
replaced = True
s2 = s + ')'
if s2 in l:
l = l.replace(s2, ')')
replaced = True
if '( )' in l or '()' in l:
return ' '
if replaced:
return l
else:
index = '*%s:(EXCLUDE_FILE'%(t.lib)
if index in l and t.file.split('.')[0] not in l:
for m in self.targets:
index = '*%s:(EXCLUDE_FILE'%(m.lib)
if index in l and m.file.split('.')[0] not in l:
l = l.replace('EXCLUDE_FILE(', 'EXCLUDE_FILE(%s '%(m.desc))
if len(m.isecs) > 0:
l += '\n %s(%s)'%(m.desc, ' '.join(m.isecs))
return l
return False
def save(self, input, output):
lines = open(input).read().splitlines()
lines = self.__replace__(lines)
open(output, 'w+').write('\n'.join(lines))
def main():
argparser = argparse.ArgumentParser(description='Relinker script generator')
argparser.add_argument(
'--input', '-i',
help='Linker template file',
type=str)
argparser.add_argument(
'--output', '-o',
help='Output linker script',
type=str)
argparser.add_argument(
'--library', '-l',
help='Library description directory',
type=str)
argparser.add_argument(
'--object', '-b',
help='Object description file',
type=str)
argparser.add_argument(
'--function', '-f',
help='Function description file',
type=str)
argparser.add_argument(
'--sdkconfig', '-s',
help='sdkconfig file',
type=str)
argparser.add_argument(
'--objdump', '-g',
help='GCC objdump command',
type=str)
argparser.add_argument(
'--debug', '-d',
help='Debug level(option is \'debug\')',
default='no',
type=str)
argparser.add_argument(
'--missing_function_info',
help='Print error information instead of throwing exception when missing function',
default=False,
type=bool)
args = argparser.parse_args()
if args.debug == 'debug':
logging.basicConfig(level=logging.DEBUG)
logging.debug('input: %s'%(args.input))
logging.debug('output: %s'%(args.output))
logging.debug('library: %s'%(args.library))
logging.debug('object: %s'%(args.object))
logging.debug('function: %s'%(args.function))
logging.debug('sdkconfig:%s'%(args.sdkconfig))
logging.debug('objdump: %s'%(args.objdump))
logging.debug('debug: %s'%(args.debug))
logging.debug('missing_function_info: %s'%(args.missing_function_info))
global espidf_objdump
espidf_objdump = args.objdump
relink = relink_c(args.input, args.library, args.object, args.function, args.sdkconfig, args.missing_function_info)
relink.save(args.input, args.output)
if __name__ == '__main__':
main()

View File

@@ -0,0 +1,8 @@
# The following lines of boilerplate have to be in your project's CMakeLists
# in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
set(EXTRA_COMPONENT_DIRS "$ENV{IDF_PATH}/tools/unit-test-app/components"
"../../cmake_utilities")
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(cmake_utilities_test_apps)

View File

@@ -0,0 +1,10 @@
idf_component_register( SRC_DIRS "."
INCLUDE_DIRS "."
REQUIRES cmake_utilities)
include(gcc)
include(gen_compressed_ota)
include(gen_single_bin)
include(package_manager)
include(relinker)
cu_pkg_define_version(${CMAKE_CURRENT_LIST_DIR})

View File

@@ -0,0 +1,6 @@
version: "3.2.1"
description: Test2 for cmake utilities
url: https://github.com/espressif/esp-iot-solution/tree/master/tools/cmake_utilities
issues: https://github.com/espressif/esp-iot-solution/issues
dependencies:
idf: ">=4.1"

View File

@@ -0,0 +1,16 @@
#include <stdio.h>
int test_component2_version_major()
{
return TEST_COMPONENT2_VER_MAJOR;
}
int test_component2_version_minor()
{
return TEST_COMPONENT2_VER_MINOR;
}
int test_component2_version_patch()
{
return TEST_COMPONENT2_VER_PATCH;
}

View File

@@ -0,0 +1,14 @@
#include <stdio.h>
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
int test_component2_version_major();
int test_component2_version_minor();
int test_component2_version_patch();
#ifdef __cplusplus
}
#endif

View File

@@ -0,0 +1,10 @@
idf_component_register( SRC_DIRS "."
INCLUDE_DIRS "."
REQUIRES cmake_utilities)
include(gcc)
include(gen_compressed_ota)
include(gen_single_bin)
include(package_manager)
include(relinker)
cu_pkg_define_version(${CMAKE_CURRENT_LIST_DIR})

View File

@@ -0,0 +1,6 @@
version: "1.2.3"
description: Test1 for cmake utilities
url: https://github.com/espressif/esp-iot-solution/tree/master/tools/cmake_utilities
issues: https://github.com/espressif/esp-iot-solution/issues
dependencies:
idf: ">=4.1"

View File

@@ -0,0 +1,16 @@
#include <stdio.h>
int test_component1_version_major()
{
return TEST_COMPONENT1_VER_MAJOR;
}
int test_component1_version_minor()
{
return TEST_COMPONENT1_VER_MINOR;
}
int test_component1_version_patch()
{
return TEST_COMPONENT1_VER_PATCH;
}

View File

@@ -0,0 +1,14 @@
#include <stdio.h>
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
int test_component1_version_major();
int test_component1_version_minor();
int test_component1_version_patch();
#ifdef __cplusplus
}
#endif

View File

@@ -0,0 +1,3 @@
idf_component_register(SRC_DIRS "."
INCLUDE_DIRS "."
REQUIRES unity test_utils test_component1 TEST-component2)

View File

@@ -0,0 +1,59 @@
/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdio.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "esp_system.h"
#include "esp_log.h"
#include "unity.h"
#include "test_component1.h"
#include "test_component2.h"
/* USB PIN fixed in esp32-s2, can not use io matrix */
#define TEST_MEMORY_LEAK_THRESHOLD (-400)
TEST_CASE("Test package manager version", "[cmake_utilities][package_manager]")
{
esp_log_level_set("*", ESP_LOG_INFO);
TEST_ASSERT_EQUAL_INT(test_component1_version_major(), 1);
TEST_ASSERT_EQUAL_INT(test_component1_version_minor(), 2);
TEST_ASSERT_EQUAL_INT(test_component1_version_patch(), 3);
TEST_ASSERT_EQUAL_INT(test_component2_version_major(), 3);
TEST_ASSERT_EQUAL_INT(test_component2_version_minor(), 2);
TEST_ASSERT_EQUAL_INT(test_component2_version_patch(), 1);
}
static size_t before_free_8bit;
static size_t before_free_32bit;
static void check_leak(size_t before_free, size_t after_free, const char *type)
{
ssize_t delta = after_free - before_free;
printf("MALLOC_CAP_%s: Before %u bytes free, After %u bytes free (delta %d)\n", type, before_free, after_free, delta);
TEST_ASSERT_MESSAGE(delta >= TEST_MEMORY_LEAK_THRESHOLD, "memory leak");
}
void setUp(void)
{
before_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
before_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
}
void tearDown(void)
{
size_t after_free_8bit = heap_caps_get_free_size(MALLOC_CAP_8BIT);
size_t after_free_32bit = heap_caps_get_free_size(MALLOC_CAP_32BIT);
check_leak(before_free_8bit, after_free_8bit, "8BIT");
check_leak(before_free_32bit, after_free_32bit, "32BIT");
}
void app_main(void)
{
printf("Cmake Utilities TEST \n");
unity_run_menu();
}

View File

@@ -0,0 +1,20 @@
'''
Steps to run these cases:
- Build
- . ${IDF_PATH}/export.sh
- pip install idf_build_apps
- python tools/build_apps.py tools/cmake_utilities/test_apps -t esp32s2
- Test
- pip install -r tools/requirements/requirement.pytest.txt
- pytest tools/cmake_utilities/test_apps --target esp32s2
'''
import pytest
from pytest_embedded import Dut
@pytest.mark.target('esp32s3')
@pytest.mark.env('generic')
def test_cmake_utilities(dut: Dut)-> None:
dut.expect_exact('Press ENTER to see the list of tests.')
dut.write('*')
dut.expect_unity_test_output(timeout = 1000)

View File

@@ -0,0 +1 @@
d4d8f2dc33205797169a97a02e0d89a8982f59fe0509129b54422052b8522f59

View File

@@ -0,0 +1 @@
idf_component_register(SRCS "esp_lcd_touch.c" INCLUDE_DIRS "include" REQUIRES "driver" "esp_lcd")

View File

@@ -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

View File

@@ -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

View File

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

View File

@@ -0,0 +1,6 @@
dependencies:
idf:
version: '>=4.4.2'
description: ESP LCD Touch - main component for using touch screen controllers
url: https://github.com/espressif/esp-bsp/tree/master/components/lcd_touch/esp_lcd_touch
version: 1.1.1

View File

@@ -0,0 +1,427 @@
/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief ESP LCD touch
*/
#pragma once
#include <stdbool.h>
#include "sdkconfig.h"
#include "esp_err.h"
#include "driver/gpio.h"
#include "esp_lcd_panel_io.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Touch controller type
*
*/
typedef struct esp_lcd_touch_s esp_lcd_touch_t;
typedef esp_lcd_touch_t *esp_lcd_touch_handle_t;
/**
* @brief Touch controller interrupt callback type
*
*/
typedef void (*esp_lcd_touch_interrupt_callback_t)(esp_lcd_touch_handle_t tp);
/**
* @brief Touch Configuration Type
*
*/
typedef struct {
uint16_t x_max; /*!< X coordinates max (for mirroring) */
uint16_t y_max; /*!< Y coordinates max (for mirroring) */
gpio_num_t rst_gpio_num; /*!< GPIO number of reset pin */
gpio_num_t int_gpio_num; /*!< GPIO number of interrupt pin */
struct {
unsigned int reset: 1; /*!< Level of reset pin in reset */
unsigned int interrupt: 1;/*!< Active Level of interrupt pin */
} levels;
struct {
unsigned int swap_xy: 1; /*!< Swap X and Y after read coordinates */
unsigned int mirror_x: 1; /*!< Mirror X after read coordinates */
unsigned int mirror_y: 1; /*!< Mirror Y after read coordinates */
} flags;
/*!< User callback called after get coordinates from touch controller for apply user adjusting */
void (*process_coordinates)(esp_lcd_touch_handle_t tp, uint16_t *x, uint16_t *y, uint16_t *strength, uint8_t *point_num, uint8_t max_point_num);
/*!< User callback called after the touch interrupt occured */
esp_lcd_touch_interrupt_callback_t interrupt_callback;
/*!< User data passed to callback */
void *user_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 occured
*
* @param tp: Touch handler
* @param callback: Interrupt callback
*
* @return
* - ESP_OK on success
*/
esp_err_t esp_lcd_touch_register_interrupt_callback(esp_lcd_touch_handle_t tp, esp_lcd_touch_interrupt_callback_t callback);
/**
* @brief Register user callback called after the touch interrupt occured 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

View File

@@ -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.

View File

@@ -0,0 +1 @@
97759953d9436a365e9427078c5b04ecce4e6a50f50cf62c68cd6bfa229b812c

View File

@@ -0,0 +1 @@
idf_component_register(SRCS "esp_lcd_touch_ft5x06.c" INCLUDE_DIRS "include" REQUIRES "esp_lcd")

View File

@@ -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);
```

View File

@@ -0,0 +1,330 @@
/*
* SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdio.h>
#include <string.h>
#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 "driver/i2c.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");
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);
}
}
*out_touch = 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);
}

View File

@@ -0,0 +1,9 @@
dependencies:
esp_lcd_touch:
public: true
version: ^1.0.4
idf:
version: '>=4.4.2'
description: ESP LCD Touch FT5x06 - touch controller FT5x06
url: https://github.com/espressif/esp-bsp/tree/master/components/lcd_touch/esp_lcd_touch_ft5x06
version: 1.0.6

View File

@@ -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

View File

@@ -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.

View File

@@ -0,0 +1,75 @@
dependencies:
esp_lcd_sh8601:
dependencies: []
source:
path: C:\Users\neila\Downloads\ESP32-S3-Touch-AMOLED-1.8-Demo\ESP-IDF-v5.3.2\05_LVGL_WITH_RAM\components\esp_lcd_sh8601
type: local
version: 1.0.0
espressif/cmake_utilities:
component_hash: 351350613ceafba240b761b4ea991e0f231ac7a9f59a9ee901f751bddc0bb18f
dependencies:
- name: idf
require: private
version: '>=4.1'
source:
registry_url: https://components.espressif.com/
type: service
version: 0.5.3
espressif/esp_io_expander:
component_hash: abf3ea0d71407d79d15500550aa3ba433848459b0fa94717cf9478822593ee5d
dependencies:
- name: idf
require: private
version: '>=4.4.2'
source:
registry_url: https://components.espressif.com
type: service
version: 1.1.0
espressif/esp_io_expander_tca9554:
component_hash: e9e49ddb1038c2b54b13c51b5e3e6dbdd10a878959c8ab0e0a7c8206316add61
dependencies:
- name: idf
require: private
version: '>=4.4.2'
- name: espressif/esp_io_expander
registry_url: https://components.espressif.com
require: private
version: ^1.0.1
source:
registry_url: https://components.espressif.com/
type: service
version: 1.0.1
espressif/esp_lcd_touch:
dependencies: []
source:
path: C:\Users\neila\Downloads\ESP32-S3-Touch-AMOLED-1.8-Demo\ESP-IDF-v5.3.2\05_LVGL_WITH_RAM\components\espressif__esp_lcd_touch
type: local
version: 1.1.1
espressif/esp_lcd_touch_ft5x06:
dependencies: []
source:
path: C:\Users\neila\Downloads\ESP32-S3-Touch-AMOLED-1.8-Demo\ESP-IDF-v5.3.2\05_LVGL_WITH_RAM\components\espressif__esp_lcd_touch_ft5x06
type: local
version: 1.0.6
idf:
source:
type: idf
version: 5.5.0
lvgl/lvgl:
component_hash: d7c1ac037ae6e85d94897f807d6e7ba0946a83e720074fc95a4f6241da9f9f53
dependencies: []
source:
registry_url: https://components.espressif.com/
type: service
version: 8.4.0
direct_dependencies:
- esp_lcd_sh8601
- espressif/cmake_utilities
- espressif/esp_io_expander_tca9554
- espressif/esp_lcd_touch
- espressif/esp_lcd_touch_ft5x06
- idf
- lvgl/lvgl
manifest_hash: 73d297b75a367c5296e4d374a0f8c4b79f7221d608e54c991bf3dd251ed9384f
target: esp32s3
version: 2.0.0

View File

@@ -0,0 +1,8 @@
idf_component_register(
SRCS "example_qspi_with_ram.c"
INCLUDE_DIRS ".")
set_source_files_properties(
${LV_DEMOS_SOURCES}
PROPERTIES COMPILE_OPTIONS
-DLV_LVGL_H_INCLUDE_SIMPLE)

View File

@@ -0,0 +1,408 @@
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "driver/i2c.h"
#include "driver/spi_master.h"
#include "esp_timer.h"
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_ops.h"
#include "esp_err.h"
#include "esp_log.h"
#include "lvgl.h"
#include "lv_demos.h"
#include "esp_lcd_sh8601.h"
#include "esp_lcd_touch_ft5x06.h"
#include "esp_io_expander_tca9554.h"
static const char *TAG = "example";
static SemaphoreHandle_t lvgl_mux = NULL;
#define LCD_HOST SPI2_HOST
#define TOUCH_HOST I2C_NUM_0
#if CONFIG_LV_COLOR_DEPTH == 32
#define LCD_BIT_PER_PIXEL (24)
#elif CONFIG_LV_COLOR_DEPTH == 16
#define LCD_BIT_PER_PIXEL (16)
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// Please update the following configuration according to your LCD spec //////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define EXAMPLE_LCD_BK_LIGHT_ON_LEVEL 1
#define EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL !EXAMPLE_LCD_BK_LIGHT_ON_LEVEL
#define EXAMPLE_PIN_NUM_LCD_CS (GPIO_NUM_12)
#define EXAMPLE_PIN_NUM_LCD_PCLK (GPIO_NUM_11)
#define EXAMPLE_PIN_NUM_LCD_DATA0 (GPIO_NUM_4)
#define EXAMPLE_PIN_NUM_LCD_DATA1 (GPIO_NUM_5)
#define EXAMPLE_PIN_NUM_LCD_DATA2 (GPIO_NUM_6)
#define EXAMPLE_PIN_NUM_LCD_DATA3 (GPIO_NUM_7)
#define EXAMPLE_PIN_NUM_LCD_RST (-1)
#define EXAMPLE_PIN_NUM_BK_LIGHT (-1)
// The pixel number in horizontal and vertical
#define EXAMPLE_LCD_H_RES 368
#define EXAMPLE_LCD_V_RES 448
#define EXAMPLE_USE_TOUCH 1
#if EXAMPLE_USE_TOUCH
#define EXAMPLE_PIN_NUM_TOUCH_SCL (GPIO_NUM_14)
#define EXAMPLE_PIN_NUM_TOUCH_SDA (GPIO_NUM_15)
#define EXAMPLE_PIN_NUM_TOUCH_RST (-1)
#define EXAMPLE_PIN_NUM_TOUCH_INT (GPIO_NUM_21)
esp_lcd_touch_handle_t tp = NULL;
#endif
#define EXAMPLE_LVGL_BUF_HEIGHT (EXAMPLE_LCD_V_RES / 4)
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
#define EXAMPLE_LVGL_TASK_MAX_DELAY_MS 500
#define EXAMPLE_LVGL_TASK_MIN_DELAY_MS 1
#define EXAMPLE_LVGL_TASK_STACK_SIZE (4 * 1024)
#define EXAMPLE_LVGL_TASK_PRIORITY 2
static const sh8601_lcd_init_cmd_t lcd_init_cmds[] = {
{0x11, (uint8_t[]){0x00}, 0, 120},
{0x44, (uint8_t[]){0x01, 0xD1}, 2, 0},
{0x35, (uint8_t[]){0x00}, 1, 0},
{0x53, (uint8_t[]){0x20}, 1, 10},
{0x2A, (uint8_t[]){0x00, 0x00, 0x01, 0x6F}, 4, 0},
{0x2B, (uint8_t[]){0x00, 0x00, 0x01, 0xBF}, 4, 0},
{0x51, (uint8_t[]){0x00}, 1, 10},
{0x29, (uint8_t[]){0x00}, 0, 10},
{0x51, (uint8_t[]){0xFF}, 1, 0},
};
static bool example_notify_lvgl_flush_ready(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
{
lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;
lv_disp_flush_ready(disp_driver);
return false;
}
static void example_lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
const int offsetx1 = area->x1;
const int offsetx2 = area->x2;
const int offsety1 = area->y1;
const int offsety2 = area->y2;
#if LCD_BIT_PER_PIXEL == 24
uint8_t *to = (uint8_t *)color_map;
uint8_t temp = 0;
uint16_t pixel_num = (offsetx2 - offsetx1 + 1) * (offsety2 - offsety1 + 1);
// Special dealing for first pixel
temp = color_map[0].ch.blue;
*to++ = color_map[0].ch.red;
*to++ = color_map[0].ch.green;
*to++ = temp;
// Normal dealing for other pixels
for (int i = 1; i < pixel_num; i++)
{
*to++ = color_map[i].ch.red;
*to++ = color_map[i].ch.green;
*to++ = color_map[i].ch.blue;
}
#endif
// copy a buffer's content to a specific area of the display
esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map);
}
/* Rotate display and touch, when rotated screen in LVGL. Called when driver parameters are updated. */
static void example_lvgl_update_cb(lv_disp_drv_t *drv)
{
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t)drv->user_data;
switch (drv->rotated)
{
case LV_DISP_ROT_NONE:
// Rotate LCD display
esp_lcd_panel_swap_xy(panel_handle, false);
esp_lcd_panel_mirror(panel_handle, true, false);
break;
case LV_DISP_ROT_90:
// Rotate LCD display
esp_lcd_panel_swap_xy(panel_handle, true);
esp_lcd_panel_mirror(panel_handle, true, true);
break;
case LV_DISP_ROT_180:
// Rotate LCD display
esp_lcd_panel_swap_xy(panel_handle, false);
esp_lcd_panel_mirror(panel_handle, false, true);
break;
case LV_DISP_ROT_270:
// Rotate LCD display
esp_lcd_panel_swap_xy(panel_handle, true);
esp_lcd_panel_mirror(panel_handle, false, false);
break;
}
}
void example_lvgl_rounder_cb(struct _lv_disp_drv_t *disp_drv, lv_area_t *area)
{
uint16_t x1 = area->x1;
uint16_t x2 = area->x2;
uint16_t y1 = area->y1;
uint16_t y2 = area->y2;
// round the start of coordinate down to the nearest 2M number
area->x1 = (x1 >> 1) << 1;
area->y1 = (y1 >> 1) << 1;
// round the end of coordinate up to the nearest 2N+1 number
area->x2 = ((x2 >> 1) << 1) + 1;
area->y2 = ((y2 >> 1) << 1) + 1;
}
#if EXAMPLE_USE_TOUCH
static void example_lvgl_touch_cb(lv_indev_drv_t *drv, lv_indev_data_t *data)
{
esp_lcd_touch_handle_t tp = (esp_lcd_touch_handle_t)drv->user_data;
assert(tp);
uint16_t tp_x;
uint16_t tp_y;
uint8_t tp_cnt = 0;
/* Read data from touch controller into memory */
esp_lcd_touch_read_data(tp);
/* Read data from touch controller */
bool tp_pressed = esp_lcd_touch_get_coordinates(tp, &tp_x, &tp_y, NULL, &tp_cnt, 1);
if (tp_pressed && tp_cnt > 0)
{
data->point.x = tp_x;
data->point.y = tp_y;
data->state = LV_INDEV_STATE_PRESSED;
ESP_LOGD(TAG, "Touch position: %d,%d", tp_x, tp_y);
}
else
{
data->state = LV_INDEV_STATE_RELEASED;
}
}
#endif
static void example_increase_lvgl_tick(void *arg)
{
/* Tell LVGL how many milliseconds has elapsed */
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
}
static bool example_lvgl_lock(int timeout_ms)
{
assert(lvgl_mux && "bsp_display_start must be called first");
const TickType_t timeout_ticks = (timeout_ms == -1) ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms);
return xSemaphoreTake(lvgl_mux, timeout_ticks) == pdTRUE;
}
static void example_lvgl_unlock(void)
{
assert(lvgl_mux && "bsp_display_start must be called first");
xSemaphoreGive(lvgl_mux);
}
static void example_lvgl_port_task(void *arg)
{
ESP_LOGI(TAG, "Starting LVGL task");
uint32_t task_delay_ms = EXAMPLE_LVGL_TASK_MAX_DELAY_MS;
while (1)
{
// Lock the mutex due to the LVGL APIs are not thread-safe
if (example_lvgl_lock(-1))
{
task_delay_ms = lv_timer_handler();
// Release the mutex
example_lvgl_unlock();
}
if (task_delay_ms > EXAMPLE_LVGL_TASK_MAX_DELAY_MS)
{
task_delay_ms = EXAMPLE_LVGL_TASK_MAX_DELAY_MS;
}
else if (task_delay_ms < EXAMPLE_LVGL_TASK_MIN_DELAY_MS)
{
task_delay_ms = EXAMPLE_LVGL_TASK_MIN_DELAY_MS;
}
vTaskDelay(pdMS_TO_TICKS(task_delay_ms));
}
}
void app_main(void)
{
esp_log_level_set("lcd_panel.io.i2c", ESP_LOG_NONE);
esp_log_level_set("FT5x06", ESP_LOG_NONE);
static lv_disp_draw_buf_t disp_buf; // contains internal graphic buffer(s) called draw buffer(s)
static lv_disp_drv_t disp_drv; // contains callback functions
ESP_LOGI(TAG, "Initialize I2C bus");
const i2c_config_t i2c_conf = {
.mode = I2C_MODE_MASTER,
.sda_io_num = EXAMPLE_PIN_NUM_TOUCH_SDA,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_io_num = EXAMPLE_PIN_NUM_TOUCH_SCL,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master.clk_speed = 200 * 1000,
};
ESP_ERROR_CHECK(i2c_param_config(TOUCH_HOST, &i2c_conf));
ESP_ERROR_CHECK(i2c_driver_install(TOUCH_HOST, i2c_conf.mode, 0, 0, 0));
esp_io_expander_handle_t io_expander = NULL;
esp_io_expander_new_i2c_tca9554(TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander);
ESP_ERROR_CHECK(esp_io_expander_new_i2c_tca9554(TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander));
esp_io_expander_set_dir(io_expander, IO_EXPANDER_PIN_NUM_0 | IO_EXPANDER_PIN_NUM_1 | IO_EXPANDER_PIN_NUM_2, IO_EXPANDER_OUTPUT);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 0);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 0);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 0);
vTaskDelay(pdMS_TO_TICKS(200));
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 1);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_1, 1);
esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 1);
#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0
ESP_LOGI(TAG, "Turn off LCD backlight");
gpio_config_t bk_gpio_config = {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = 1ULL << EXAMPLE_PIN_NUM_BK_LIGHT};
ESP_ERROR_CHECK(gpio_config(&bk_gpio_config));
#endif
ESP_LOGI(TAG, "Initialize SPI bus");
const spi_bus_config_t buscfg = SH8601_PANEL_BUS_QSPI_CONFIG(EXAMPLE_PIN_NUM_LCD_PCLK,
EXAMPLE_PIN_NUM_LCD_DATA0,
EXAMPLE_PIN_NUM_LCD_DATA1,
EXAMPLE_PIN_NUM_LCD_DATA2,
EXAMPLE_PIN_NUM_LCD_DATA3,
EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES * LCD_BIT_PER_PIXEL / 8);
ESP_ERROR_CHECK(spi_bus_initialize(LCD_HOST, &buscfg, SPI_DMA_CH_AUTO));
ESP_LOGI(TAG, "Install panel IO");
esp_lcd_panel_io_handle_t io_handle = NULL;
const esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG(EXAMPLE_PIN_NUM_LCD_CS,
example_notify_lvgl_flush_ready,
&disp_drv);
sh8601_vendor_config_t vendor_config = {
.init_cmds = lcd_init_cmds,
.init_cmds_size = sizeof(lcd_init_cmds) / sizeof(lcd_init_cmds[0]),
.flags = {
.use_qspi_interface = 1,
},
};
// Attach the LCD to the SPI bus
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST, &io_config, &io_handle));
esp_lcd_panel_handle_t panel_handle = NULL;
const esp_lcd_panel_dev_config_t panel_config = {
.reset_gpio_num = EXAMPLE_PIN_NUM_LCD_RST,
.rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
.bits_per_pixel = LCD_BIT_PER_PIXEL,
.vendor_config = &vendor_config,
};
ESP_LOGI(TAG, "Install SH8601 panel driver");
ESP_ERROR_CHECK(esp_lcd_new_panel_sh8601(io_handle, &panel_config, &panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_reset(panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_init(panel_handle));
// user can flush pre-defined pattern to the screen before we turn on the screen or backlight
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(panel_handle, true));
#if EXAMPLE_USE_TOUCH
esp_lcd_panel_io_handle_t tp_io_handle = NULL;
const esp_lcd_panel_io_i2c_config_t tp_io_config = ESP_LCD_TOUCH_IO_I2C_FT5x06_CONFIG();
// Attach the TOUCH to the I2C bus
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)TOUCH_HOST, &tp_io_config, &tp_io_handle));
const esp_lcd_touch_config_t tp_cfg = {
.x_max = EXAMPLE_LCD_H_RES,
.y_max = EXAMPLE_LCD_V_RES,
.rst_gpio_num = EXAMPLE_PIN_NUM_TOUCH_RST,
.int_gpio_num = EXAMPLE_PIN_NUM_TOUCH_INT,
.levels = {
.reset = 0,
.interrupt = 0,
},
.flags = {
.swap_xy = 0,
.mirror_x = 0,
.mirror_y = 0,
},
};
ESP_LOGI(TAG, "Initialize touch controller");
ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_ft5x06(tp_io_handle, &tp_cfg, &tp));
#endif
#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0
ESP_LOGI(TAG, "Turn on LCD backlight");
gpio_set_level(EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_ON_LEVEL);
#endif
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
lv_color_t *buf1 = heap_caps_malloc(EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
assert(buf1);
lv_color_t *buf2 = heap_caps_malloc(EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT * sizeof(lv_color_t), MALLOC_CAP_DMA);
assert(buf2);
// initialize LVGL draw buffers
lv_disp_draw_buf_init(&disp_buf, buf1, buf2, EXAMPLE_LCD_H_RES * EXAMPLE_LVGL_BUF_HEIGHT);
ESP_LOGI(TAG, "Register display driver to LVGL");
lv_disp_drv_init(&disp_drv);
disp_drv.hor_res = EXAMPLE_LCD_H_RES;
disp_drv.ver_res = EXAMPLE_LCD_V_RES;
disp_drv.flush_cb = example_lvgl_flush_cb;
disp_drv.rounder_cb = example_lvgl_rounder_cb;
disp_drv.drv_update_cb = example_lvgl_update_cb;
disp_drv.draw_buf = &disp_buf;
disp_drv.user_data = panel_handle;
lv_disp_t *disp = lv_disp_drv_register(&disp_drv);
ESP_LOGI(TAG, "Install LVGL tick timer");
// Tick interface for LVGL (using esp_timer to generate 2ms periodic event)
const esp_timer_create_args_t lvgl_tick_timer_args = {
.callback = &example_increase_lvgl_tick,
.name = "lvgl_tick"};
esp_timer_handle_t lvgl_tick_timer = NULL;
ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));
ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000));
#if EXAMPLE_USE_TOUCH
static lv_indev_drv_t indev_drv; // Input device driver (Touch)
lv_indev_drv_init(&indev_drv);
indev_drv.type = LV_INDEV_TYPE_POINTER;
indev_drv.disp = disp;
indev_drv.read_cb = example_lvgl_touch_cb;
indev_drv.user_data = tp;
lv_indev_drv_register(&indev_drv);
#endif
lvgl_mux = xSemaphoreCreateMutex();
assert(lvgl_mux);
xTaskCreate(example_lvgl_port_task, "LVGL", EXAMPLE_LVGL_TASK_STACK_SIZE, NULL, EXAMPLE_LVGL_TASK_PRIORITY, NULL);
ESP_LOGI(TAG, "Display LVGL demos");
// Lock the mutex due to the LVGL APIs are not thread-safe
if (example_lvgl_lock(-1))
{
// lv_demo_widgets(); /* A widgets example */
lv_demo_music(); /* A modern, smartphone-like music player demo. */
// lv_demo_stress(); /* A stress test for LVGL. */
// lv_demo_benchmark(); /* A demo to measure the performance of LVGL or to compare different settings. */
// Release the mutex
example_lvgl_unlock();
}
}

View File

@@ -0,0 +1,18 @@
version: "1.0.0"
dependencies:
espressif/esp_io_expander_tca9554: "^1.0.1"
idf: ">5.0.4,!=5.1.1"
esp_lcd_touch_ft5x06:
version: "*"
public: true
esp_lcd_sh8601:
path: "../components/esp_lcd_sh8601"
version: "*"
public: true
lvgl/lvgl:
version: "8.4.*"
public: true

View File

@@ -0,0 +1,5 @@
# Name, Type, SubType, Offset, Size, Flags
# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
nvs, data, nvs, , 0x6000,
phy_init, data, phy, , 0x1000,
factory, app, factory, , 3M,
1 # Name, Type, SubType, Offset, Size, Flags
2 # Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
3 nvs, data, nvs, , 0x6000,
4 phy_init, data, phy, , 0x1000,
5 factory, app, factory, , 3M,

2804
05_LVGL_WITH_RAM/sdkconfig Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,31 @@
# This file was generated using idf.py save-defconfig. It can be edited manually.
# Espressif IoT Development Framework (ESP-IDF) 5.2.0 Project Minimal Configuration
#
CONFIG_IDF_TARGET="esp32s3"
CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_COMPILER_OPTIMIZATION_PERF=y
CONFIG_SPIRAM=y
CONFIG_SPIRAM_MODE_OCT=y
CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y
CONFIG_SPIRAM_RODATA=y
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
CONFIG_ESP32S3_DATA_CACHE_LINE_64B=y
CONFIG_FREERTOS_HZ=1000
CONFIG_LV_DISP_DEF_REFR_PERIOD=4
CONFIG_LV_INDEV_DEF_READ_PERIOD=4
CONFIG_LV_COLOR_16_SWAP=y
CONFIG_LV_COLOR_SCREEN_TRANSP=y
CONFIG_LV_MEM_CUSTOM=y
CONFIG_LV_MEMCPY_MEMSET_STD=y
CONFIG_LV_USE_PERF_MONITOR=y
CONFIG_LV_ATTRIBUTE_FAST_MEM_USE_IRAM=y
CONFIG_LV_FONT_MONTSERRAT_12=y
CONFIG_LV_FONT_MONTSERRAT_16=y
CONFIG_LV_USE_DEMO_WIDGETS=y
CONFIG_LV_USE_DEMO_BENCHMARK=y
CONFIG_LV_USE_DEMO_STRESS=y
CONFIG_LV_USE_DEMO_MUSIC=y
CONFIG_LV_DEMO_MUSIC_AUTO_PLAY=n

View File

@@ -485,7 +485,8 @@ void app_main(void) {
esp_lcd_panel_io_spi_config_t io_config = SH8601_PANEL_IO_QSPI_CONFIG(
PIN_NUM_LCD_CS, notify_lvgl_flush_ready, &disp_drv);
io_config.pclk_hz = 80 * 1000 * 1000; /* Boost to 80MHz for 60FPS */
io_config.pclk_hz =
40 * 1000 * 1000; /* Reduced to 40MHz for stability (matching demo) */
ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)LCD_HOST,
&io_config, &lcd_io));
@@ -502,10 +503,15 @@ void app_main(void) {
.bits_per_pixel = LCD_BIT_PER_PIXEL,
.vendor_config = &vendor_config,
};
ESP_LOGI(TAG, "Install SH8601 panel driver");
ESP_ERROR_CHECK(esp_lcd_new_panel_sh8601(lcd_io, &panel_config, &lcd_panel));
ESP_LOGI(TAG, "Resetting panel");
ESP_ERROR_CHECK(esp_lcd_panel_reset(lcd_panel));
ESP_LOGI(TAG, "Initializing panel");
ESP_ERROR_CHECK(esp_lcd_panel_init(lcd_panel));
ESP_LOGI(TAG, "Turning panel ON");
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(lcd_panel, true));
ESP_LOGI(TAG, "Panel init complete");
/* Touch Driver Setup (FT5x06) */
#if USE_TOUCH