Proyectos de pantalla táctil de Arduino

A continuación, deberá conectar el cable USB de su placa a su computadora e instalar todas las bibliotecas necesarias para que la pantalla táctil funcione con su placa Arduino. Afortunadamente, estas bibliotecas son generalmente fáciles de instalar y configurar. Encuentre la biblioteca Adafruit ILI9341 necesaria y la biblioteca Adafruit_GFX.

Una vez que haya instalado todo, pruebe su pantalla para asegurarse de que todo esté conectado correctamente. Si todo se ve bien, está listo para continuar con la configuración de la pantalla táctil. Para esto, la pantalla deberá interpretar la entrada táctil y mostrar la reacción correspondiente en su pantalla. Esto se puede configurar con la biblioteca Adafruit_GFX.

Finalmente, es hora de escribir el programa para su proyecto de pantalla táctil Arduino. Según su proyecto, puede ser un boceto simple o un conjunto complejo de instrucciones que permite a los usuarios interactuar con la pantalla táctil de varias maneras.

Ahora es el momento de codificar el boceto. En el siguiente código configuraremos todo para que la pantalla muestre ‘¡Hola!’ cada vez que el usuario toca la pantalla.

#incluir «SPI.h»
#incluir
#incluir «Pantalla táctil.h»
#incluye “Adafruit_GFX.h”
#incluye “Adafruit_ILI9341.h”
#incluye “Adafruit_STMPE610.h”

#define YP A2 // debe ser un pin analógico
#define XM A3 // debe ser un pin analógico
#define YM 8 // puede ser un pin digital
#define XP 9 // puede ser un pin digital
#define PRESSURE_THRESHOLD 10

// API de la biblioteca de gráficos: https://learn.adafruit.com/adafruit-gfx-graphics-library/graphics-primitives

Adafruit_ILI9341 tft = Adafruit_ILI9341(10, 9);
Pantalla táctil ts = Pantalla táctil (XP, YP, XM, YM, 300); // 300 = resistencia entre pines X+ y X-

colores int[3] = {ILI9341_CIAN OSCURO, ILI9341_NARANJA, ILI9341_OLIVA};
int font_colors[3] = {ILI9341_BLANCO, ILI9341_NEGRO, ILI9341_BLANCO};
int colores_activos = 0;

b1 sin firmar[4] = {15, 175, 135, 50};
b2 sin firmar[4] = {170, 175, 135, 50};

bool screenRedrawNecessary = false;

// Prototipos de funciones
configuración vacía ();
bucle vacío (vacío);
bool tocadoDentro(TSPoint touch, x sin signo, y sin signo, w sin signo, h sin signo);
reinicio vacío y pantalla clara (vacío);
void dibujarIntroTexto(void);
void drawTouchButton(x sin firmar, y sin firmar, ancho sin firmar, altura sin firmar, Texto de cadena);

configuración vacía ()
{
Serial.begin(9600);
tft.begin();
screenRedrawNecessary = verdadero;
}

bucle vacío ()
{
// Determinar si el usuario tocó la pantalla
TSPoint p = ts.getPoint();

if (pz > PRESSURE_THRESHOLD && !screenRedrawNecessary)
{
// NOTA: El controlador de pantalla táctil NO usa el
// coordenadas de pantalla! Utiliza su propio sistema de coordenadas.

si(tocadodentro(p, 165, 100, 320, 450))
{
colores_activos -= 1;
screenRedrawNecessary = verdadero;
}
else if(tocadoDentro(p, 175, 500, 330, 830))
{
colores_activos += 1;
screenRedrawNecessary = verdadero;
}

if(colores_activos < 0) colores_activos = 2; si (colores_activos >= 3)
colores_activos = 0;
}

si (pantalla RedrawNecessary)
{
resetAndClearScreen();
dibujarIntroTexto();
Dibujar Botón Táctil (b1[0]b1[1]b1[2]b1[3]»Anterior»);
Dibujar botón táctil (b2[0]b2[1]b2[2]b2[3]»Próximo»);

screenRedrawNecessary = falso;
}
}

bool tocadoDentro(TSPoint touch, x sin signo, y sin signo, w sin signo, h sin signo)
{
return (tocar.x > x) && (tocar.x < (w)) && (tocar.y > y) && (tocar.y < (h));
}

reinicio vacío y pantalla clara (vacío)
{
tft.setRotation(1);
tft.fillScreen(colores[active_colors]);
producir();
}

void dibujarIntroTexto(void)
{
tft.setCursor(15, 15);
tft.setTextColor(font_colors[active_colors]);
tft.establecerTamañoTexto(2);
tft.println(“¡Hola!”);

tft.setCursor(15, 55);
tft.println(“Use los botones de abajo”);
tft.setCursor(15, 75);
tft.println(“para cambiar el fondo”);
tft.setCursor(15, 95);
tft.println(“¡color!”);
}

void drawTouchButton (x sin firmar, y sin firmar, ancho sin firmar, altura sin firmar, texto de cadena)
{
int x_text_pos = x + ancho / 2 – (texto.longitud() / 2) * 11;
int y_text_pos = y + altura / 2 – 8;

tft.drawRect(x, y, ancho, alto, font_colors[active_colors]);
tft.establecerTamañoTexto(2);
tft.setTextColor(font_colors[active_colors]);
tft.setCursor(x_text_pos, y_text_pos);
tft.imprimir(texto);
}

Este es solo el proyecto muy básico para poner en funcionamiento su pantalla táctil Arduino. Una vez que haya escrito el código, es hora de agregar algunas características más para hacer que su proyecto sea un poco más interesante. Analicemos algunas de las posibilidades.

Dibujar>

Además de enviar texto a la pantalla, es posible dibujar formas y figuras básicas con algunas funciones de biblioteca disponibles en diferentes bibliotecas TFT.

Por ejemplo, las funciones drawCircle() y drawEllipse() permiten a los usuarios dibujar un círculo (o una elipse) y también agregar parámetros para iniciar las coordenadas x/y, el radio, el color y el grosor de la línea.

Puedes experimentar con estos todo lo que quieras antes de pasar a formas más complejas.

Juego de tres en raya táctil basado en Arduino

Uno de los proyectos de pantalla táctil basados ​​en Arduino más interesantes es hacer un juego de tres en raya. Aunque este no es el proyecto más fácil de hacer, es bastante divertido y gratificante cuando está terminado. Para crear este proyecto, utilizamos un Arduino UNO y una pantalla táctil.

Este sistema es para un solo jugador, pero es interactivo porque tiene una pantalla táctil. Esto significa que los jugadores pueden participar en juegos y recibir mensajes que les indiquen si han ganado o perdido. Si los jugadores necesitan tomar un descanso durante el juego, pueden simplemente tocar la pantalla para pausar el juego y luego volver a tocar para reanudar el juego.

Proyecto>

Si está buscando crear un proyecto de pantalla táctil Arduino que use un gran tablero de ajedrez, Arduino Mega es la mejor plataforma para ello. El Arduino Mega tiene muchos pines de E/S y memoria para manejar todos los datos necesarios para un juego de ajedrez

Materiales necesitados:

• placa arduino mega 2560
• Pantalla táctil LCD de 5″ con toque resistivo
• Zumbador
• Algoritmo de software Negamax

Se supone que es su juego de ajedrez promedio, en este proyecto, sin embargo, reemplaza un tablero de ajedrez tradicional con un zumbador que suena cada vez que ocurren controles en el juego.

¡Y eso es todo lo que necesita saber sobre la conexión de pantallas LCD TFT táctiles a su placa Arduino! Con ese conocimiento y algo de creatividad, las posibilidades son infinitas cuando se trata de proyectos de pantalla táctil de Arduino. ¡Buena suerte! [2], [3], [4], [5]

Preguntas>

¿TFT es una pantalla táctil?

Sí, TFT son las siglas de Thin-Film Transistor y es un tipo de tecnología de pantalla táctil. La forma en que esto funciona es que cada píxel en la pantalla tiene su propio electrodo conectado a un transistor de película delgada (TFT). Cuando hay una conexión eléctrica entre el electrodo y el transistor, provoca un cambio de voltaje que luego puede ser detectado por el controlador. Esto permite acciones táctiles precisas como deslizar y tocar con gran precisión.

¿Qué es TFT en la pantalla táctil?

Es un componente electrónico hecho de finas capas de óxido de metal que forman transistores que controlan el flujo de corriente eléctrica entre dos terminales o puntos en la pantalla. Las pantallas TFT se utilizan para crear imágenes de alta resolución controlando cada píxel individualmente, lo que permite obtener gráficos más detallados que otros tipos de pantallas. La pantalla táctil contiene una matriz de sensores superpuesta en la parte superior del panel TFT que detecta cuando un dedo u otro objeto la toca y envía esta información al procesador Arduino.

¿Cómo usar una pantalla LCD TFT con un Arduino?

Usar una pantalla LCD TFT con un Arduino es bastante simple. Todo lo que necesita hacer es asegurarse de que el Arduino tenga instalado el software correcto y luego conectar la pantalla LCD a los pines apropiados en el Arduino.

Primero, deberá instalar una biblioteca para interactuar con las pantallas LCD TFT, como las bibliotecas GFX o U8Glib de Adafruit. Después de instalar esta biblioteca, puede usarla para escribir código para su proyecto. Luego, simplemente conecte su TFT LCD a los pines correctos de su placa Arduino de acuerdo con su hoja de datos.

Por ejemplo, si utiliza una pantalla TFT LCD basada en SPI como la pantalla ILI9341 de 2,4″ de Adafruit, deberá conectarla a los pines SPI (MISO, MOSI, SCK) y a los pines CS y D/C de su placa Arduino. Luego, puede usar las funciones de biblioteca incorporadas para enviar comandos a la pantalla LCD, dibujar píxeles, imprimir texto o incluso mostrar imágenes.

¿Puede un Arduino ejecutar una pantalla LCD?

Sí, Arduino puede ejecutar pantallas LCD con la ayuda de una biblioteca llamada LiquidCrystal. Esta biblioteca permite la salida de texto simple en pantallas LCD y viene preinstalada con el IDE de Arduino. Al usar esta biblioteca, puede enviar caracteres e incluso cadenas completas para que se muestren en su pantalla LCD. Con solo unas pocas líneas de código, puede hacer que su Arduino controle una pantalla LCD, lo que la convierte en una excelente herramienta para todo tipo de proyectos.

¿Qué es una pantalla táctil capacitiva TFT?

Esta tecnología detecta ligeros cambios en la corriente eléctrica cuando el dedo del usuario u otro objeto conductor toca la pantalla. Se utiliza una pantalla de cristal líquido (LCD) TFT (Thin-Film Transistor) para crear una imagen en la pantalla, lo que facilita que los usuarios interactúen con el dispositivo. Todo el proceso se inicia con cargas eléctricas generadas por su dedo cuando entra en contacto con la superficie de la pantalla táctil.

En comparación con las pantallas táctiles resistivas tradicionales, este tipo de pantalla táctil tiene una capacidad de respuesta y una durabilidad más precisas, lo que permite a los usuarios obtener interacciones más fluidas desde sus dispositivos con una recopilación de datos de entrada más precisa. Además, la tecnología de pantalla táctil capacitiva TFT es más resistente al polvo, el agua y otros factores ambientales que las pantallas táctiles resistivas. Esto lo convierte en la elección perfecta para aplicaciones en entornos industriales o al aire libre donde se requiere una mayor durabilidad.

Video útil: Cómo crear una GUI de pantalla táctil simple || Arduino LCD y tutorial de pantalla táctil

Conclusión

Arduino es una de las plataformas más versátiles que existen y sus capacidades, cuando se combinan con una pantalla táctil, abren una gama completamente nueva de posibilidades. Desde mostrar información hasta controlar funciones complejas, los proyectos de pantalla táctil de Arduino le brindan el poder de crear cosas increíbles.

En este artículo, hemos cubierto todo, desde los conceptos básicos de los proyectos de pantalla táctil hasta temas más avanzados. También proporcionamos consejos y trucos útiles para crear proyectos exitosos de pantalla táctil Arduino utilizando la pantalla TFT.

No importa en qué tipo de proyecto esté trabajando, asegúrese de investigar de antemano y probar diferentes componentes para determinar cuáles se adaptan mejor a sus necesidades. ¡Con un poco de paciencia, creatividad y conocimiento de la programación de Arduino, puede crear increíbles proyectos de pantalla táctil de Arduino en muy poco tiempo! ¡Buena suerte!

Referencias

1. https://learn.sparkfun.com/tutorials/what-is-an-arduino/all
2. https://www.digikey.com/en/maker/blogs/2022/how-to-use-a-touchscreen-with-an-arduino
3. https://www.instructables.com/Arduino-Touch-Screen-TFT-LCD-Tutorial-First-Review/
4. https://www.watelectronics.com/arduino-projects/
5. https://www.hackster.io/electropeak/ultimate-beginner-s-guide-to-run-tft-lcd-displays-by-arduino-081006#toc-drawing-circles-12