alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2025-11-04 06:11:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'origin/feature/esp_lcd_panel_init_result_check' into 'master'

Browse Source 
fix(esp_lcd): Check the result of each esp_lcd_panel_io_tx_param/esp_lcd_panel_io_tx_color call

Closes IDFGH-10494

See merge request espressif/esp-idf!24604
This commit is contained in:
morris
2023-07-13 15:40:54 +08:00
parent 3fca9b778a c190beb4d9
commit 84a680b057
7 changed files with 114 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.gitlab/ci/target-test.yml
View File

@@ -813,6 +813,14 @@ pytest_components_esp32c3_generic:
tags: [ esp32c3, generic ] tags: [ esp32c3, generic ]
parallel: 3 parallel: 3
pytest_components_esp32c3_i2c_oled:
extends:
- .pytest_components_dir_template
- .rules:test:component_ut-esp32c3
needs:
- build_pytest_components_esp32c3
tags: [ esp32c3, i2c_oled ]
pytest_components_esp32c3_generic_multi_device: pytest_components_esp32c3_generic_multi_device:
extends: extends:
- .pytest_components_dir_template - .pytest_components_dir_template

5
components/esp_lcd/.build-test-rules.yml
View File

@@ -3,6 +3,11 @@
components/esp_lcd/test_apps/i2c_lcd: components/esp_lcd/test_apps/i2c_lcd:
disable: disable:
- if: SOC_I2C_SUPPORTED != 1 - if: SOC_I2C_SUPPORTED != 1
disable_test:
- if: IDF_TARGET not in ["esp32c3"]
temporary: true
reason: insufficient runners
components/esp_lcd/test_apps/i80_lcd: components/esp_lcd/test_apps/i80_lcd:
disable: disable:

74
components/esp_lcd/src/esp_lcd_panel_nt35510.c
View File

@@ -7,11 +7,13 @@
#include <stdlib.h> #include <stdlib.h>
#include <sys/cdefs.h> #include <sys/cdefs.h>
#include "sdkconfig.h" #include "sdkconfig.h"
#if CONFIG_LCD_ENABLE_DEBUG_LOG #if CONFIG_LCD_ENABLE_DEBUG_LOG
// The local log level must be defined before including esp_log.h // The local log level must be defined before including esp_log.h
// Set the maximum log level for this source file // Set the maximum log level for this source file
#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG #define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
#endif #endif
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "esp_lcd_panel_interface.h" #include "esp_lcd_panel_interface.h"
@@ -28,7 +30,8 @@ static const char *TAG = "lcd_panel.nt35510";
static esp_err_t panel_nt35510_del(esp_lcd_panel_t *panel); static esp_err_t panel_nt35510_del(esp_lcd_panel_t *panel);
static esp_err_t panel_nt35510_reset(esp_lcd_panel_t *panel); static esp_err_t panel_nt35510_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_nt35510_init(esp_lcd_panel_t *panel); static esp_err_t panel_nt35510_init(esp_lcd_panel_t *panel);
static esp_err_t panel_nt35510_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_nt35510_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_nt35510_invert_color(esp_lcd_panel_t *panel, bool invert_color_data); static esp_err_t panel_nt35510_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_nt35510_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y); static esp_err_t panel_nt35510_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_nt35510_swap_xy(esp_lcd_panel_t *panel, bool swap_axes); static esp_err_t panel_nt35510_swap_xy(esp_lcd_panel_t *panel, bool swap_axes);
@@ -47,7 +50,9 @@ typedef struct {
uint8_t colmod_cal; // save surrent value of LCD_CMD_COLMOD register uint8_t colmod_cal; // save surrent value of LCD_CMD_COLMOD register
} nt35510_panel_t; } nt35510_panel_t;
esp_err_t esp_lcd_new_panel_nt35510(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel) esp_err_t
esp_lcd_new_panel_nt35510(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)
{ {
#if CONFIG_LCD_ENABLE_DEBUG_LOG #if CONFIG_LCD_ENABLE_DEBUG_LOG
esp_log_level_set(TAG, ESP_LOG_DEBUG); esp_log_level_set(TAG, ESP_LOG_DEBUG);
@@ -151,7 +156,8 @@ static esp_err_t panel_nt35510_reset(esp_lcd_panel_t *panel)
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} else { } else {
// perform software reset // perform software reset
esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET << 8, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET << 8, NULL, 0), TAG,
"io tx param LCD_CMD_SWRESET failed");
vTaskDelay(pdMS_TO_TICKS(20)); // spec, wait at least 5m before sending new command vTaskDelay(pdMS_TO_TICKS(20)); // spec, wait at least 5m before sending new command
} }
@@ -163,19 +169,21 @@ static esp_err_t panel_nt35510_init(esp_lcd_panel_t *panel)
nt35510_panel_t *nt35510 = __containerof(panel, nt35510_panel_t, base); nt35510_panel_t *nt35510 = __containerof(panel, nt35510_panel_t, base);
esp_lcd_panel_io_handle_t io = nt35510->io; esp_lcd_panel_io_handle_t io = nt35510->io;
// LCD goes into sleep mode and display will be turned off after power on reset, exit sleep mode first // LCD goes into sleep mode and display will be turned off after power on reset, exit sleep mode first
esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT << 8, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT << 8, NULL, 0), TAG,
"io tx param LCD_CMD_SLPOUT failed");;
vTaskDelay(pdMS_TO_TICKS(100)); vTaskDelay(pdMS_TO_TICKS(100));
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL << 8, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL << 8, (uint16_t[]) {
nt35510->madctl_val, nt35510->madctl_val,
}, 2); }, 2), TAG, "io tx param LCD_CMD_MADCTL failed");
esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD << 8, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD << 8, (uint16_t[]) {
nt35510->colmod_cal, nt35510->colmod_cal,
}, 2); }, 2), TAG, "io tx param LCD_CMD_COLMOD failed");
return ESP_OK; return ESP_OK;
} }
static esp_err_t panel_nt35510_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_nt35510_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end,
const void *color_data)
{ {
nt35510_panel_t *nt35510 = __containerof(panel, nt35510_panel_t, base); nt35510_panel_t *nt35510 = __containerof(panel, nt35510_panel_t, base);
assert((x_start < x_end) && (y_start < y_end) && "start position must be smaller than end position"); assert((x_start < x_end) && (y_start < y_end) && "start position must be smaller than end position");
@@ -187,33 +195,33 @@ static esp_err_t panel_nt35510_draw_bitmap(esp_lcd_panel_t *panel, int x_start,
y_end += nt35510->y_gap; y_end += nt35510->y_gap;
// define an area of frame memory where MCU can access // define an area of frame memory where MCU can access
esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 0, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 0, (uint16_t[]) {
(x_start >> 8) & 0xFF, (x_start >> 8) & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_CASET failed");
esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 1, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 1, (uint16_t[]) {
x_start & 0xFF, x_start & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_CASET failed");
esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 2, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 2, (uint16_t[]) {
((x_end - 1) >> 8) & 0xFF, ((x_end - 1) >> 8) & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_CASET failed");
esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 3, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_CASET << 8) + 3, (uint16_t[]) {
(x_end - 1) & 0xFF, (x_end - 1) & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_CASET failed");
esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 0, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 0, (uint16_t[]) {
(y_start >> 8) & 0xFF, (y_start >> 8) & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_RASET failed");
esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 1, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 1, (uint16_t[]) {
y_start & 0xFF, y_start & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_RASET failed");
esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 2, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 2, (uint16_t[]) {
((y_end - 1) >> 8) & 0xFF, ((y_end - 1) >> 8) & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_RASET failed");
esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 3, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, (LCD_CMD_RASET << 8) + 3, (uint16_t[]) {
(y_end - 1) & 0xFF, (y_end - 1) & 0xFF,
}, 2); }, 2), TAG, "io tx param LCD_CMD_RASET failed");
// transfer frame buffer // transfer frame buffer
size_t len = (x_end - x_start) * (y_end - y_start) * nt35510->fb_bits_per_pixel / 8; size_t len = (x_end - x_start) * (y_end - y_start) * nt35510->fb_bits_per_pixel / 8;
esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR << 8, color_data, len); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR << 8, color_data, len), TAG, "io tx color failed");
return ESP_OK; return ESP_OK;
} }
@@ -228,7 +236,8 @@ static esp_err_t panel_nt35510_invert_color(esp_lcd_panel_t *panel, bool invert_
} else { } else {
command = LCD_CMD_INVOFF; command = LCD_CMD_INVOFF;
} }
esp_lcd_panel_io_tx_param(io, command << 8, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command << 8, NULL, 0), TAG,
"io tx param LCD_CMD_INVON/LCD_CMD_INVOFF failed");
return ESP_OK; return ESP_OK;
} }
@@ -246,9 +255,9 @@ static esp_err_t panel_nt35510_mirror(esp_lcd_panel_t *panel, bool mirror_x, boo
} else { } else {
nt35510->madctl_val &= ~LCD_CMD_MY_BIT; nt35510->madctl_val &= ~LCD_CMD_MY_BIT;
} }
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL << 8, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL << 8, (uint16_t[]) {
nt35510->madctl_val nt35510->madctl_val
}, 2); }, 2), TAG, "io tx param LCD_CMD_MADCTL failed");
return ESP_OK; return ESP_OK;
} }
@@ -261,9 +270,9 @@ static esp_err_t panel_nt35510_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
} else { } else {
nt35510->madctl_val &= ~LCD_CMD_MV_BIT; nt35510->madctl_val &= ~LCD_CMD_MV_BIT;
} }
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL << 8, (uint16_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL << 8, (uint16_t[]) {
nt35510->madctl_val nt35510->madctl_val
}, 2); }, 2), TAG, "io tx param LCD_CMD_MADCTL failed");
return ESP_OK; return ESP_OK;
} }
@@ -285,6 +294,7 @@ static esp_err_t panel_nt35510_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
} else { } else {
command = LCD_CMD_DISPOFF; command = LCD_CMD_DISPOFF;
} }
esp_lcd_panel_io_tx_param(io, command << 8, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command << 8, NULL, 0), TAG,
"io tx param LCD_CMD_DISPON/LCD_CMD_DISPOFF failed");
return ESP_OK; return ESP_OK;
} }

40
components/esp_lcd/src/esp_lcd_panel_ssd1306.c
View File

@@ -5,6 +5,7 @@
*/ */
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h>
#include <sys/cdefs.h> #include <sys/cdefs.h>
#include "sdkconfig.h" #include "sdkconfig.h"
#if CONFIG_LCD_ENABLE_DEBUG_LOG #if CONFIG_LCD_ENABLE_DEBUG_LOG
@@ -137,15 +138,18 @@ static esp_err_t panel_ssd1306_init(esp_lcd_panel_t *panel)
{ {
ssd1306_panel_t *ssd1306 = __containerof(panel, ssd1306_panel_t, base); ssd1306_panel_t *ssd1306 = __containerof(panel, ssd1306_panel_t, base);
esp_lcd_panel_io_handle_t io = ssd1306->io; esp_lcd_panel_io_handle_t io = ssd1306->io;
esp_lcd_panel_io_tx_param(io, SSD1306_CMD_DISP_OFF, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, SSD1306_CMD_DISP_OFF, NULL, 0), TAG,
esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_MEMORY_ADDR_MODE, (uint8_t[]) { "io tx param SSD1306_CMD_DISP_OFF failed");
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_MEMORY_ADDR_MODE, (uint8_t[]) {
0x00 // horizontal addressing mode 0x00 // horizontal addressing mode
}, 1); }, 1), TAG, "io tx param SSD1306_CMD_SET_MEMORY_ADDR_MODE failed");
esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_CHARGE_PUMP, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_CHARGE_PUMP, (uint8_t[]) {
0x14 // enable charge pump 0x14 // enable charge pump
}, 1); }, 1), TAG, "io tx param SSD1306_CMD_SET_CHARGE_PUMP failed");
esp_lcd_panel_io_tx_param(io, SSD1306_CMD_MIRROR_X_OFF, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, SSD1306_CMD_MIRROR_X_OFF, NULL, 0), TAG,
esp_lcd_panel_io_tx_param(io, SSD1306_CMD_MIRROR_Y_OFF, NULL, 0); "io tx param SSD1306_CMD_MIRROR_X_OFF failed");
ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, SSD1306_CMD_MIRROR_Y_OFF, NULL, 0), TAG,
"io tx param SSD1306_CMD_MIRROR_Y_OFF failed");
return ESP_OK; return ESP_OK;
} }
@@ -174,17 +178,17 @@ static esp_err_t panel_ssd1306_draw_bitmap(esp_lcd_panel_t *panel, int x_start,
uint8_t page_start = y_start / 8; uint8_t page_start = y_start / 8;
uint8_t page_end = (y_end - 1) / 8; uint8_t page_end = (y_end - 1) / 8;
// define an area of frame memory where MCU can access // define an area of frame memory where MCU can access
esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_COLUMN_RANGE, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_COLUMN_RANGE, (uint8_t[]) {
(x_start & 0x7F), (x_start & 0x7F),
((x_end - 1) & 0x7F), ((x_end - 1) & 0x7F),
}, 2); }, 2), TAG, "io tx param SSD1306_CMD_SET_COLUMN_RANGE failed");
esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_PAGE_RANGE, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, SSD1306_CMD_SET_PAGE_RANGE, (uint8_t[]) {
(page_start & 0x07), (page_start & 0x07),
(page_end & 0x07), (page_end & 0x07),
}, 2); }, 2), TAG, "io tx param SSD1306_CMD_SET_PAGE_RANGE failed");
// transfer frame buffer // transfer frame buffer
size_t len = (y_end - y_start) * (x_end - x_start) * ssd1306->bits_per_pixel / 8; size_t len = (y_end - y_start) * (x_end - x_start) * ssd1306->bits_per_pixel / 8;
esp_lcd_panel_io_tx_color(io, -1, color_data, len); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_color(io, -1, color_data, len), TAG, "io tx color failed");
return ESP_OK; return ESP_OK;
} }
@@ -199,7 +203,8 @@ static esp_err_t panel_ssd1306_invert_color(esp_lcd_panel_t *panel, bool invert_
} else { } else {
command = SSD1306_CMD_INVERT_OFF; command = SSD1306_CMD_INVERT_OFF;
} }
esp_lcd_panel_io_tx_param(io, command, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG,
"io tx param SSD1306_CMD_INVERT_ON/OFF failed");
return ESP_OK; return ESP_OK;
} }
@@ -214,13 +219,15 @@ static esp_err_t panel_ssd1306_mirror(esp_lcd_panel_t *panel, bool mirror_x, boo
} else { } else {
command = SSD1306_CMD_MIRROR_X_OFF; command = SSD1306_CMD_MIRROR_X_OFF;
} }
esp_lcd_panel_io_tx_param(io, command, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG,
"io tx param SSD1306_CMD_MIRROR_X_ON/OFF failed");
if (mirror_y) { if (mirror_y) {
command = SSD1306_CMD_MIRROR_Y_ON; command = SSD1306_CMD_MIRROR_Y_ON;
} else { } else {
command = SSD1306_CMD_MIRROR_Y_OFF; command = SSD1306_CMD_MIRROR_Y_OFF;
} }
esp_lcd_panel_io_tx_param(io, command, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG,
"io tx param SSD1306_CMD_MIRROR_Y_ON/OFF failed");
return ESP_OK; return ESP_OK;
} }
@@ -250,7 +257,8 @@ static esp_err_t panel_ssd1306_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
} else { } else {
command = SSD1306_CMD_DISP_OFF; command = SSD1306_CMD_DISP_OFF;
} }
esp_lcd_panel_io_tx_param(io, command, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG,
"io tx param SSD1306_CMD_DISP_ON/OFF failed");
// SEG/COM will be ON/OFF after 100ms after sending DISP_ON/OFF command // SEG/COM will be ON/OFF after 100ms after sending DISP_ON/OFF command
vTaskDelay(pdMS_TO_TICKS(100)); vTaskDelay(pdMS_TO_TICKS(100));
return ESP_OK; return ESP_OK;

50
components/esp_lcd/src/esp_lcd_panel_st7789.c
View File

@@ -7,11 +7,13 @@
#include <stdlib.h> #include <stdlib.h>
#include <sys/cdefs.h> #include <sys/cdefs.h>
#include "sdkconfig.h" #include "sdkconfig.h"
#if CONFIG_LCD_ENABLE_DEBUG_LOG #if CONFIG_LCD_ENABLE_DEBUG_LOG
// The local log level must be defined before including esp_log.h // The local log level must be defined before including esp_log.h
// Set the maximum log level for this source file // Set the maximum log level for this source file
#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG #define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
#endif #endif
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "esp_lcd_panel_interface.h" #include "esp_lcd_panel_interface.h"
@@ -28,7 +30,8 @@ static const char *TAG = "lcd_panel.st7789";
static esp_err_t panel_st7789_del(esp_lcd_panel_t *panel); static esp_err_t panel_st7789_del(esp_lcd_panel_t *panel);
static esp_err_t panel_st7789_reset(esp_lcd_panel_t *panel); static esp_err_t panel_st7789_reset(esp_lcd_panel_t *panel);
static esp_err_t panel_st7789_init(esp_lcd_panel_t *panel); static esp_err_t panel_st7789_init(esp_lcd_panel_t *panel);
static esp_err_t panel_st7789_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_st7789_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_st7789_invert_color(esp_lcd_panel_t *panel, bool invert_color_data); static esp_err_t panel_st7789_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
static esp_err_t panel_st7789_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y); static esp_err_t panel_st7789_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
static esp_err_t panel_st7789_swap_xy(esp_lcd_panel_t *panel, bool swap_axes); static esp_err_t panel_st7789_swap_xy(esp_lcd_panel_t *panel, bool swap_axes);
@@ -47,7 +50,9 @@ typedef struct {
uint8_t colmod_cal; // save surrent value of LCD_CMD_COLMOD register uint8_t colmod_cal; // save surrent value of LCD_CMD_COLMOD register
} st7789_panel_t; } st7789_panel_t;
esp_err_t esp_lcd_new_panel_st7789(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel) esp_err_t
esp_lcd_new_panel_st7789(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)
{ {
#if CONFIG_LCD_ENABLE_DEBUG_LOG #if CONFIG_LCD_ENABLE_DEBUG_LOG
esp_log_level_set(TAG, ESP_LOG_DEBUG); esp_log_level_set(TAG, ESP_LOG_DEBUG);
@@ -146,7 +151,8 @@ static esp_err_t panel_st7789_reset(esp_lcd_panel_t *panel)
gpio_set_level(st7789->reset_gpio_num, !st7789->reset_level); gpio_set_level(st7789->reset_gpio_num, !st7789->reset_level);
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} else { // perform software reset } else { // perform software reset
esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0), TAG,
"io tx param LCD_CMD_SWRESET failed");
vTaskDelay(pdMS_TO_TICKS(20)); // spec, wait at least 5m before sending new command vTaskDelay(pdMS_TO_TICKS(20)); // spec, wait at least 5m before sending new command
} }
@@ -158,19 +164,21 @@ static esp_err_t panel_st7789_init(esp_lcd_panel_t *panel)
st7789_panel_t *st7789 = __containerof(panel, st7789_panel_t, base); st7789_panel_t *st7789 = __containerof(panel, st7789_panel_t, base);
esp_lcd_panel_io_handle_t io = st7789->io; esp_lcd_panel_io_handle_t io = st7789->io;
// LCD goes into sleep mode and display will be turned off after power on reset, exit sleep mode first // LCD goes into sleep mode and display will be turned off after power on reset, exit sleep mode first
esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0), TAG,
"io tx param LCD_CMD_SLPOUT failed");
vTaskDelay(pdMS_TO_TICKS(100)); vTaskDelay(pdMS_TO_TICKS(100));
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
st7789->madctl_val, st7789->madctl_val,
}, 1); }, 1), TAG, "io tx param LCD_CMD_MADCTL failed");
esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_COLMOD, (uint8_t[]) {
st7789->colmod_cal, st7789->colmod_cal,
}, 1); }, 1), TAG, "io tx param LCD_CMD_COLMOD failed");
return ESP_OK; return ESP_OK;
} }
static esp_err_t panel_st7789_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_st7789_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end,
const void *color_data)
{ {
st7789_panel_t *st7789 = __containerof(panel, st7789_panel_t, base); st7789_panel_t *st7789 = __containerof(panel, st7789_panel_t, base);
assert((x_start < x_end) && (y_start < y_end) && "start position must be smaller than end position"); assert((x_start < x_end) && (y_start < y_end) && "start position must be smaller than end position");
@@ -182,21 +190,21 @@ static esp_err_t panel_st7789_draw_bitmap(esp_lcd_panel_t *panel, int x_start, i
y_end += st7789->y_gap; y_end += st7789->y_gap;
// define an area of frame memory where MCU can access // define an area of frame memory where MCU can access
esp_lcd_panel_io_tx_param(io, LCD_CMD_CASET, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_CASET, (uint8_t[]) {
(x_start >> 8) & 0xFF, (x_start >> 8) & 0xFF,
x_start & 0xFF, x_start & 0xFF,
((x_end - 1) >> 8) & 0xFF, ((x_end - 1) >> 8) & 0xFF,
(x_end - 1) & 0xFF, (x_end - 1) & 0xFF,
}, 4); }, 4), TAG, "io tx param LCD_CMD_CASET failed");
esp_lcd_panel_io_tx_param(io, LCD_CMD_RASET, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_RASET, (uint8_t[]) {
(y_start >> 8) & 0xFF, (y_start >> 8) & 0xFF,
y_start & 0xFF, y_start & 0xFF,
((y_end - 1) >> 8) & 0xFF, ((y_end - 1) >> 8) & 0xFF,
(y_end - 1) & 0xFF, (y_end - 1) & 0xFF,
}, 4); }, 4), TAG, "io tx param LCD_CMD_RASET failed");
// transfer frame buffer // transfer frame buffer
size_t len = (x_end - x_start) * (y_end - y_start) * st7789->fb_bits_per_pixel / 8; size_t len = (x_end - x_start) * (y_end - y_start) * st7789->fb_bits_per_pixel / 8;
esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, color_data, len); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, color_data, len), TAG, "io tx color failed");
return ESP_OK; return ESP_OK;
} }
@@ -211,7 +219,8 @@ static esp_err_t panel_st7789_invert_color(esp_lcd_panel_t *panel, bool invert_c
} else { } else {
command = LCD_CMD_INVOFF; command = LCD_CMD_INVOFF;
} }
esp_lcd_panel_io_tx_param(io, command, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG,
"io tx param LCD_CMD_INVON/LCD_CMD_INVOFF failed");
return ESP_OK; return ESP_OK;
} }
@@ -229,9 +238,9 @@ static esp_err_t panel_st7789_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool
} else { } else {
st7789->madctl_val &= ~LCD_CMD_MY_BIT; st7789->madctl_val &= ~LCD_CMD_MY_BIT;
} }
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
st7789->madctl_val st7789->madctl_val
}, 1); }, 1), TAG, "io tx param LCD_CMD_MADCTL failed");
return ESP_OK; return ESP_OK;
} }
@@ -244,9 +253,9 @@ static esp_err_t panel_st7789_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
} else { } else {
st7789->madctl_val &= ~LCD_CMD_MV_BIT; st7789->madctl_val &= ~LCD_CMD_MV_BIT;
} }
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) { ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, (uint8_t[]) {
st7789->madctl_val st7789->madctl_val
}, 1); }, 1), TAG, "io tx param LCD_CMD_MADCTL failed");
return ESP_OK; return ESP_OK;
} }
@@ -268,6 +277,7 @@ static esp_err_t panel_st7789_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
} else { } else {
command = LCD_CMD_DISPOFF; command = LCD_CMD_DISPOFF;
} }
esp_lcd_panel_io_tx_param(io, command, NULL, 0); ESP_RETURN_ON_ERROR(esp_lcd_panel_io_tx_param(io, command, NULL, 0), TAG,
"io tx param LCD_CMD_DISPON/LCD_CMD_DISPOFF failed");
return ESP_OK; return ESP_OK;
} }

4
components/esp_lcd/test_apps/i2c_lcd/pytest_i2c_lcd.py
View File

@@ -5,8 +5,8 @@ import pytest
from pytest_embedded import Dut from pytest_embedded import Dut
@pytest.mark.supported_targets @pytest.mark.esp32c3
@pytest.mark.generic @pytest.mark.i2c_oled
@pytest.mark.parametrize( @pytest.mark.parametrize(
'config', 'config',
[ [

1
conftest.py
View File

@@ -127,6 +127,7 @@ ENV_MARKERS = {
'ccs811': 'Runner with CCS811 connected', 'ccs811': 'Runner with CCS811 connected',
'ethernet_w5500': 'SPI Ethernet module with two W5500', 'ethernet_w5500': 'SPI Ethernet module with two W5500',
'nvs_encr_hmac': 'Runner with test HMAC key programmed in efuse', 'nvs_encr_hmac': 'Runner with test HMAC key programmed in efuse',
'i2c_oled': 'Runner with ssd1306 I2C oled connected',
# multi-dut markers # multi-dut markers
'ieee802154': 'ieee802154 related tests should run on ieee802154 runners.', 'ieee802154': 'ieee802154 related tests should run on ieee802154 runners.',
'openthread_br': 'tests should be used for openthread border router.', 'openthread_br': 'tests should be used for openthread border router.',