Tetris am AZ-Touch

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

Pantalla de 2,8 pulgadas con carcasa de pared AZ-Touch

 

o 1

Pantalla de 2,4 pulgadas con carcasa de pared AZ-Touch MOD

 

1

ESP32 Dev C

 

o 1

D1 mini

 

 

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.

Para que la mayor área posible esté disponible para el juego, no se muestran botones táctiles. Para iniciar el juego, toque el cuarto superior de la pantalla. El cuarto más bajo de la pantalla se usa para mover las piezas. Esta tira se divide en tres. Tocar el tercio izquierdo empuja la parte de Tetris que cae hacia la izquierda, tocar el tercio medio hace girar la parte y tocar el tercio derecho empuja la parte hacia la derecha.


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.

< tr>

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();
    }
  }
}

 

Boceto para descargar

Contribución como PDF

Diviértete jugando.

 

MuestraEsp-32Precipitador electrostático - 8266Casa inteligente

3 comentarios

Gerald

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

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

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

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