4 victorias con el mod de AZ-Touch

Como ya se habrá dado cuenta, no solo soy bloguero, sino también padre de la familia. Por lo tanto, hay que combinar el pasatiempo y la vida familiar de alguna manera y programa pequeños juegos para los niños. En este caso, el popular juego "4 Wins", que ya existe en diversas formas y diseños. En este caso, llevamos el juego al AZ-Touch Mod con una pantalla de 2.4 "o 2.8", y al mismo tiempo va a aprender sobre matrices multidimensionales y funciones recursivas.

El hardware y el software para este blog

Para que pueda recrear este blog, necesitará los componentes que se presentan en la Tabla 1:

Pos

número

Componente

1

1

Módulo ESP32 Nodemcu WiFi Tablero de desarrollo con CP2102 (modelo sucesor de ESP8266)

2

o

1

Set de Carcasa de Pared AZ-Touch Mod con Pantalla Táctil de 2.4" para ESP8266 y ESP32

3

1

Set de Carcasa de Pared AZ-Touch Mod con Pantalla Táctil de 2.8" para ESP8266 y ESP32

4

(Opcional)

1

Fuente de alimentación 12V

Tabla 1: Componentes para juego "4 Wins"

En cuanto al software, necesita:

Lo básico

La matriz multidimensional

Si no tiene conocimientos de informática, pero la programación es uno de sus pasatiempos, probablemente reconocerá el término "matriz multidimensional". En una de mis últimas publicaciones en el blog de juego TicTacToe, utilicé una matriz normal de tipo de datos enteros, vea el código 1:

int IsetMark[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

Código 1: Matriz del tipo de datos enteros

Se trata de la llamada matriz unidimensional, en la que sólo existe una serie de datos. En la línea 29 del juego "4 Wins" se crea una matriz bidimensional, vea el código 2:

byte bmatrix[Numrov][Numcolumn];

Código 2: Matriz bidimensional

En principio, puede imaginarse una matriz bidimensional como una lista de Excel. Se ingresa un valor en cada columna y fila, que luego se puede leer o escribir nuevamente. Básicamente, esto se puede llevar tan lejos que se puede crear una matriz N-Dimensional, vea Código 3:

Datatype array [first level] [second level] [third level] .... [N-1 level] [nth level];

Código 3: Matriz N-dimensional

La lectura y escritura de este tipo de matrices puede ser bastante difícil, dependiendo de lo compleja que sea la matriz. Para restablecer la matriz bidimensional de "4 Wins", se necesitan dos bucles anidados, vea el código 4:

/*
 * =================================================================
 * FUNCTION: ResetMatrix
 * RETURNS: Void
 * Description: Reset the Matrix
 * =================================================================
 */
 void resetmatrix()
 {
   Serial.Println("----- Reset Matrix -----");
   for(int icolum = 0; icolum < int(Numcolumn); icolum++)
     for(int Irov = 0; Irov < int(Numrov); Irov++)
       bmatrix[Irov][icolum] = 0;
   showmatrix();
   Serial.Println("------------------------");
 }

Código 4: Restablecimiento de la matriz bidimensional de "4 Wins"

Para entender mejor el bucle anidado, podemos enrollarlo. En el centro, encontramos la orden:

Bmatrix [Irow] [Icolumno] = 0;

Las ubicaciones de almacenamiento de una matriz se especifican entre corchetes. Cuantos más corchetes, más niveles (como se ha descrito anteriormente). Dos niveles representan una tabla, como se mencionó con anterioridad. A continuación, se navega por las filas y columnas con los valores de los paréntesis empezando por  0:
Bmatrix [0] [0] = 0;

Bmatrix [0] [1] = 0;

Bmatrix [1] [0] = 0;

Bmatrix [1] [1] = 0;

etc.

Ahora se puede usar uno de los dos bucles para correr a través de una línea (iterar). El otro bucle cuenta entonces a través de las columnas. En este caso, el bucle interno se encarga de las filas y el exterior de las columnas.

Ahora se puede presentar una matriz tridimensional como una segunda tabla que se encuentra detrás de la primera. En la cabecera del bucle, se especifica el valor de inicio, el valor final y el tamaño del paso. Para definir todos los valores de una matriz con 0, debe hacerlos así en C o C ++.

Solo eche un vistazo a la función Checkporwinner (), donde se lee la matriz bidimensional para determinar un posible ganador.

La llamada a la función recursiva

Si la función Checkporwinner () ya se mencionó, el tema de las llamadas a funciones recursivas también se debe explicar con más detalle. En muchas de nuestras entradas de blog encontrará algo como en el código 5.

boot checkvertical(int Irov, int icolum)

Código 5: Ejemplo de una función

En primer lugar, se define el valor de retorno de la función, en el ejemplo un BOOL (es decir, True o False, o HIGH o LOW, o 0 o 1). Directamente después de eso sigue el nombre de la función, que se utiliza para llamar a la función en el código fuente. Después de eso sigue en los paréntesis, que los datos se utilizan como copia,  como referencia o puntero. Con esto ha aclarado primero el principio de una función "normal". Una llamada a una función recursiva se llama así porque la función se llama a sí misma de nuevo. Esto se puede ver mejor en el código 6:

 /*
 * =================================================================
 * FUNCTION: CHECKVERTICAL
 * RETURNS: TRUE IF There is a Winner Else False
 * INPUT IROW: CURRENT ROW
 * INPUT ICOLUMN: CURRENT COLUMN
 * Ref Isum: Sum of Current Equal position
 * Description: RECURSIVE FUNCTION TO CHECK VERTICAL WIN
 * =================================================================
 */
 boot checkvertical(int Irov, int icolum, int &isum)
 {
   IF(bmatrix[Irov][icolum] != Bplayermove || bmatrix[Irov][icolum] == 0)
     return false;
   Else
  {
     isum++;
     IF(isum == 4)
       return true;
     Else
       return checkvertical(Irov, icolum+1, isum);
  }
 }

Código 6: Ejemplo de una función recursiva

Lo peligroso en este tipo de llamada es que los errores son difíciles de encontrar y puede programar un bucle infinito no deseado. Por lo tanto, la condición de terminación debe ser programada limpiamente, véase la consulta interna if del código 6, que devuelve un verdadero y termina la llamada recursiva. En este punto, se comprueba la referencia iSuma para ver si iSuma ha alcanzado el valor 4.

Así que tenga cuidado al programar funciones recursivas.

Transferir el juego al microcontrolador

Para jugar "4 Wins", descarga el paquete zip de mi página de GitHub. Descomprima este archivo ZIP y abra la carpeta directamente después. Allí encontrará dos archivos:

  • ino: El programa para el Arduino IDE.
  • h: El archivo de configuración de la pantalla

Por favor, reemplace el archivo usuario_setup.h en la carpeta C:\ NUsuario\Tu nombre\ Documents\ Arduino \ librerias \ TFT_ESPI, consulte la figura 1. Tiene sentido cambiar el nombre del archivo con el mismo nombre anterior, por ejemplo en User_setup_old.h.

Usuario_setup.h anulación

Figura 1: usuario_setup.h sobrescribir

A continuación, abra el código fuente en el Arduino IDE y seleccione el microcontrolador adecuado según las instrucciones de libro electrónico. Transfiera el programa al microcontrolador y después de un reinicio debería ver el aviso de calibración, consulte la Figura 2.

Solicitud de calibración en la pantalla

Figura 2: Aviso de calibración en la pantalla

Si se produce un error al compilar, por ejemplo, TFT_eSPI no conoce la función calibrateTouch (), entonces no ha reemplazado correctamente el usuario_Setup.H, o el usuario_setup.h está en el mismo directorio que el archivo *.ino, que no debería estar.

Si se ha completado este paso, busque la flecha verde junto a las casillas rojas en la esquina y se le mostrará la pantalla de inicio inmediatamente después, consulte la Figura 3:

Pantalla de inicio de "4 victorias"

Figura 3: Pantalla de inicio de "4 Wins"

Al presionar el botón "Start", el campo de juego se construye directamente, consulte la Figura 4:

El campo de juego

Figura 4: El campo de juego

En la parte superior, observa los objetivos para configurar su pieza de juego, a la derecha, observa qué jugador es el que le toca. Para que usted y sus oponentes pueden ver en todo momento de quién es el turno y, por supuesto, qué piezas se han colocado, consulte la figura 5:

Juego avanzado con toda la información necesaria.

Figura 5: Juego avanzado con toda la información necesaria.

No se preocupe por obtener la casilla correcta, dependiendo de la columna que usted o su oponente seleccionen, la posición correcta de la pieza se determina automáticamente. Cuando una columna está llena, tampoco es posible realizar otro movimiento en esa columna, al igual que en el juego real.

Si uno de los dos jugadores ha ganado o si el campo de juego está lleno y nadie ha podido ganar, aparece la correspondiente pantalla de finalización, consulte la figura 6:

El juego hasta el final, el jugador 2 ha ganado

Figura 6: Fin de la partida, el jugador 2 ha ganado.

Le deseamos mucha diversión mientras juega y una pequeña información importante al final:

Dado que la pantalla de 2.4 "y 2.8" tienen la misma resolución, no tiene que ser incómodo cambiar nada en el código fuente. Si se calibra al principio, se puede utilizar el AZ-Touch con pantalla de 2.4" o 2.8".

Más proyectos para AZ-Entrega de mi parte, puede encontarlos en https://github.com/M3taKn1ght/Blog-Repo.

MuestraEsp-32Proyectos para principiantes

Deja un comentario

Todos los comentarios son moderados antes de ser publicados

Artículos de blog

  1. Ahora instalamos el esp32 a través de la administración.
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. Transporte Aéreo - programación de ESP mediante redes locales inalámbricas