Animación LCD y juegos

Acerca de este proyecto

Este proyecto se centra en los conceptos básicos de la animación utilizando arduino y una pantalla lcd de 16 por 2. Sin embargo, este proyecto también se puede extender a pantallas de LCD de otras dimensiones.

Primero comenzaremos con el cableado del lcd al arduino, luego con la simple impresión de un mensaje al lcd. Luego pasaremos a la animación.

Cableado LCD

Este es el circuito que se muestra esquemáticamente arriba.

PIN de LCD

1:VSS:al riel positivo de la placa de pruebas (conecte 5v de arduino al riel positivo también)

2:VDD:al riel negativo de la placa de pruebas (adjunte GND de arduino aquí también)

3:VO (contraste):al limpiaparabrisas del potenciómetro (coloque los terminales laterales del potenciómetro en los rieles positivo y negativo)

4:RS (selección de registro):al pin 12 de Arduino

5:R / W (lectura-escritura):a carril negativo

6:E (habilitar):al pin 11 de Arduino

15:A (ánodo):a riel positivo con resistencia de 220 ohmios

16:K (cátodo):a carril negativo

No adjuntaremos PIN de datos en este momento.

Encienda la energía y si la fila inferior se ilumina, su pantalla lcd está funcionando. Debe probar esto antes de comenzar a hacer cualquier otra cosa.

Si el lcd no se enciende, verifique su soldadura, cableado (vuelva a verificar) y si aún no se enciende, es muy probable que su lcd esté dañado, por lo que debe reemplazarlo.

Si su pantalla lcd funciona, ¡Bravo! ha terminado la primera parte de este tutorial.

Después de esto, conecte los pines de datos:

11:D4 (pin de datos 4):al pin 4 de Arduino

12:D5:al pin 5 de Arduino

13:D6:al pin 6 de Arduino

14:D7:al pin 7 de Arduino

Después de este código de muestra de carga

  #include  LiquidCrystal lcd (12,11,4,5,6,7); // rs, e, d4, d5, d6, d7 respectivamentevoid setup () {lcd.begin (16,2); lcd.setCursor (0,1); lcd.print ("En funcionamiento");} bucle vacío () {}  

Después de cargar, si ve caracteres aleatorios o nada en absoluto, verifique su contraste (gire el dial del potenciómetro hacia arriba y hacia abajo), verifique la soldadura de su pin (los pines de datos NO deben estar conectados entre sí ni siquiera levemente), y finalmente su circuito y la línea 2 en el código de muestra (asegúrese de que los números de pin proporcionados a LiquidCrystal coincidan con los de su circuito.

Si todavía no pasa nada, no pierdas la esperanza, si has visto iluminarse la fila inferior en la primera parte, significa que tu pantalla lcd está bien. Juega con el circuito y la soldadura hasta que funcione.

Si ve el mensaje "Trabajando", entonces ha conectado correctamente su pantalla lcd y ha terminado la segunda parte de este tutorial. Deje su circuito como está, no nos meteremos más con él, todo lo que tenemos que hacer ahora será en el software.

Explicación del código en la Parte 2

LiquidCrystallcd (12,11,4,5,6,7);

Esta línea declara un objeto lcd con pines de interfaz como se indica en los argumentos. Ahora toda su interfaz lcd se realizará a través de este objeto 'lcd' (tenga en cuenta que puede nombrar esto como desee, pero mantenga ese nombre en todo momento).

lcd.begin (16,2);

Esta línea declara que nuestra pantalla lcd tiene dimensiones de 16 columnas y 2 filas, tenga en cuenta que su lcd puede no ser de 16 por 2, ajuste los números en consecuencia.

lcd.setCursor (0,1);

Esta línea colocará el cursor en la primera columna y la segunda fila (¡ya que el conteo en C ++ comienza con 0 y no con 1!). Tenga en cuenta que no puede ver el cursor, pero el cursor siempre está allí, fija el lugar en el que aparecerá el siguiente carácter.

lcd.print ("Bienvenido");

Esta línea imprimirá el mensaje Bienvenido en el lugar al que apunta el cursor, es decir, 0 columnas 1 filas.

Desplazamiento de texto

Bueno, imprimimos un mensaje en la pantalla, pero no es muy atractivo sentarse mirando ese mismo mensaje, además no sirve para nada. Así imprimiremos en esta sección un mensaje que se desplazará de derecha a izquierda como en los carteles publicitarios. Solo las funciones setup () y loop () serán diferentes, por lo tanto, solo estoy mostrando esas funciones, el resto permanece igual.

  void setup () {lcd.begin (16,2);} void loop () {int n; char message [] ="¡texto en movimiento!"; n =15; char * ptr =message; while (n! =- 14) {lcd.clear (); lcd.setCursor (n, 1); si (n <0) {ptr ++; } lcd.print (ptr); n -; retraso (250);}}  

Tenga en cuenta que para comprender este código, necesita un conocimiento bastante bueno de los punteros en C y C ++, ya que el lenguaje Arduino es en realidad AVR-C ++ ligeramente procesado.

En la función de bucle, estamos definiendo su mensaje como una cadena constante.

lcd.clear () se usa para limpiar la pantalla para cada iteración.

Luego configuramos un puntero ptr para contener la dirección del mensaje. Este valor de puntero se incrementará para ajustar el mensaje en la ventana lcd incluso después de que los caracteres se salgan de la vista hacia la izquierda. Hacemos esto para el extremo izquierdo y no para el derecho, ya que la biblioteca LiquidCrystal puede manejarlo para el extremo derecho (el texto se desplaza hacia afuera) pero no puede manejar direcciones de columna negativas como se requiere para nuestro programa.

Luego tenemos un ciclo while que mostrará el mensaje en varios lugares de izquierda a derecha dando así la ilusión de que el texto se está moviendo. Tenga en cuenta que el retraso () al final es para asegurarnos de que podemos leer el texto y que no se desplaza de derecha a izquierda a velocidades ilegibles. Si la animación parece demasiado lenta o demasiado rápida, puede cambiar el valor de retraso.

Caracteres personalizados

Para todos los usos de la función lcd.print (), no podemos mostrar, digamos, un dinosaurio, en la pantalla lcd. Sin embargo, podemos hacer esto usando una función de la biblioteca LiquidCrystal llamada Caracteres personalizados.

Para esto, definimos un byte de datos, que contiene 1 para todos los píxeles activados y 0 para todos los píxeles desactivados, así:

  byte dino [] ={B01110, B01110, B01100, B01111, B11101, B01010, B01010, B01010}  

Este es un personaje personalizado, que mostrará un dinosaurio en la pantalla LCD. Puedes crear tus propios personajes aquí:https://maxpromer.github.io/LCD-Character-Creator/

Después de esto, necesitamos mostrarlos. Sin embargo, estos caracteres no se pueden mostrar con el método lcd.print normal; necesitamos usar esto:

  void setup () {lcd.createChar (0, dino); lcd.begin (16,2); lcd.setCursor (0,1); lcd.write (byte (0));}  

Con este código, creamos un carácter direccionable personalizado a partir de nuestro byte dino [] definido por arlier. La dirección de nuestro carácter personalizado viene dada por el método lcd.createChar () que define el carácter 0 como dino []. Luego nos referiremos a este carácter como byte (0) que devuelve la dirección de nuestro carácter personalizado, y finalmente lo imprimiremos en la pantalla usando el método lcd.Write ().

Flechas de tiro

Este programa finalmente le enseñará cómo animar usando pantallas lcd, lea esto con atención.

  #include  LiquidCrystal lcd (12,11,4,5,6,7); punta de flecha de bytes [] ={B00001, B00011, B00111, B01111, B00111, B00011, B00001, B00000 } byte cuerpo de flecha [] ={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000} byteB00011, B00111, B01111, B11111, B11111, B01111, B00111, B00011} voidlcd.createChar; lcd. createChar (1, arrowbody); lcd.createChar (2, arrowtail); lcd.begin (16,2);} voidintwhile (n! =- 1) {lcd.clear (); lcd.setCursor (0,1); lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); n -; retraso (50);}}  

Aquí usamos tres caracteres personalizados para simular una flecha. El resto te es familiar. Mientras ejecuta esto en su pantalla lcd, puede notar un rastro detrás de la cola de flecha que lo hace parecer más largo de lo que es, no lo dude, es solo el residuo de la posición anterior de la flecha.

¡Eso es! ¡Ha terminado su primera animación con Arduino y LCD! ¡Juega con el código y combínalo con entradas de botones para transformarlo en un juego completo!

Juego LCD

¡Finalmente podemos hacer un juego! Sin embargo, durante este tutorial no voy a empezar con un juego muy complicado, sino un juego muy simple bastante similar a los primeros juegos de arcade.

Objetivo de este juego

Antes de comenzar el juego, debemos encontrar un objetivo para el juego.

En este juego, el objetivo es el siguiente:

Está el héroe, una persona en la fila 1 (tenga en cuenta que la primera fila es la fila 0) (normalmente) a quien se le disparará una serie de flechas. Si golpean al héroe, el juego termina. El héroe va a evitar las flechas saltando a la fila 0, que vamos a manipular mediante un botón. (presionar botón =fila 0 no =fila1). La puntuación se incrementa por bucle y se muestra en la esquina derecha.

En realidad, esta es una extensión de la animación de las flechas anteriores, por lo que solo incluiré las partes que han cambiado.

  byte man [] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001}; void setup () {// configura el número de columnas y filas de la pantalla LCD:lcd.createChar ( 0, punta de flecha); lcd.createChar (1, cuerpo de flecha); lcd.createChar (2, cola de flecha); lcd.createChar (3, hombre); lcd. comienzo (16, 2); attachInterrupt (0, buttonin, CHANGE); randomSeed (analogRead (A0)); // Imprime un mensaje en la pantalla LCD. //lcd.print("hello, world! ");} int n; void loop () {// coloca el cursor en la columna 0, línea 1 // (nota:la línea 1 es la segunda fila, ya que el conteo comienza con 0)://lcd.setCursor(0, 1); // imprime el número de segundos desde el reinicio://lcd.print (millis () / 1000); n =15; int rnd; rnd =aleatorio (15,25); while (n! =- 1) {lcd.clear (); retraso (10); dibujante (); lcd.setCursor (n, 1); if (n ==1) {if (nivel ==1) {stopgame (); Seguir; }} lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); lcd.setCursor (10,0); lcd.print (puntuación); retraso (100 rnd); norte--; puntuación ++; si (nivel ==0) puntuación--; }} void drawman () {lcd.setCursor (1, nivel); lcd.write (byte (3));} void buttonin () {if (digitalRead (2) ==LOW) {nivel =0; } más {nivel =1; }} void stopgame () {lcd.clear (); lcd.setCursor (0,0); lcd.print ("Fin del juego"); lcd.setCursor (10,0); lcd.print (puntuación); nivel =1; puntuación =0; n =15; retraso (3000); return;}  

No todo este código es sobre la pantalla lcd, pero TODO es importante para los desarrolladores de juegos.

Comenzamos con la definición de carácter de man [] que almacenará el byte para el personaje de man (nuestro héroe). Luego tenemos la función de configuración, donde solo han cambiado dos líneas. Ambas líneas son representativas de solo una parte del vasto grupo al que pertenecen, a saber, interrupciones y números aleatorios. Ambos son servicios muy útiles, más información sobre los cuales puede encontrar en el sitio web arduino.cc.

Primero tenemos la función attachInterrupt. Tenga en cuenta que la definición que voy a dar no es muy completa, pero es necesaria una breve para comprender lo que está sucediendo aquí.

Las interrupciones son funciones a las que se puede recurrir cuando se produce un evento, SIN IMPORTAR DONDE se esté produciendo la EJECUCIÓN. Este es un hecho importante útil para implementar funciones de entrada en tiempo real. Aquí lo usamos para asegurarnos de que no importa en qué punto de la ejecución se presione el botón, tomaremos la acción apropiada (al menos el programa lo hará).

Sintaxis para attachInterrupt:

attachInterrupt (pin_number-2, function_to_call_without_parehesis, condition_for_calling);

CHANGE es un valor #define usado para significar que para cualquier cambio de estado en la entrada de pin_number, se llamará a la función adjunta.

Entonces tenemos un número aleatorio. Una cualidad sobresaliente que poseen los procesadores físicos como Arduino y que los procesadores normales no tienen es que un número aleatorio generado por Arduino es realmente aleatorio como el ruido analógico presente en el pin A0 si El pin A0 es flotante (es decir, no está conectado) es aleatorio como predice la física cuántica (más o menos).

randomSeed se utiliza para establecer la semilla para el proceso aleatorio. random () es una función con parámetros MIN, MAX o MAX solo para obtener el siguiente número aleatorio en la secuencia.

Luego tenemos la función de interrupción buttonin () que verifica si el botón está presionado (BAJO) o no presionado (ALTO) y cambia el nivel (fila) de nuestro héroe en consecuencia.

¡¡Eso es todo, tenemos un juego completamente funcional !!

Código

• código para animación
• código para el juego

código para animación Arduino

 // incluye el código de la biblioteca:#include  // inicializa la biblioteca asociando cualquier pin de interfaz LCD necesario // con el número de pin arduino al que está conectado const int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7; LiquidCrystal lcd (rs, en, d4, d5, d6, d7); punta de flecha de bytes [] ={B00001, B00011, B00111, B01111, B00111, B00011, B00001 , B00000}; byte arrowbody [] ={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000}; byte arrowtail [] ={B00011, B00111, B11111, B11111, B11111, B00111, B00011, B00000}; byte man [] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001}; void setup () {// configura el número de columnas y filas de la pantalla LCD:lcd.createChar (0, punta de flecha); lcd.createChar (1, cuerpo de flecha); lcd.createChar (2, cola de flecha); lcd.createChar (3, hombre); lcd. comienzo (16, 2); // Imprime un mensaje en la pantalla LCD. //lcd.print("hello, world! ");} void loop () {// coloca el cursor en la columna 0, línea 1 // (nota:la línea 1 es la segunda fila, ya que el conteo comienza con 0)://lcd.setCursor(0, 1); // imprime el número de segundos desde el reinicio://lcd.print (millis () / 1000); int n; n =15; while (n! =- 1) {lcd.clear (); retraso (10); lcd.setCursor (0,0); lcd.print ("por Debanshu Das"); / * lcd.setCursor (1,1); lcd.write (byte (3)); lcd.setCursor (n, 1); lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); * / retraso (65); norte--; }} 

código para el juego Arduino

 // incluye el código de la biblioteca:#include  // inicializa la biblioteca asociando cualquier pin de interfaz LCD necesario // con el número de pin arduino al que está conectado const int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7; LiquidCrystal lcd (rs, en, d4, d5, d6, d7); int level =1; int score =0; byte arrowhead [] ={B00001, B00011 , B00111, B01111, B00111, B00011, B00001, B00000}; cuerpo de flecha de bytes [] ={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000}; cola de flecha de bytes [] ={B00011, B00111, B11111, B11111 , B11111, B00111, B00011, B00000}; byte man [] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001}; void setup () {// configura el número de columnas y filas de la pantalla LCD:lcd.createChar (0, punta de flecha); lcd.createChar (1, cuerpo de flecha); lcd.createChar (2, cola de flecha); lcd.createChar (3, hombre); lcd. comienzo (16, 2); attachInterrupt (0, buttonin, CHANGE); randomSeed (analogRead (A0)); // Imprime un mensaje en la pantalla LCD. //lcd.print("hello, world! ");} int n; void loop () {// coloca el cursor en la columna 0, línea 1 // (nota:la línea 1 es la segunda fila, ya que el conteo comienza con 0)://lcd.setCursor(0, 1); // imprime el número de segundos desde el reinicio://lcd.print (millis () / 1000); n =15; int rnd; rnd =aleatorio (15,25); while (n! =- 1) {lcd.clear (); retraso (10); dibujante (); lcd.setCursor (n, 1); if (n ==1) {if (nivel ==1) {stopgame (); Seguir; }} lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); lcd.setCursor (10,0); lcd.print (puntuación); retraso (100 rnd); norte--; puntuación ++; si (nivel ==0) puntuación--; }} void drawman () {lcd.setCursor (1, nivel); lcd.write (byte (3));} void buttonin () {if (digitalRead (2) ==LOW) {nivel =0; } más {nivel =1; }} void stopgame () {lcd.clear (); lcd.setCursor (0,0); lcd.print ("Fin del juego"); lcd.setCursor (10,0); lcd.print (puntuación); nivel =1; puntuación =0; n =15; retraso (3000); volver;} 

Esquemas

Persianas inteligentes Arduino Due TIC TAC TOE con pantalla táctil