Cómo utilizar el controlador de pantalla táctil TFT LCD ILI9486 de 3,5 ″ con Arduino

En este proyecto, diseñaremos una aplicación sencilla utilizando una pantalla LCD TFT de 3,5 pulgadas que muestra diferentes tipos de gráficos y mensajes de texto con Arduino.

Las pantallas LCD TFT son las pantallas en color más populares; las pantallas de los teléfonos inteligentes, tabletas y portátiles son en realidad solo pantallas LCD TFT. Hay escudos TFT LCD disponibles para Arduino en una variedad de tamaños, como 1,44″, 1,8″, 2,0″, 2,4″ y 2,8″. Arduino es una máquina bastante humilde cuando se trata de procesar o controlar gráficos. Después de todo, es una plataforma de microcontrolador y las aplicaciones gráficas generalmente requieren recursos de procesamiento mucho mayores. Aún así, Arduino es lo suficientemente capaz de controlar unidades de visualización pequeñas. Las pantallas LCD TFT son pantallas a todo color que pueden albergar hermosas interfaces de usuario.

La mayoría de los escudos TFT LCD más pequeños se pueden controlar utilizando la biblioteca TFT LCD de Adafruit. También hay una pantalla LCD TFT más grande de 3,5 pulgadas, con un controlador ILI9486 de 8 bits.

La biblioteca Adafruit no es compatible con el controlador ILI9486. De hecho, la biblioteca Adafruit está escrita para controlar únicamente pantallas TFT de menos de 3,5 pulgadas. Para controlar la pantalla táctil TFT LCD de 3,5 pulgadas, necesitamos otra biblioteca. Este es MCUFRIEND_kbv. La biblioteca MCUFRIEND_kbv es, de hecho, incluso más fácil de usar en comparación con la biblioteca Adafruit TFT LCD. Esta biblioteca solo requiere la creación de instancias de un objeto TFT y ni siquiera requiere que se especifiquen conexiones de pines.

La pantalla táctil TFT LCD de 3,5 pulgadas es casi del tamaño del Arduino UNO, y encima de la placa Arduino, el escudo luce realmente glamoroso.

La pantalla LCD TFT de 3,5 pulgadas se puede utilizar para diversas aplicaciones como:

1. Para mostrar texto y fuentes.
2. Mostrar gráficos y figuras interactivas.
3. Para mostrar imágenes de mapa de bits.
4. Para mostrar fotografías e imágenes en color RGB.
5. Para usar como pantalla táctil.
6. Para alojar interfaces gráficas con entrada táctil.
7. Para acceder a firmas digitales.
8. Para alojar videojuegos con entrada táctil.
9. Para alojar aplicaciones de entrada táctil como Paint y Calculator.

¿Qué necesitas?

1. Arduino UNO/Mega2560/Leonardo/Due/Zero/MO-Pro x1
2. Carcasa de pantalla táctil TFT LCD de 3,5 pulgadas

LCD TFT para Arduino
Las interfaces de usuario son una parte esencial de cualquier aplicación integrada. La interfaz de usuario permite cualquier interacción con el usuario final y hace posible el uso final del dispositivo. Las interfaces de usuario se alojan mediante una serie de dispositivos, como pantallas LCD de caracteres de siete segmentos, pantallas LCD gráficas y pantallas LCD TFT en color. De todos estos dispositivos, sólo las pantallas TFT en color son capaces de albergar interfaces sofisticadas. Una interfaz de usuario sofisticada puede tener muchos campos de datos para mostrar, o puede necesitar albergar menús y submenús o albergar gráficos interactivos. Una pantalla LCD TFT es una pantalla LCD de matriz activa capaz de albergar imágenes de alta calidad.

Arduino opera a baja frecuencia. Por eso no es posible renderizar imágenes o vídeos de alta definición con Arduino. Sin embargo, Arduino puede controlar una pequeña pantalla TFT que muestra datos y comandos enriquecidos gráficamente. Al conectar una pantalla táctil TFT LCD con Arduino, puede generar gráficos, menús, tablas, gráficos y paneles de usuario interactivos.

Algunas de las pantallas LCD TFT en color más populares disponibles para Arduino incluyen una pantalla de 3,5 ″ 480 × 320, una pantalla de 2,8 ″ 400 × 200, una pantalla de 2,4 ″ 320 × 240 y una pantalla de 1,8 ″ 220 × 176. Se puede utilizar una pantalla TFT de tamaño y resolución adecuados. seleccionado según una determinada aplicación.

Si la interfaz de usuario solo tiene datos gráficos y comandos, las placas Arduino Atmega328 pueden controlar la pantalla. Si la interfaz de usuario es un programa grande que alberga múltiples menús y/o submenús, se debe preferir el Arduino Mega2560 para controlar la pantalla TFT. Si la interfaz de usuario necesita albergar imágenes y movimiento de alta resolución, se deben usar placas centrales Arduino ARM como DUE para controlar la pantalla TFT.

Biblioteca MCUFRIEND_kbv
La biblioteca Adafruit TFT LCD solo admite pantallas TFT pequeñas. Para pantallas TFT grandes, como las LCD TFT de 3,5, 3,6 y 3,95 pulgadas, incluidas las LCD TFT de 2,4 y 2,8 pulgadas, la biblioteca MCUFRIEND_kbv es útil. Esta biblioteca está diseñada para controlar escudos LCD TFT de 28 pines para Arduino UNO. También funciona con Arduino Mega2560. Además de UNO y Mega2560, la biblioteca también es compatible con LEONARDO, DUE, ZERO y M0-PRO. También funciona en NUCLEO-F103 y TEENSY3.2 con adaptador Sparkfun. Los escudos estilo Mcufriend tienden a tener una pantalla táctil resistiva en A1, 7, A2, 6, pero no siempre están en la misma dirección de rotación. La biblioteca MCUFRIEND_kbv se puede incluir en un boceto de Arduino en el administrador de biblioteca.

El boceto también necesitará la biblioteca Adafruit_GFX para dibujar texto y gráficos en la pantalla TFT.

Conexiones de circuito

El protector LCD TFT de 3,5 pulgadas debe conectarse a la placa Arduino. Los escudos estilo Mcufriend están diseñados para adaptarse a todas las placas Arduino mencionadas anteriormente. Los escudos tienen una pantalla táctil TFT que puede mostrar imágenes e interfaces a todo color, y un lector de tarjetas micro SD para guardar imágenes y otros datos. Una pantalla táctil TFT LCD de 3,5 pulgadas tiene el siguiente diagrama de pines.

guía de programación

En el boceto de Arduino, esencialmente se deben incluir las siguientes bibliotecas.
#incluir “Adafruit_GFX.h”#incluir “MCUFRIEND_kbv.h”

Se pueden incluir las siguientes bibliotecas según los requisitos de su aplicación.
#include “TouchScreen.h” // solo cuando quieras usar la pantalla táctil
#include “bitmap_mono.h” // cuando desee mostrar una imagen de mapa de bits de la biblioteca
#include “bitmap_RGB.h” // cuando desee mostrar una imagen de mapa de bits de la biblioteca
#include “Fonts/FreeSans9pt7b.h” // cuando quieras otras fuentes
#incluye “Fonts/FreeSans12pt7b.h” // cuando quieras otras fuentes
#incluye “Fonts/FreeSerif12pt7b.h” // cuando quieras otras fuentes
#incluye “FreeDefaultFonts.h” // cuando quieras otras fuentes
#include “SPI.h” // usando tarjeta sd para mostrar imagen de mapa de bits
#incluir “SD.h”

En primer lugar, es necesario crear una instancia de un objeto de clase MCUFRIEND_kbv para proporcionar comunicación SPI entre LCD y Arduino.
MCUFRIEND_kbv tft;

Para iniciar la pantalla LCD TFT, es necesario leer su ID y proporcionarla al método Begin.
uint16_t ID = tft.readID;
tft.begin(ID);

La resolución de la pantalla TFT se puede determinar utilizando el siguiente código.
ancho_pantalla = tft.ancho; //int16_t ancho(vacío);
Serial.print(“Ancho de pantalla TFT LCD: “);
Serial.println(ancho_pantalla); altura_pantalla = tft. altura ; //int16_t altura(vacío);
Serial.print(“Altura de la pantalla TFT LCD: “);
Serial.println(altura_pantalla);

El color de la pantalla se puede configurar mediante el siguiente método.
tft.fillScreen

Este método puede tomar cualquiera de los siguientes argumentos.
#definir NEGRO 0x0000
#definir MARINO 0x000F
#definir VERDE OSCURO 0x03E0

#define CIAN OSCURO 0x03EF
#definir MARRÓN 0x7800
#definir PÚRPURA 0x780F
#definir OLIVEIRA 0x7BE0
#definir GRIS CLARO 0xC618
#define GRIS OSCURO 0x7BEF
#definir AZUL 0x001F
#definir VERDE 0x07E0
#definir CIAN 0x07FF
#definir ROJO 0xF800
#definir MAGENTA 0xF81F
#definir AMARILLO 0xFFE0
#definir BLANCO 0xFFFF
#definir NARANJA 0xFD20
#definir VERDE AMARILLO 0xAFE5
#definir ROSA 0xF81F

El siguiente método se utiliza para configurar la posición del cursor en la pantalla LCD TFT.
tft.setCursor(x,y); //setCursor(int16_t x, int16_t y)

Los siguientes métodos se utilizan para configurar el color del texto.
tft.setTextColor
tft.setTextColor(t,b); //setTextColor(uint16_t t, uint16_t b)

El siguiente método se utiliza para establecer el tamaño del texto.
tft.setTextSize(s); //setTextSize(uint8_t s)

Los siguientes métodos se utilizan para mostrar texto en una pantalla LCD TFT.
tft.write(c); //escribir(uint8_t c)
tft.println(“www.Electropeak.com”);
tft.print(“www.Electropeak.com”);

La función drawPixel rellena un píxel en la ubicación xey con el color t. La función readPixel lee el color de un píxel en las ubicaciones xey.
tft.drawPixel(x,y,t); //drawPixel(int16_t x, int16_t y, uint16_t t)
tft.readPixel(x,y); //uint16_t readPixel(int16_t x, int16_t y)

La función drawFastVLine dibuja una línea vertical que comienza en la ubicación x, y, su longitud es h píxel y su color es t. La función drawFastHLine dibuja una línea horizontal que comienza en la ubicación xey, y la longitud es w píxeles y el color es t. La función drawLine dibuja una línea que comienza en xi e yi, la ubicación termina en xj e yj y el color es t. Estos métodos dibujan líneas de 5 píxeles de grosor.
tft.desenharVLineFast(x,y,h,t);
//drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t t)tft.drawFastHLine(x,y,w,t);
//drawLineFastHLine(int16_t x, int16_t y, int16_t w, uint16_t t)tft.drawLine(xi,yi,xj,yj,t);
//drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t t)

La función fillRect dibuja un rectángulo relleno en las ubicaciones xey. w es el ancho, h es el alto y t es el color del rectángulo. La función drawRect dibuja un rectángulo en las ubicaciones xey con ancho w, alto h y color t. La función fillRoundRect dibuja un rectángulo relleno con radios r esquinas redondeadas en la ubicación xey, ancho w, alto h y color t. La función drawRoundRect dibuja un rectángulo con radio r y esquinas redondeadas en la ubicación xey, ancho w, alto h y color t.
tft.fillRect(x,y,w,h,t);
//fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t t)tft.drawRect(x,y,w,h,t);
//drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t t)tft.fillRoundRect(x,y,w,h,r,t);
//fillRoundRect (int16_t x, int16_t y, int16_t w, int16_t h, uint8_t R, uint16_t t)tft.drawRoundRect(x,y,w,h,r,t);
//drawRoundRectangle(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t R, uint16_t t)

La función drawCircle dibuja un círculo en la ubicación xey y con radio y color r. La función fillCircle dibuja un círculo relleno en la ubicación xey y el radio y color r.
tft.drawCircle(x,y,r,t);
//drawCircle(int16_t x, int16_t y, int16_t r, uint16_t t)tft.fillCircle(x,y,r,t);
//rellenarCírculo(int16_t x, int16_t y, int16_t r, uint16_t t)

La función drawTriangle dibuja un triángulo con tres ubicaciones de esquinas x, y, z y colores t. La función fillTriangle dibuja un triángulo relleno con tres ubicaciones de esquina con colores x, y, z y t.
tft.drawTriangle(x1,y1,x2,y2,x3,y3,t);
//drawTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, // uint16_t t)tft.fillTriangle(x1,y1,x2,y2,x3,y3,t);
//fillTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, // uint16_t t)

La siguiente función gira la pantalla en un ángulo determinado.
tft.setRotation(r); //definirRotación(uint8_t r)

La siguiente función invierte los colores de la pantalla.
tft.invertDisplay(i); //invertDisplay(booleano i)

La siguiente función proporciona el código RGB y obtiene el código de color UTFT.
tft.color565(r,g,b); //uint16_t cor565(uint8_t r, uint8_t g, uint8_t b)

La siguiente función desplaza la pantalla. Maxroll es la altura máxima de su rollo.
para (uint16_t i = 0; i < maxscroll; i++) {
tft.vertScroll(0, maxscroll, i);
retraso(10);}

La siguiente función restablece la pantalla.
tft.restablecer;

Bosquejo de Arduino

Cómo funciona el proyecto
El código llena un rectángulo y luego dibuja un rectángulo dentro del cual se muestra el texto "EEWORLDONLINE". Luego se dibujan líneas, círculos, rectángulos y cuadrados en la pantalla. El proyecto finaliza con un saludo y un mensaje.

Resultados