Prefacio
Tocando durante varios días, había demasiados hoyos, pero afortunadamente, finalmente volé. Por cierto, el controlador de pantalla también está escrito; déjame decirte de antemano que mi hardware es una pantalla de controlador ILI9341 de 2.4 pulgadas + táctil resistiva XPT2046. El chip táctil y la pantalla comparten los datos SPI y los pines de reloj, solo el CS pin es diferente.
1. Los pozos encontrados
1. La biblioteca TFT_eSPI no es solo un controlador de pantalla, sino también un controlador táctil. Puede abrir y probar el ejemplo TFT_eSPI / examples / Generic / Touch_calibrate / Touch_calibrate.ino para ver si puede implementar con éxito el toque. Si se puede implementar, no se necesita ningún controlador de terceros, lo que evita el problema de la adaptación de la API.
2. LVGL admite múltiples plataformas y el archivo ino está especialmente escrito para la plataforma Arduino. El archivo oficial LVGL_Arduino.ino ya tiene declaraciones de configuración de dispositivo de entrada (indev). Si tiene archivos lv_port_indev_template.cy lv_port_indev_template.h, son inútiles, al menos no para Arduino.
3. Hay un error en el archivo oficial LVGL_Arduino.ino y no hay una declaración de tiempo, lo que hará que LVGL no responda al tacto. Además, la falta de biblioteca SPI hace que el controlador no pueda comunicarse con el chip táctil en la parte inferior.
2. Configuración del controlador de pantalla
1. Selección de perfil de usuario
Abra TFT_eSPI / User_Setup_Select.hy busque:
#include <User_Setup.h> // Default setup is root library folder
Y borre el símbolo de comentario delante de él. Este se usa para seleccionar el archivo de configuración del controlador. TFT_eSPI tiene muchos archivos de configuración predeterminados. Aquí elegimos User_Setup para configurar la pantalla por nosotros mismos. A continuación, abra User_Setup.h.
En este archivo, debe seleccionar el controlador de pantalla, definir los pines y configurar la velocidad SPI. Algunos controladores de pantalla también tendrán sus propios elementos de configuración patentados. Preste atención a las notas o utilice el editor para buscar el modelo de su propio controlador de pantalla.
Si está utilizando ESP32, vaya al final del archivo para encontrar
// The ESP32 has 2 free SPI ports i.e. VSPI and HSPI, the VSPI is the default.
// If the VSPI port is in use and pins are not accessible (e.g. TTGO T-Beam)
// then uncomment the following line:
//#define USE_HSPI_PORT
Y elimine el símbolo de comentario antes de #define USE_HSPI_PORT, esta oración se usa para resolver el problema de la ocupación de SPI de hardware
La habilitación del pin CS mencionado en la guía de pasos 01 también se realiza aquí, por ejemplo:
// The hardware SPI can be mapped to any pins
#define TFT_MISO 19
#define TFT_MOSI 23
#define TFT_SCLK 18
#define TFT_CS 15 // Chip select control pin
#define TFT_DC 2 // Data Command control pin
#define TFT_RST 4 // Reset pin (could connect to RST pin)
//#define TFT_RST -1 // Set TFT_RST to -1 if display RESET is connected to ESP32 board RST
#define TOUCH_CS 12 // Chip select pin (T_CS) of touch screen
Debe haber #define TOUCH_CS, porque hay una definición de condición en el archivo.Si el pin CS no está definido, el módulo relacionado con el tacto no se compilará, causando un error en la parte táctil del archivo ino. Así que #define TOUCH_CS o elimine todos los códigos táctiles.
Tres, configuración de unidad táctil
LVGL admite una variedad de dispositivos de entrada, incluidos mouse, teclado, codificador, etc. Aquí presentamos el método de configuración de la pantalla táctil (Touchpad).
1. Carga de la biblioteca de parches
Abra LVGL_Arduino.ino y agregue una oración a un grupo de incluir:
#include <SPI.h>
Después de agregar, debe haber un total de cuatro incluir, de la siguiente manera:
#include <lv_examples.h>
#include <lvgl.h>
#include <TFT_eSPI.h>
#include <SPI.h>
2. Corrija el error
Encontramos la función loop () con solo dos líneas en la parte inferior; agregue una línea de código, y después de completar, es como sigue:
void loop()
{
lv_task_handler(); /* let the GUI do its work */
lv_tick_inc(5);
delay(5);
}
lv_tick_inc (5) le dice a LVGL que han pasado 5 milisegundos. Sin esta oración, LVGL perderá su reloj y, por lo tanto, no podrá responder.
Está hecho, solo dos pasos, simple.
Tres, un breve análisis de archivos ino
Finalmente, echemos un vistazo al archivo ino oficial. Observe principalmente cómo están conectados LittleVGL y TFT_eSPI. Primero, en la parte superior del archivo, cree una instancia de objeto llamada tft para la clase TFT_eSPI:
TFT_eSPI tft = TFT_eSPI(); /* TFT instance */
1. Mostrar parte
void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)
{
uint32_t w = (area->x2 - area->x1 + 1);
uint32_t h = (area->y2 - area->y1 + 1);
tft.startWrite();
tft.setAddrWindow(area->x1, area->y1, w, h);
tft.pushColors(&color_p->full, w * h, true);
tft.endWrite();
lv_disp_flush_ready(disp);
}
lv_disp_buf_init(&disp_buf, buf, NULL, LV_HOR_RES_MAX * 10);
/*Initialize the display*/
lv_disp_drv_t disp_drv;
lv_disp_drv_init(&disp_drv);
disp_drv.hor_res = 320;
disp_drv.ver_res = 240;
disp_drv.flush_cb = my_disp_flush;
disp_drv.buffer = &disp_buf;
lv_disp_drv_register(&disp_drv);
La primera mitad es la función de actualización de pantalla que debe escribir usted mismo, porque TFT_eSPI es un controlador oficial elegido a mano, por lo que está escrito oficialmente aquí. La segunda mitad es la definición del dispositivo de salida de visualización de LVGL. A LVGL no le importa cuál es la pantalla. Una vez definido el dispositivo de visualización, dará la información de píxeles de cada cuadro a la función de procesamiento especificada por el dispositivo, a saber, my_disp_flush; my_disp_flush es el método definido por TFT_eSPI para mostrar información de píxeles en la pantalla.
2. Toque la pieza
Los dispositivos de entrada y salida son los mismos para LVGL, ambos son dispositivos, por lo que el código es similar a la parte de la pantalla
bool my_touchpad_read(lv_indev_drv_t * indev_driver, lv_indev_data_t * data)
{
uint16_t touchX, touchY;
bool touched = tft.getTouch(&touchX, &touchY, 600);
if(!touched) {
data->state = LV_INDEV_STATE_REL;
} else {
data->state = LV_INDEV_STATE_PR;
/*Set the coordinates*/
data->point.x = touchX;
data->point.y = touchY;
Serial.print("Data x");
Serial.println(touchX);
Serial.print("Data y");
Serial.println(touchY);
}
return false; /*Return `false` because we are not buffering and no more data to read*/
}
/*SETUP函数里散落了一些触摸屏初始化和校准语句*/
tft.begin(); /* TFT init */
tft.setRotation(1); /* Landscape orientation */
uint16_t calData[5] = {
275, 3620, 264, 3532, 1 };
tft.setTouch(calData);
/*Initialize the (dummy) input device driver*/
lv_indev_drv_t indev_drv;
lv_indev_drv_init(&indev_drv);
indev_drv.type = LV_INDEV_TYPE_POINTER;
indev_drv.read_cb = my_touchpad_read;
lv_indev_drv_register(&indev_drv);
En la parte inferior está la definición del dispositivo de entrada. Dígale a LVGL que hay un dispositivo táctil Touchpad. LVGL ejecutará my_touchpad_read con regularidad. El tiempo se establece en lv_conf, y el valor predeterminado es 30ms. my_touchpad_read es la función de procesamiento para informar el estado táctil y la última coordenada.