Esta publicación muestra cómo puedes poder realizar el conocido juego de Tetris con un microcontrolador y una pantalla táctil. La carcasa de pared AZ-Touch con pantalla de 2,8 pulgadas o la carcasa de pared AZ-Touch MOD con pantalla de 2,4 pulgadas se utilizan como base. Se puede utilizar un ESP32 Dev-Kit C o un D1-Mini como microcontrolador. Una vez soldadas las tiras de enchufe para la pantalla y el controlador en el lado del componente, se puede montar la pantalla. Consejo: Suelde únicamente las tiras de resorte (también llamadas tiras Caterpillar) que se requieren para la MCU respectiva.
 |
Si el D1-Mini se va a utilizar como controlador, no debe estar equipado con los encabezados de pines simples, ya que los pines no se sujetan de forma segura en el zócalo. Es mejor equipar el D1-Mini con los cabezales combinados de resorte / pasador, ya que estos pasadores son más largos.
 |
Cuando haya soldado en las barras Caterpillar para ambos MCU, los pines de la barra ESP32 que se encuentran debajo del D1-Mini deben cubrirse con una cinta aislante para que no haya conexión conductora con la carcasa del enchufe USB del D1- Mini viene. Ver imagen.
Hardware requerido
|
número |
Componente |
anotación |
|---|---|---|
|
1 |
|
|
|
o 1 |
|
|
|
1 |
|
|
|
o 1 |
|
Estructura del programa
Se supone que se conocen las reglas del juego de Tetris. En esta implementación se utilizan siete partes diferentes. Con las versiones rotadas, hay 19 partes diferentes.
Cada parte se almacena como una constante en una matriz con 4 x 4 = 16 bytes. Las siete partes diferentes tienen colores diferentes. En la matriz, los bloques no utilizados se rellenan con 0 y los bloques ocupados con el índice de la tabla de colores.
// colores para los bloques
const uint16_t colorBlock [8] = {ILI9341_BLACK, ILI9341_YELLOW, ILI9341_RED, ILI9341_CYAN, ILI9341_GREEN, ILI9341_PURPLE, ILI9341_BLUE, ILI9341_ORANGE};
// patrón de bits para las piezas
// 0 = bloque no establecido> 0 índice del color del bloque
const uint8_t pieza [20] [16] = {
{0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0 , 0,
0, 0, 0, 0},
{0, 0, 0, 0,
0, 0, 0, 0,
1, 1, 0 , 0,
1, 1, 0, 0},
{0, 2, 0, 0,
 | < / tr>
El tablero de juego en sí tiene 16 líneas con 12 columnas. La indexación de las columnas es de izquierda a derecha, la de las filas de abajo hacia arriba.
 |
A continuación, se muestra la secuencia del programa para una mejor comprensión. Un juego se inicia limpiando el marcador y el campo de juego. Luego, se inserta una nueva parte en la parte superior. El juego termina si no se puede insertar ninguna parte nueva. El diagrama de flujo muestra la secuencia del bucle principal.
 |
Los cambios a la derecha e izquierda, así como la rotación, se activan de forma asincrónica mediante eventos táctiles. Después de comprobar si el cambio es posible, se lleva a cabo. Si el cambio no es posible, todo permanece sin cambios.
La puntuación aumenta en 4 por cada parte recién agregada. Si se puede eliminar una fila completa, la puntuación aumenta en 10. Dependiendo de la puntuación, el nivel y la velocidad de caída aumentan.
| Puntuación | Nivel | Velocidad de caída |
|---|---|---|
| <100 | 1 | 0.9 s / línea | <1000 | 2 | 0,7 s / línea |
| <10 000 | 3 | 0,5 s / línea |
| <100 000 | 4 | 0,3 s / line |
| Desde 100.000 | 5 | 0,1 s / línea |
El programa
Además el paquete ESP32 o ESP8266 requiere las siguientes bibliotecas:
- Adafruit ILI9341
- Biblioteca Adafruit GFX
- XPT2046_Touchscreen
- TouchEvent
El programa diferencia automáticamente entre ESP32 y D1-Mini y usa las asignaciones de pines correspondientes. La versión actual es para la pantalla de 2,8 pulgadas. Para la pantalla de 2,4 pulgadas, la línea de #define TOUCH_ROTATION = 3
debe cambiarse a
#define TOUCH_ROTATION = 1
.
# incluir < Adafruit_GFX . h > // Bibliothek Grafik # incluir < Adafruit_ILI9341 . h > // Mostrar Treiber # incluir < XPT2046_Pantalla táctil . h > // Pantalla táctil Treiber # incluir < TouchEvent . h > // Auswertung von Touchscreen Ereignissen // Aussehen # definir FONDO ILI9341_GREENYELLOW // Farbe des Rahmens # definir TOPMARGIN 20 // Rand oben # definir LEFTMARGIN 12 // Rand links und rechts # definir COLUMNAS 12 // Anzahl der Spalten # definir FILAS 16 // Anzahl der Zeilen # definir TAMAÑO DEL BLOQUE 18 // Größe eines Blocks in Pixel # definir NOPIECE ILI9341_BLACK // Farb für das leere Spielfeld # definir ALLON ILI9341_DARKGREY // Farbe für alle Blöcke ein # definir FRONTERA ILI9341_WHITE // Farbe für den Blockrand // Unterschiedliche Pin-Belegung für ESP32 und D1Mini # ifdef ESP32 # definir TFT_CS 5 # definir TFT_DC 4 # definir TFT_RST 22 # definir TFT_LED 15 # definir TOUCH_CS 14 # definir LED_ON 0 # endif # ifdef ESP8266 # definir TFT_CS D1 # definir TFT_DC D2 # definir TFT_RST - 1 # definir TFT_LED D8 # definir TOUCH_CS 0 # definir LED_ON 1 # endif # definir TOUCH_ROTATION 3 // muss für 2.4 Zoll Display 1 und für 2.8 Zoll Display 3 sein // Instanzen der Bibliotheken Adafruit_ILI9341 tft = Adafruit_ILI9341 ( TFT_CS , TFT_DC , TFT_RST ) ; XPT2046_Pantalla táctil toque ( TOUCH_CS ) ; TouchEvent tevent ( toque ) ; // Farben für die Blöcke const uint16_t colorBlock [ 8 ] = { ILI9341_BLACK , ILI9341_YELLOW , ILI9341_RED , ILI9341_CYAN , ILI9341_GREEN , ILI9341_PURPLE , ILI9341_BLUE , ILI9341_ORANGE }; // Bitmuster für die Teile // 0 = Bloque nicht gesetzt> 0 Index der Farbe für den Block constante uint8_t pedazo[20][16] = { {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0}, {0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2}, {0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 3, 3, 0}, {0, 0, 0, 0, 0, 3, 0, 0, 3, 3, 0, 0, 3, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 4, 0, 0}, {0, 0, 0, 0, 4, 0, 0, 0, 4, 4, 0, 0, 0, 4, 0, 0}, {0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 5, 5, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 5, 5, 5, 0}, {0, 0, 0, 0, 5, 5, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 0, 5, 0, 0, 0}, {0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 6, 6, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 0}, {0, 0, 0, 0, 6, 6, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 6, 6, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 7, 7, 0}, {0, 0, 0, 0, 0, 7, 0, 0, 7, 7, 0, 0, 0, 7, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 0, 0, 7, 0, 0}, {0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 7, 0, 0, 7, 0, 0} }; // Speicherplatz für das Spielfeld // 0 bedeutet Block frei> 0 Index der Farbe des belegten Blocks uint8_t patio de recreo[FILAS][COLUMNAS]; // Variable globaln uint8_t curPiece; // aktuelles Tetris Teil int8_t curCol; // aktuelle Spalte int8_t curRow; // aktuelle Zeile uint32_t puntaje; // Puntuación aktueller uint8_t nivel; // Nivel aktueller uint16_t intervalo; // aktuelles Zeitintervall für die Abwärtsbewegung uint32_t último; // letzter Zeitstempel // Fuktion zeigt in der Kopfleiste den aktuellen Score und den Level an // Abhängig vom Score wird der Level hinaufgesetzt und das Intervall verringert vacío displayScore() { si (puntaje < 10) {nivel = 1; intervalo = 900;} demás si (puntaje < 100) {nivel = 2; intervalo = 700;} demás si (puntaje < 1000) {nivel = 3; intervalo = 500;} demás si (puntaje < 10000) {nivel = 4; intervalo = 300;} demás si (puntaje < 100000) {nivel = 5; intervalo = 100;} tft.fillRect(0,0,240,20,ANTECEDENTES); tft.setTextSize(2); tft.setTextColor(ILI9341_BLACK); tft.setCursor(5,4); carbonizarse buf[50]; sprintf(buf,"SC:% 8i LV:% i",puntaje,nivel); tft.imprimir(buf); } // Funktion um ein Tetris-Teil zu drehen. Der Parameter ist die Nummer des // Teils das gedreht werden soll. Rückgabewert ist der Index des vgerehten // Teils uint8_t girar(uint8_t ordenador personal) { uint8_t res = 0; cambiar (ordenador personal) { caso 1: res = 1; descanso; caso 2: res = 3; descanso; caso 3: res = 2; descanso; caso 4: res = 5; descanso; caso 5: res = 4; descanso; caso 6: res = 7; descanso; caso 7: res = 6; descanso; caso 8: res = 9; descanso; caso 9: res = 10; descanso; caso 10: res = 11; descanso; caso 11: res = 8; descanso; caso 12: res = 13; descanso; caso 13: res = 14; descanso; caso 14: res = 15; descanso; caso 15: res = 12; descanso; caso 16: res = 17; descanso; caso 17: res = 18; descanso; caso 18: res = 19; descanso; caso 19: res = 16; descanso; } regreso res; } // La función prueba si una línea está llena booleano rowComplete(int8_t rpg) { si ((rpg >= 0) && (rpg < FILAS)) { booleano res = cierto; uint8_t C = 0; // si no se usa un bloque (color 0), // la línea no está completa mientras (res && (C < COLUMNAS)) { si (patio de recreo[rpg][C] == 0) res = falso; C++; } regreso res; } } // La función comprueba si hay entre la línea rpc de la pieza de Tetris pc y // la línea rpg del campo de juego desde la posición cpg da colisiones. // Cuando ocurre una colisión o la última línea del campo de juego // se alcanzó se devuelve incorrectamente booleano checkRow(uint8_t ordenador personal, int8_t rpc, int8_t cpg, int8_t rpg) { booleano res = cierto; si (rpg >= FILAS) regreso falso; si (rpg < 0) regreso cierto; por (uint8_t I = 0; I<4; I++) { si (pedazo[ordenador personal][rpc*4 + I]>0) { si (((cpg+I) < 0) || ((cpg+I) >= COLUMNAS)) { res = falso; }demás { si (patio de recreo[rpg][cpg+I] > 0) res = falso; } } } regreso res; } // La función comprueba si el PC de la parte de Tetris en el campo de juego en la posición // fila rpg columna cpg (esquina inferior izquierda de la pieza) ocurren colisiones booleano checkPiece(uint8_t ordenador personal, int8_t cpg, int8_t rpg) { booleano res = cierto; uint8_t rpc = 0; mientras (res && (rpc < 4)) { res = checkRow(ordenador personal,rpc,cpg,rpc+rpg-3); // Serial.printf ("comprobar% i =% i \ n", rpc + rpg-3, res); rpc++; } regreso res; } // La función muestra un bloque del campo de juego en la fila y columna x con el color color // color es el color del formato 565 para la pantalla vacío showBlock(uint8_t X, uint8_t y, uint16_t color) { tft.fillRect(MARGEN IZQUIERDO+X*TAMAÑO DE BLOQUE+2,MARGEN SUPERIOR+y*TAMAÑO DE BLOQUE+2,TAMAÑO DE BLOQUE-4,TAMAÑO DE BLOQUE-4,color); tft.drawRect(MARGEN IZQUIERDO+X*TAMAÑO DE BLOQUE+1,MARGEN SUPERIOR+y*TAMAÑO DE BLOQUE+1,TAMAÑO DE BLOQUE-2,TAMAÑO DE BLOQUE-2,FRONTERA); } // La función llena un bloque del campo de juego en la fila y columna x con el color de fondo vacío hideBlock(uint8_t X, uint8_t y) { tft.fillRect(MARGEN IZQUIERDO+X*TAMAÑO DE BLOQUE,MARGEN SUPERIOR+y*TAMAÑO DE BLOQUE,TAMAÑO DE BLOQUE,TAMAÑO DE BLOQUE,NOPIECE); } // La función muestra la pieza de Tetris pc en la fila rpg, columna cpg (esquina inferior izquierda) // El color se toma de la definición de la parte Tetris vacío obra maestra(uint8_t ordenador personal, uint8_t cpg, uint8_t rpg) { uint8_t color; por (uint8_t r = 0; r<4; r++) { por (uint8_t C = 0; C<4; C++) { color = pedazo[ordenador personal][r*4+C]; si ((color > 0) && ((3-r+rpg) >= 0)) showBlock(cpg+C,rpg-3+r,bloque de color[color]); } } } // La función llena los bloques ocupados de la pieza de Tetris pc en línea rpg, // columna cpg (esquina inferior izquierda) con color de fondo vacío hidePiece(uint8_t ordenador personal, int8_t cpg, int8_t rpg) { uint8_t color; por (uint8_t r = 0; r<4; r++) { por (uint8_t C = 0; C<4; C++) { color = pedazo[ordenador personal][r*4+C]; si ((color > 0) && ((3-r+rpg) >= 0)) hideBlock(cpg+C,rpg-3+r); } } } // la función llena la fila del campo de juego con color de fondo y // borra todas las entradas para esta línea en la memoria de campo vacío borrar fila(int8_t fila) { tft.fillRect(MARGEN IZQUIERDO,MARGEN SUPERIOR+fila*TAMAÑO DE BLOQUE,COLUMNAS * TAMAÑO DE BLOQUE,TAMAÑO DE BLOQUE,NOPIECE); por (uint8_t I =0; I<COLUMNAS; I++) patio de recreo[fila][I]=0; } // La función copia la línea srcrow a la línea dstrow // La visualización de la línea de destino se elimina de antemano. En el // copiar la línea de origen se muestra en la línea de destino vacío copyRow(int8_t srcrow, int8_t dstrow) { uint8_t columna; borrar fila(dstrow); si ((srcrow < dstrow) && (srcrow >=0) && (dstrow < FILAS)) { por (uint8_t C = 0; C < COLUMNAS; C++) { columna = patio de recreo[srcrow][C]; patio de recreo[dstrow][C] = columna; si (columna > 0) showBlock(C,dstrow,bloque de color[columna]); } } } // La función muestra todos los bloques del campo de juego con el color ALLON. // Después de una pausa de 500 ms, Sielfeld se elimina por completo vacío clearBoard() { por (uint8_t X = 0; X<COLUMNAS; X++) { por (uint8_t y = 0; y<FILAS; y++) { showBlock(X,y,ALLON); } } demora(500); por (uint8_t I = 0; I<FILAS; I++) { borrar fila(I); } } // La función transfiere el PC de la pieza de Tetris a la memoria de campo en la fila // rpg en la columna cpg (esquina inferior izquierda) vacío putPiece(uint8_t ordenador personal, int8_t cpg, int8_t rpg) { uint8_t color; por (uint8_t r = 0; r<4; r++) { por (uint8_t C = 0; C<4; C++) { color = pedazo[ordenador personal][r*4+C]; si ((color > 0) && ((3-r+rpg) >= 0)) patio de recreo[rpg-3+r][cpg+C] = color; } } } // Se inserta una nueva pieza de tetris en la parte superior del campo de juego. // Qué parte y en qué columna se determina como un número aleatorio // Si la parte nueva no tiene lugar en el campo de juego, el juego termina booleano nuevoPieza() { uint8_t ordenador personal = aleatorio(1,20); uint8_t cpg = aleatorio(0,COLUMNAS-4); booleano res = checkPiece(ordenador personal,cpg,3); curPiece=0; si (res) { curPiece = ordenador personal; curCol = cpg; curRow = 0; obra maestra(ordenador personal,cpg,0); puntaje += 4; displayScore(); } demás { tft.setTextSize(3); tft.setCursor(MARGEN IZQUIERDO+COLUMNAS*TAMAÑO DE BLOQUE/2-79,MARGEN SUPERIOR+FILAS*TAMAÑO DE BLOQUE/2-10); tft.setTextColor(ILI9341_BLACK); tft.imprimir("JUEGO TERMINADO"); tft.setCursor(MARGEN IZQUIERDO+COLUMNAS*TAMAÑO DE BLOQUE/2-81,MARGEN SUPERIOR+FILAS*TAMAÑO DE BLOQUE/2-12); tft.setTextColor(ILI9341_YELLOW); tft.imprimir("JUEGO TERMINADO"); } } // La función determina líneas completamente llenas en el campo de juego y las elimina // Las líneas de arriba se mueven hacia abajo vacío removeComplete() { uint8_t s=FILAS-1; int8_t D= FILAS-1; mientras (D >= 0) { si (rowComplete(D)) { s--; puntaje += 10; copyRow(s,D); } demás { si ((s < D) && (s >=0)) { De serie.printf("copiar% i a% i \ n",s, D); copyRow(s,D); } s--; D--; } } displayScore(); } // la función inicia un nuevo juego. La puntuación se establece en 0, el campo de juego // eliminado y comenzado con una nueva parte de Tetris vacío nuevo juego() { puntaje=0; displayScore(); clearBoard(); nuevoPieza(); } // Función de devolución de llamada para hacer clic en eventos de pantalla táctil // Esta función se llama siempre que la pantalla // se toca brevemente. p indica la posición del punto de contacto vacío al hacer clic(TS_Point pag) { si (pag.y < 80) { // Haga clic en el cuarto superior de la pantalla nuevo juego(); } demás si (pag.y > 240) { // Haga clic en el trimestre más bajo uint8_t ordenador personal = curPiece; int8_t C = curCol; si (pag.X < 80) { // Haga clic en el tercio izquierdo -> deslice hacia la izquierda C--; } demás si (pag.X <160) { // haga clic en el tercio medio -> girar ordenador personal = girar(ordenador personal); } demás { // haga clic en el tercio derecho -> deslice hacia la derecha C++; } // después de cambiar la posición, se verifica una colisión // solo si no se produce una colisión, el movimiento // ejecutado si (checkPiece(ordenador personal,C,curRow)) { hidePiece(curPiece,curCol,curRow); curPiece = ordenador personal; curCol = C; obra maestra(curPiece,curCol,curRow); } } } //Preparación vacío configurar() { De serie.comenzar(115200); // enciende la luz de fondo pinMode(TFT_LED,PRODUCCIÓN); escritura digital(TFT_LED, LLEVADO EN); De serie.println("Comenzar"); // inicializar la pantalla tft.comenzar(); tft.fillScreen(ANTECEDENTES); // Prepara la pantalla táctil tocar.comenzar(); tocar.setRotation(TOUCH_ROTATION); evento.setResolution(tft.ancho(),tft.altura()); evento.setDrawMode(falso); // Registrar la función de devolución de llamada evento.registerOnTouchClick(al hacer clic); //tft.fillRect(LEFTMARGIN,TOPMARGIN,COLUMNS*BLOCKSIZE,ROWS*BLOCKSIZE,NOPIECE); clearBoard(); // newPiece (); // Recuerda la hora de inicio y elimina el campo de juego carga = millis(); puntaje=0; displayScore(); } // bucle principal vacío lazo() { // Verificar eventos táctiles evento.pollTouchScreen(); // Siempre que se alcanza el intervalo de tiempo, la parte actual de Tetris se convierte en // Bajó una línea si es posible. // Si hay una colisión o se alcanza el borde inferior, // para que la parte no se mueva sino que se ancle en el campo de juego. // Se eliminan las líneas completas y una nueva parte en la parte superior // margen insertado si ((curPiece > 0) && ((millis()-carga) > intervalo)) { carga = millis(); si (checkPiece(curPiece,curCol,curRow+1)) { hidePiece(curPiece,curCol,curRow); curRow++; obra maestra(curPiece,curCol,curRow); } demás { putPiece(curPiece,curCol,curRow); removeComplete(); nuevoPieza(); } } }
Diviértete jugando.
 |
4 comentarios
Bernhard
Bei mir hat das Übertragen problemlos funktioniert. Display + Touch funktionieren. Wenn ich allerdings das Spiel starte kommt es zu einer Exception/Reboot. Ich kann keinen Fehler finden – weder in Code noch in meinem Setup :-(
Woran könnte es liegen?
ArduinoTouch 01-03 mit ESP8266, 2.4Zoll TFT
Gerald
Hallo TimQ,
die meisten Beispiele auch die im Smarthome-Buch arbeiten mit der AZ-Touch Version mit 2.4 Zoll Display und der alten Version der Platine, bei der ein Jumper zum Hochladen angeschlossen werden musste. Bei der neuen Platine wurde die Interruptleitung für den Touchscreen auf Pin27 geändert. Hier die notwendigen Änderungen damit die Smarthome-Zentrale aus dem Smarthome Buch funktioniert.
Das neue AZ-Touch MOD hat den Interrupt für den Touchscreen nicht mehr an Pin 2 sondern an Pin27.
Die entsprechende Definition am Anfang der Smarthome Sketches muss daher
#define TOUCH_IRQ 27
lauten.
Bei der Verwendung des 2.8 Zoll Displays muss außerdem in der Setup-Funktion nach
touch.begin();
touch.setRotation(3);
eingefügt werden.
Birger T
Dieses Projekt sollte der Beginn meiner Beschäftigung mit den ESP32 und ESP8266 aus einem AZ-Delivery Überraschungspaket sein. Nach dem Studium der diversen E-books habe ich auch irgendwo den Hinweis gefunden, wie weitere Bordverwalter URLs in die Arduino IDE zu ergänzen sind und somit die “Boards” installiert werden können. Doch der erste Versuch mit dem Blink-Sketch funktionierte nicht: Kompilierung abgebrochen, weil das im ESP-Tool einzubindende “Serial” nicht vorhanden ist.
Ich arbeite unter Ubuntu 20.04 – und wollte hier denjenigen Ubuntu Usern, die ebenfalls Probleme mit der ESP Programmierung in der Arduino IDE das Problem mit dem “Serial” haben, einen/den Link zur Lösung mitteilen: https://koen.vervloesem.eu/blog/fixing-the-arduino-ide-for-the-esp32esp8266-on-ubuntu-2004/
TimQ
Das ist das erste Beispiel für den AZ-Touch MOD 01-03 und ESP32, das funktioniert. Super !
Alle anderen Versuche mit den Beispielen aus den Blocks, Smarthome Buch oder den zahlreichen Foren sind bei mir gescheitert. Entweder blieb der Screen weiß oder dunkel. Ich hoffe es gibt bald mal eine wirklich funktionierende Beschreibung zur Smarthome Zentrale. Danke