Conceptos básicos de la interfaz Arduino TFT: 10 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Las pantallas táctiles TFT son la increíble interfaz gráfica que se puede usar con microcontroladores como Atmel, PIC, STM, ya que tiene una amplia gama de colores, una buena capacidad gráfica y un buen mapeo de píxeles.

Hoy, vamos a conectar el Shield TFT LCD de 2,4 pulgadas con Arduino.

Este escudo es para Arduino UNO, pero enseñaré cómo usarlo con Arduino Mega por una razón muy lógica, la "Memoria de programa".

Al utilizar este protector LCD TFT a color, podemos mostrar caracteres, cadenas, interfaz de botones, imágenes de mapa de bits, etc. en la pantalla LCD TFT a color.

Paso 1: requisitos de hardware y software

Para hacer la interfaz del escudo con el Arduino mega, necesitamos lo siguiente.

HARDWARE:

• Arduino mega

• LCD TFT de 2,4 / 2,8 / 3,2 pulgadas

• Cable USB

SOFTWARE

• IDE de Arduino

• Biblioteca UTFT / biblioteca spfd5408

El Shield está hecho originalmente para las placas Arduino UNO, que se pueden usar con Arduino mega.

Hay dos problemas principales al usarlo con Arduino UNO: "Memoria de almacenamiento" y uso de pines.

Es difícil usar los pines no utilizados que están disponibles en UNO, mientras que es mejor con Arduino MEGA ya que nos quedan más pines de E / S.

En el siguiente paso, mostraré cómo editar la biblioteca UTFT para usar el escudo TFT

Paso 2: Ajustar UTFT Lib

Esta biblioteca es la continuación de mis bibliotecas ITDB02_Graph, ITDB02_Graph16 y RGB_GLCD para Arduino y chipKit. A medida que la cantidad de controladores y módulos de pantalla compatibles comenzó a aumentar, sentí que era hora de crear una biblioteca única y universal, ya que será mucho más fácil de mantener en el futuro.

Arduino MEGA tiene 256 kb de memoria de programa. Además, hay 54 pines.

La mayoría de ellos son de uso gratuito, y los análogos solo 5 se toman de 16.

Esta biblioteca admite una serie de pantallas gráficas de 8 bits, 16 bits y en serie, y funcionará tanto con Arduino, placas chipKit como con determinados LaunchPads de TI.

NOTA: Debido al tamaño de la biblioteca, no recomiendo usarla en ATmega328 (Arduino Uno) y ATmega32U4 (Arduino Leonardo) ya que solo tienen 32 KB de memoria flash. Funcionará, pero estará muy limitado en la memoria flash disponible para su aplicación

Pasos

• Descargue la biblioteca de UTFT
• Descomprime la biblioteca
• Abra UTFT / hardware / avr en el caso de Arduino o dependiendo del microcontrolador utilizado
• Abra HW_AVR_defines usando el Bloc de notas
• Descomente Line 7 para habilitar el escudo UNO para MEGA
• Guarde el archivo y agregue esta biblioteca a Arduino IDE

¡Ahora hemos terminado con este paso! En el siguiente paso, mostraré cómo usar la biblioteca y definir los pines para Arduino Mega.

Paso 3: Inicialización de TFT Shield

Después de editar la biblioteca, agréguela al directorio de Arduino.

A continuación, le mostraré cómo definir el módulo TFT correcto que tiene

deberíamos encontrar su nombre de módulo en la biblioteca.

• abre el archivo de la biblioteca
• ir a la documentación

Puede ver estos archivos en la documentación

• UTFT:

Este archivo muestra todas las funciones y comandos incluidos en esta biblioteca.

• UTFT_Requirement

Este archivo tiene información sobre los módulos y cómo está relacionado con la biblioteca, como configuraciones de pines

• Controlador UTFT_Supported_display_modules _ & _

Este es nuestro objetivo, este archivo tiene los nombres de los módulos y escudos que son compatibles con esta biblioteca, puede ver en él una lista de nombres de módulos y nombres de módulos para la UTFT que debe usar para definir su módulo.

Pasos para definir el TFT:

Abra el archivo de controlador UTFT_Supported_display_modules _ & _ de la biblioteca

• Abra el archivo de controlador UTFT_Supported_display_modules _ & _ de la biblioteca
• Encuentre los modelos para UTFT para los módulos (escudo) que tiene.
• Ahora, para definir una función UTFT en el IDE de Arduino, usamos el comando:

Nombre UTFT (módulo, Rs, Wr, Cs, Rst);

Abra el archivo UTFT_Requirement de la biblioteca

Por el documento, sabemos que los pines están ubicados en los pines A5, A4, A3 y A2.

usamos el comando:

UTFT myGLCD (ITDB28, 19, 18, 17, 16); # tenga en cuenta que los pines 19, 18, 17, 16 en el Arduino Mega

UTFT myGLCD (ITDB28, A5, A4, A3, A2); # tenga en cuenta que los pines A5, A4, A3, A2 en Arduino UNO

¡Y hecho! Ahora puede usar los ejemplos de la biblioteca en el IDE de Arduino con los siguientes cambios.

Paso 4: Hola mundo básico

#include // Declaramos qué fuentes usaremos

extern uint8_t BigFont ; extern uint8_t SevenSegNumFont ; // ¡Recuerde cambiar el parámetro del modelo para que se adapte a su módulo de visualización! UTFT myGLCD (ITDB28, A5, A4, A3, A2); configuración vacía () {myGLCD. InitLCD (); myGLCD.clrScr (); myGLCD.setFont (BigFont); } bucle vacío () {myGLCD.setColor (0, 255, 0); // green myGLCD.print ("HOLA MUNDO", 45, 100); while (verdadero) {}; }

Paso 5: fuentes UTFT

#include // Declaramos qué fuentes usaremos

extern uint8_t SmallFont ; extern uint8_t BigFont ; extern uint8_t SevenSegNumFont ; // Establezca los pines en los correctos para su escudo de desarrollo // ----------------------------------- ------------------------- // Arduino Uno / 2009: // ---------------- --- // Blindaje estándar Arduino Uno / 2009:, A5, A4, A3, A2 // DisplayModule Arduino Uno TFT shield:, A5, A4, A3, A2 // // Arduino Mega: // ----- -------------- // Escudo estándar Arduino Mega / Due:, 38, 39, 40, 41 // CTE TFT LCD / SD Shield para Arduino Mega:, 38, 39, 40, 41 // // ¡Recuerde cambiar el parámetro del modelo para adaptarlo a su módulo de visualización! UTFT myGLCD (ITDB32S, 38, 39, 40, 41); configuración vacía () {myGLCD. InitLCD () myGLCD.clrScr (); } bucle vacío () {myGLCD.setColor (0, 255, 0); myGLCD.setBackColor (0, 0, 0); myGLCD.setFont (BigFont); myGLCD.print ("! \" # $% & '() * +, -. / ", CENTER, 0); myGLCD.print (" 0123456789:;? ", CENTER, 16); myGLCD.print (" @ ABCDEFGHIJKLMNO ", CENTER, 32); myGLCD.print (" PQRSTUVWXYZ ^ _ ", CENTER, 48); myGLCD.print (" `abcdefghijklmno", CENTER, 64); myGLCD.print ("pqrstuvwxyz {|} ~ ", CENTRO, 80); myGLCD.setFont (SmallFont); myGLCD.print ("! / "# $% & '() * +, -. / 0123456789:;?", CENTRO, 120); myGLCD.print ("@ ABCDEFGHIJKLMNOPQRSTUVWXYZ ^ _", CENTRO, 132); myGLCD.print ("` abcdefghijklmnopqrstuvwxyz {|} ~ ", CENTRO, 144); myGLCD.setFont (SevenSegNumFont); myGLCD.print ("0123456789", CENTER, 190); while (1) {}; }

Paso 6: Formas, líneas y patrones UTFT

#include "UTFT.h" // Declaramos qué fuentes usaremos xtern uint8_t SmallFont ; // Establece los pines a los correctos para tu escudo de desarrollo // -------------- ---------------------------------------------- // Arduino Uno / 2009: // ------------------- // Blindaje estándar Arduino Uno / 2009:, A5, A4, A3, A2 // DisplayModule Arduino Uno TFT shield:, A5, A4, A3, A2 // // Arduino Mega: // ------------------- // Estándar Arduino Mega / Due shield:, 38, 39, 40, 41 // CTE TFT LCD / SD Shield para Arduino Mega:, 38, 39, 40, 41 // // ¡Recuerde cambiar el parámetro del modelo para adaptarlo a su módulo de visualización! UTFT myGLCD (ITDB32S, 38, 39, 40, 41); configuración vacía () {randomSeed (analogRead (0)); // Configurar la pantalla LCD myGLCD. InitLCD (); myGLCD.setFont (SmallFont); }

bucle vacío ()

{int buf [318]; int x, x2; int y, y2; int r; // Limpia la pantalla y dibuja el marco myGLCD.clrScr (); myGLCD.setColor (255, 0, 0); myGLCD.fillRect (0, 0, 319, 13); myGLCD.setColor (64, 64, 64); myGLCD.fillRect (0, 226, 319, 239); myGLCD.setColor (255, 255, 255); myGLCD.setBackColor (255, 0, 0); myGLCD.print ("* Biblioteca de pantallas TFT en color universal *", CENTER, 1); myGLCD.setBackColor (64, 64, 64); myGLCD.setColor (255, 255, 0); myGLCD.print ("", CENTRO, 227); myGLCD.setColor (0, 0, 255); myGLCD.drawRect (0, 14, 319, 225); // Dibuja una cruz myGLCD.setColor (0, 0, 255); myGLCD.setBackColor (0, 0, 0); myGLCD.drawLine (159, 15, 159, 224); myGLCD.drawLine (1, 119, 318, 119); para (int i = 9; i <310; i + = 10) myGLCD.drawLine (i, 117, i, 121); for (int i = 19; i <220; i + = 10) myGLCD.drawLine (157, i, 161, i); // Dibujar líneas sin-, cos- y tan-myGLCD.setColor (0, 255, 255); myGLCD.print ("Sin", 5, 15); para (int i = 1; i <318; i ++) {myGLCD.drawPixel (i, 119+ (sin (((i * 1.13) * 3.14) / 180) * 95)); } myGLCD.setColor (255, 0, 0); myGLCD.print ("Cos", 5, 27); para (int i = 1; i <318; i ++) {myGLCD.drawPixel (i, 119+ (cos (((i * 1.13) * 3.14) / 180) * 95)); } myGLCD.setColor (255, 255, 0); myGLCD.print ("Tan", 5, 39); para (int i = 1; i <318; i ++) {myGLCD.drawPixel (i, 119+ (tan (((i * 1.13) * 3.14) / 180))); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); myGLCD.setColor (0, 0, 255); myGLCD.setBackColor (0, 0, 0); myGLCD.drawLine (159, 15, 159, 224); myGLCD.drawLine (1, 119, 318, 119); // Dibuja una onda sinusoidal en movimiento x = 1; for (int i = 1; i319) {if ((x == 159) || (buf [x-1] == 119)) myGLCD.setColor (0, 0, 255); más myGLCD.setColor (0, 0, 0); myGLCD.drawPixel (x, buf [x-1]); } myGLCD.setColor (0, 255, 255); y = 119 + (sin (((i * 1,1) * 3,14) / 180) * (90- (i / 100))); myGLCD.drawPixel (x, y); buf [x-1] = y; } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); // Dibuja algunos rectángulos rellenos para (int i = 1; i <6; i ++) {switch (i) {caso 1: myGLCD.setColor (255, 0, 255); rotura; caso 2: myGLCD.setColor (255, 0, 0); rotura; caso 3: myGLCD.setColor (0, 255, 0); rotura; caso 4: myGLCD.setColor (0, 0, 255); rotura; caso 5: myGLCD.setColor (255, 255, 0); rotura; } myGLCD.fillRect (70+ (i * 20), 30+ (i * 20), 130+ (i * 20), 90+ (i * 20)); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); // Dibuja algunos rectángulos redondeados rellenos para (int i = 1; i <6; i ++) {switch (i) {caso 1: myGLCD.setColor (255, 0, 255); rotura; caso 2: myGLCD.setColor (255, 0, 0); rotura; caso 3: myGLCD.setColor (0, 255, 0); rotura; caso 4: myGLCD.setColor (0, 0, 255); rotura; caso 5: myGLCD.setColor (255, 255, 0); rotura; } myGLCD.fillRoundRect (190- (i * 20), 30+ (i * 20), 250- (i * 20), 90+ (i * 20)); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); // Dibuja algunos círculos rellenos para (int i = 1; i <6; i ++) {switch (i) {caso 1: myGLCD.setColor (255, 0, 255); rotura; caso 2: myGLCD.setColor (255, 0, 0); rotura; caso 3: myGLCD.setColor (0, 255, 0); rotura; caso 4: myGLCD.setColor (0, 0, 255); rotura; caso 5: myGLCD.setColor (255, 255, 0); rotura; } myGLCD.fillCircle (100+ (i * 20), 60+ (i * 20), 30); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); // Dibuja algunas líneas en un patrón myGLCD.setColor (255, 0, 0); para (int i = 15; i <224; i + = 5) {myGLCD.drawLine (1, i, (i * 1.44) -10, 224); } myGLCD.setColor (255, 0, 0); para (int i = 224; i> 15; i- = 5) {myGLCD.drawLine (318, i, (i * 1.44) -11, 15); } myGLCD.setColor (0, 255, 255); para (int i = 224; i> 15; i- = 5) {myGLCD.drawLine (1, i, 331- (i * 1.44), 15); } myGLCD.setColor (0, 255, 255); para (int i = 15; i <224; i + = 5) {myGLCD.drawLine (318, i, 330- (i * 1.44), 224); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); // Dibuja algunos círculos aleatorios para (int i = 0; i <100; i ++) {myGLCD.setColor (random (255), random (255), random (255)); x = 32 + aleatorio (256); y = 45 + aleatorio (146); r = aleatorio (30); myGLCD.drawCircle (x, y, r); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); // Dibuja algunos rectángulos aleatorios para (int i = 0; i <100; i ++) {myGLCD.setColor (random (255), random (255), random (255)); x = 2 + aleatorio (316); y = 16 + aleatorio (207); x2 = 2 + aleatorio (316); y2 = 16 + aleatorio (207); myGLCD.drawRect (x, y, x2, y2); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); // Dibuja algunos rectángulos redondeados aleatorios para (int i = 0; i <100; i ++) {myGLCD.setColor (random (255), random (255), random (255)); x = 2 + aleatorio (316); y = 16 + aleatorio (207); x2 = 2 + aleatorio (316); y2 = 16 + aleatorio (207); myGLCD.drawRoundRect (x, y, x2, y2); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); para (int i = 0; i <100; i ++) {myGLCD.setColor (aleatorio (255), aleatorio (255), aleatorio (255)); x = 2 + aleatorio (316); y = 16 + aleatorio (209); x2 = 2 + aleatorio (316); y2 = 16 + aleatorio (209); myGLCD.drawLine (x, y, x2, y2); } retraso (2000); myGLCD.setColor (0, 0, 0); myGLCD.fillRect (1, 15, 318, 224); para (int i = 0; i <10000; i ++) {myGLCD.setColor (aleatorio (255), aleatorio (255), aleatorio (255)); myGLCD.drawPixel (2 + aleatorio (316), 16 + aleatorio (209)); } retraso (2000); myGLCD.fillScr (0, 0, 255); myGLCD.setColor (255, 0, 0); myGLCD.fillRoundRect (80, 70, 239, 169); myGLCD.setColor (255, 255, 255); myGLCD.setBackColor (255, 0, 0); myGLCD.print ("¡Eso es!", CENTRO, 93); myGLCD.print ("Reiniciando en un", CENTRO, 119); myGLCD.print ("unos segundos …", CENTRO, 132); myGLCD.setColor (0, 255, 0); myGLCD.setBackColor (0, 0, 255); myGLCD.print ("Tiempo de ejecución: (ms)", CENTRO, 210); myGLCD.printNumI (milis (), CENTRO, 225); retraso (10000); }

Paso 7: mapa de bits UTFT

#incluir

#include // Declaramos qué fuentes usaremos extern uint8_t SmallFont ; // Establece los pines en los correctos para tu escudo de desarrollo // ------------------ ------------------------------------------ // Arduino Uno / 2009: / / ------------------- // Escudo estándar Arduino Uno / 2009:, A5, A4, A3, A2 // DisplayModule Arduino Uno TFT shield:, A5, A4, A3, A2 // // Arduino Mega: // ------------------- // Estándar Arduino Mega / Due shield:, 38, 39, 40, 41 // CTE TFT LCD / SD Shield para Arduino Mega:, 38, 39, 40, 41 // // ¡Recuerde cambiar el parámetro del modelo para adaptarlo a su módulo de pantalla! UTFT myGLCD (ITDB32S, A5, A4, A3, A2); información int sin firmar externa [0x400]; icono int sin signo externo [0x400]; extern unsigned int tux [0x400]; void setup () {myGLCD. InitLCD (); myGLCD.setFont (SmallFont); } bucle vacío () {myGLCD.fillScr (255, 255, 255); myGLCD.setColor (255, 255, 255); myGLCD.print ("*** Una cuadrícula de 10 por 7 de un icono de 32x32 ***", CENTRO, 228); para (int x = 0; x <10; x ++) para (int y = 0; y <7; y ++) myGLCD.drawBitmap (x * 32, y * 32, 32, 32, info); retraso (5000); myGLCD.fillScr (255, 255, 255); myGLCD.setColor (255, 255, 255); myGLCD.print ("Dos iconos diferentes en escala 1 a 4", CENTRO, 228); int x = 0; para (int s = 0; s0; s--) {myGLCD.drawBitmap (x, 224- (s * 32), 32, 32, icon, s); x + = (s * 32); } retraso (5000); }

Paso 8: Interfaz de botones

#include #include // Inicializar la pantalla // ------------------ // Establecer los pines a los correctos para su placa de desarrollo // ------- -------------------------------------------------- - // Standard Arduino Uno / 2009 Shield:, 19, 18, 17, 16 // Standard Arduino Mega / Due shield:, 38, 39, 40, 41 // CTE TFT LCD / SD Shield para Arduino Due:, 25, 26, 27, 28 // Teensy 3.x TFT Test Board:, 23, 22, 3, 4 // ElecHouse TFT LCD / SD Shield para Arduino Due:, 22, 23, 31, 33 // // Recuerda ¡Cambie el parámetro del modelo para adaptarlo a su módulo de visualización! UTFT myGLCD (ITDB32S, 38, 39, 40, 41); // Inicializar la pantalla táctil // ---------------------- // Establecer los pines en la posición correcta unos para su placa de desarrollo // ------------------------------------------- ---------------- // Escudo estándar Arduino Uno / 2009: 15, 10, 14, 9, 8 // Escudo estándar Arduino Mega / Due: 6, 5, 4, 3, 2 // CTE TFT LCD / SD Shield para Arduino Due: 6, 5, 4, 3, 2 // Teensy 3.x TFT Test Board: 26, 31, 27, 28, 29 // ElecHouse TFT LCD / SD Shield para Arduino Due: 25, 26, 27, 29, 30 // URTouch myTouch (6, 5, 4, 3, 2); // Declaramos qué fuentes usaremos extern uint8_t BigFont ; int x, y; char stCurrent [20] = ""; int stCurrentLen = 0; char stLast [20] = ""; / ************************ ** Funciones personalizadas ** ********* **************** / void drawButtons () {// Dibuja la fila superior de botones para (x = 0; x <5; x ++) {myGLCD.setColor (0, 0, 255); myGLCD.fillRoundRect (10+ (x * 60), 10, 60+ (x * 60), 60); myGLCD.setColor (255, 255, 255); myGLCD.drawRoundRect (10+ (x * 60), 10, 60+ (x * 60), 60); myGLCD.printNumI (x + 1, 27+ (x * 60), 27); } // Dibuja la fila central de botones para (x = 0; x <5; x ++) {myGLCD.setColor (0, 0, 255); myGLCD.fillRoundRect (10+ (x * 60), 70, 60+ (x * 60), 120); myGLCD.setColor (255, 255, 255); myGLCD.drawRoundRect (10+ (x * 60), 70, 60+ (x * 60), 120); si (x <4) myGLCD.printNumI (x + 6, 27+ (x * 60), 87); } myGLCD.print ("0", 267, 87); // Dibuja la fila inferior de botones myGLCD.setColor (0, 0, 255); myGLCD.fillRoundRect (10, 130, 150, 180); myGLCD.setColor (255, 255, 255); myGLCD.drawRoundRect (10, 130, 150, 180); myGLCD.print ("Claro", 40, 147); myGLCD.setColor (0, 0, 255); myGLCD.fillRoundRect (160, 130, 300, 180); myGLCD.setColor (255, 255, 255); myGLCD.drawRoundRect (160, 130, 300, 180); myGLCD.print ("Entrar", 190, 147); myGLCD.setBackColor (0, 0, 0); } void updateStr (int val) {if (stCurrentLen = 10) && (y = 10) && (x = 70) && (x = 130) && (x = 190) && (x = 250) && (x = 70) && (y = 10) && (x = 70) && (x = 130) && (x = 190) && (x = 250) && (x = 130) && (y = 10) && (x = 160) && (x0) {para (x = 0; x

Paso 9: Flappy Bird

#include #include #include // ==== Creación de objetos UTFT myGLCD (SSD1289, 38, 39, 40, 41); // Los parámetros deben ajustarse a su modelo Display / Schield UTouch myTouch (6, 5, 4, 3, 2); // ==== Definición de fuentes extern uint8_t SmallFont ; extern uint8_t BigFont ; extern uint8_t SevenSegNumFont ; extern unsigned int bird01 [0x41A]; // Bird Bitmapint x, y; // Variables para las coordenadas donde se ha pulsado el display // Floppy Bird int xP = 319; int yP = 100; int yB = 50; int MovingRate = 3; int fallRateInt = 0; flotador fallRate = 0; puntuación int = 0; int lastSpeedUpScore = 0; int HighestScore; booleano screenPressed = falso; boolean gameStarted = false; void setup () {// Iniciar visualización myGLCD. InitLCD (); myGLCD.clrScr (); myTouch. InitTouch (); myTouch.setPrecision (PREC_MEDIUM); puntaje más alto = EEPROM.read (0); // Leer la puntuación más alta de la EEPROM initiateGame (); // Iniciar el juego} void loop () {xP = xP-movingRate; // xP - coordenada x de los pilares; rango: 319 - (-51) drawPilars (xP, yP); // Dibuja los pilares // yB - coordenada y del pájaro que depende del valor de la variable FallRate yB + = fallRateInt; fallRate = fallRate + 0.4; // Cada entrada aumenta la tasa de caída para que podamos el efecto de la aceleración / gravedad fallRateInt = int (fallRate); // Comprueba la colisión if (yB> = 180 || yB <= 0) {// top and bottom gameOver (); } if ((xP = 5) && (yB <= yP-2)) {// pilar superior gameOver (); } if ((xP = 5) && (yB> = yP + 60)) {// pilar inferior gameOver (); } // Dibuja el pájaro drawBird (yB); // Después de que el pilar haya pasado por la pantalla si (xPRESET = 250) && (x = 0) && (y = 0) && (x = 30) && (y = 270) {myGLCD.setColor (0, 200, 20); myGLCD.fillRect (318, 0, x, y-1); myGLCD.setColor (0, 0, 0); myGLCD.drawRect (319, 0, x-1, y); myGLCD.setColor (0, 200, 20); myGLCD.fillRect (318, y + 81, x, 203); myGLCD.setColor (0, 0, 0); myGLCD.drawRect (319, y + 80, x-1, 204); } else if (x puntaje más alto) {puntaje más alto = puntaje; EEPROM.write (0, puntaje más alto); } // Restablece las variables a los valores de posición inicial xP = 319; yB = 50; fallRate = 0; puntuación = 0; lastSpeedUpScore = 0; MovingRate = 3; gameStarted = falso; // Reiniciar el juego initiateGame (); }

Paso 10: Trabajo del proyecto

Puedes encontrar el código fuente en mi repositorio de Github.

Enlace:

Dale un pulgar hacia arriba si realmente te ayudó y sigue mi canal para proyectos interesantes:)

Comparta este video si lo desea.

Feliz de que se haya suscrito:

¡Gracias por leer!