Dígitos personalizados

Retomamos un tema anterior y realizamos caracteres personalizados para el contador de vidas del Pinball, de modo que en lugar de aparecer palabras, aparecerán figuras simbolizando las vidas del jugador. Me costó el implementar correctamente lo programado con los caracteres personalizados, pero se pudo. Formar los dígitos personalizados fue algo más fácil.

Así quedó el sketch:

#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
int pinFotocelda=A0;
int vidas=3;
byte corazon_izq[8]={0b00000000,
0b00000001,
0b00000011,
0b00000011,
0b00000001,
0b00000000,
0b00000000
 };

byte corazon_der[8]={ 0b00000000,
0b00000000,
0b00000010,
0b00010111,
0b00011111,
0b00011110,
0b00011100,
0b00001000
 };

void setup() {
  pinMode(pinFotocelda,INPUT);
  lcd.begin(16, 2);
  lcd.createChar(1,corazon_izq);
  lcd.createChar(2,corazon_der);

}



void loop() {
  int dato=analogRead(pinFotocelda);
  delay(1000);
  if(dato<300)
  {
    vidas=vidas-1;
  }
  if(vidas==0)
  {
    lcd.clear();
    lcd.setCursor(1, 1); 
    lcd.print("¡JUEGO FINALIZADO!");
    vidas=3;
  }
   lcd.setCursor(0, 0);
   printVidas();
}


void printVidas(){
  if(vidas==3)
  {
    lcd.clear();
    lcd.write(1);
    lcd.write(2);

    lcd.write(1);
    lcd.write(2);

    lcd.write(1);
    lcd.write(2);
  }
  else if(vidas==2){
 
  }

}

uwuwuwuwuwuwuwuwuwuwuw (esto es un separador)


#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
int pinFotocelda=A0;
int vidas=3;
byte corazon_izq[8]={0b00000000,
0b00000000,
0b00000001,
0b00000011,
0b00000011,
0b00000001,
0b00000000,
0b00000000,
0b0000000

 };

byte corazon_der[8]={ 0b00000000,
0b00000000,
0b00000010,
0b00010111,
0b00011111,
0b00011110,
0b00011100,
0b00001000,
0b0000000

 };

void setup() {
  pinMode(pinFotocelda,INPUT);
  lcd.begin(16, 2);
  lcd.createChar(1,corazon_izq);
  lcd.createChar(2,corazon_der);

}



void loop() {
  int dato=analogRead(pinFotocelda);
  delay(1000);
  if(dato<300)
  {
    vidas=vidas-1;
  }
  if(vidas==0)
  {
    lcd.clear();
    lcd.setCursor(1, 1); 
    lcd.print("¡JUEGO FINALIZADO!");
    vidas=3;
  }
   lcd.setCursor(0, 0);
   printVidas();
}


void printVidas(){
  if(vidas==3)
  {
    lcd.clear();
    lcd.write(1);
    lcd.write(2);

    lcd.write(1);
    lcd.write(2);

    lcd.write(1);
    lcd.write(2);
  }
  else if(vidas==2){
 
  }

}

Al final, supuse que para implementar o crear cualquier figura como un carácter personalizado, la clave estaría en tener una disposición clara tanto de la figura como del display donde se vaya a mostrar.

Codificación con dígitos personalizados (corregido)

Estudiamos los errores e implementamos lo aprendido en clases pasadas para componer el sketch para el contador de puntos del pinball, e incluimos otros factores que afectarían la puntuación del jugador, como la rampa y el túnel.

 Se me dificultó mucho el implementar todos los componentes para el pinball en este sketch. Sin embargo, se pudo lograr, y ahora tengo una mejor comprensión de distintos elementos, como los operadores de comparación y los condicionales en programación, así como de las partes que forman el juego.
Todavía me pregunto sobre la mejor manera de unir todos los componentes en el pinball, pero planeando distintas variantes podría llegar a la mejor opción.

 El resultado fue éste:

#include <LiquidCrystal.h>
LiquidCrystal displei(12, 11, 5, 4, 3, 2);

int pinFotocelda=A0;
int pinTunel=A1;
int pinRampa=A2;
int vidas=3;
int puntos=0;
byte corazon_izq[8]={0b00000100,
0b00000001,
0b00000011,
0b00000011,
0b00000001,
0b00000000,
0b00000000
};
byte corazon_der[8]={0b00000000,
0b00000000,
0b00000010,
0b00010111,
0b00011111,
0b00011110,
0b00011100,
0b00001000
};
   void setup() {
   displei.begin(16, 2);
   pinMode(pinFotocelda,INPUT);
   pinMode(pinTunel, INPUT);
   pinMode(pinRampa, INPUT);
   displei.createChar(1,corazon_izq);
   displei.createChar(2,corazon_der);
}

void loop() {
   int datoTunel=analogRead (pinTunel);
   int datoRampa=analogRead(pinRampa);
   int dato=analogRead(pinFotocelda);
   delay(1000);
   if(dato<600)
   {
    vidas=vidas-1;
   }
   if(vidas==0)
   {
  displei.clear();
  displei.setCursor(0,0);
  displei.print("Como que perdiste D:");
  delay(5000);
  vidas=3;
}
/*void mensajePerdiste(){
  displei.clear();
  displei.setCursor(0,0);
  displei.print("Como que perdiste D:");
  delay(5000)
  ;vidas=3;
}*/
  displei.setCursor(0,0);
  printVidas();
  int pinTunel=analogRead(pinTunel);
  int pinRampa=analogRead(pinRampa);
   delay(500);
   if(datoTunel<600)
{
    puntos=puntos+30;
}
   if(datoRampa<600)
   {
     puntos=puntos+20;
   }
   if(puntos>=100)
   {
  displei.clear();
  displei.setCursor(0,0);
  displei.print("¡Muy bien!");
  delay(5000);
  puntos=0;
  }
  displei.setCursor(12,0);
  displei.print(puntos);

}
void printVidas(){
  if(vidas==3)
{
  displei.clear();
  displei.write(1);
  displei.write(2);

  displei.write(1);
  displei.write(2);
}
}

Contador de vidas para el Pinball #2

Se corrigió el sketch anterior para el contador de vidas para el Pinball. La dificultad se presentó cuando escribía la programación, porque, a pesar de verificar lo escrito algunas veces, se presentaba un error en la revisión. De todas formas, pude aprender a corregir el sketch anterior y a vislumbrar que se podía cambiar.

 Quedó así:

#include <LiquidCrystal.h>
LiquidCrystal displei(12, 11, 5, 4, 3, 2);
int pinFoto=A0;
int vidas=3;
void setup() {
 pinMode(pinFoto,INPUT);
 displei.begin(16,2);
}
void loop() {
int dato=analogRead(pinFotocelda);
delay(1000);
if(dato<300)
{
  vidas=vidas-1;
}
if(valor==0)
{
 displei.clear();
 displei.setCursor(0,0);
 displei.print("Game Over");
 delay(5000);
 vidas=3;
}
 displei.setCursor(0,0);
 displei.print("Vidas = ")
 displei.print(vidas);

Además de la corrección, profundizamos en los operadores de comparación, que son utilizados para contrastar y verificar datos, como también para condicionar acciones. En este caso, para representar que un dato era menor que 300 como condición, se utilizó el símbolo "<", y se escribió el siguiente enunciado: if(dato<300)

Aquí un tabla con distintos operadores de comparación:


Podría decirse que el contador está mejor estructurado, pero creo que sería necesario instruirme en el lenguaje de programación para poder dar fundamento a las actividades que se realizan en clase.

Fuentes:

• AulaFacil. (2019). Operadores de comparación. Recuperado de https://www.aulafacil.com/uploads/cursos/1537/editor/programacion-en-c-lecc9.png

Contador de vidas para el Pinball #1

Aprendimos a programar el contador de vidas para el pinball, que usaremos para registrar las vidas que el jugador va perdiendo hasta que se acaban, y se reinician automáticamente para empezar un juego nuevo. Al no conocer ciertos elementos de programación, se me dificultó el entender la actividad, pero después de una explicación pude comprender sus funciones.

 El resultado final fue éste:

#include <LiquidCrystal.h>

LiquidCrystal displei(12, 11, 5, 4, 3, 2);

int pinFoto=A0;

int vidas=3;

void setup() {

 pinMode(pinFoto,INPUT);

 displei.begin(16,2);

}

void loop() {

int valor=analogRead(pinFoto);

if(1000<100)

{

  vidas=vidas-1;

}

if(valor==0)

{

 displei.clear();

 displei.setCursor(0,0);

 displei.write("");

  vidas=3;

}

Nota: Éste sketch cambiará más adelante, pues hay detalles que deben agregarse y aspectos por mejorar, al igual que mucho errores por corregir. 

¿Qué es un contador?

Un contador se basa en una variable cuyo valor cambia a otro valor definido. En este caso, si el dato registrado por la fotocelda es menor a un valor predeterminado, se resta una vida de las que tiene el jugador, hasta que se acaban y el juego empieza de nuevo (esto debido a que antes de programar el contador se agregó “void loop() {”). La variable es las vidas del jugador.

¿Qué es la sentencia IF?

Es un condicional en programación. Los condicionales en programación funcionan de manera que una acción puede ser únicamente ejecutada si la condición la determina correcta (o verdadera).

La sentencia IF hace que una acción sea ejecutada solo si la condición se cumple.

Para el contador del juego, la condición es que el dato registrado por la fotocelda sea menor a un valor determinado con anterioridad (condición que se cumple cuando la pelota del pinball cae por entre las flippers), y la acción es la resta de una de las vidas del jugador. 

  

Fuentes:

• Pes, C. (2019). Definición de Variable Contador. Recuperado de http://www.carlospes.com/minidiccionario/variable_contador.php

• Palomares, F. [kiko Palomares]. (2019, Febrero 18). La Sentencia IF - Condicionales en programación [Diccionario del PROGRAMADOR]. Recuperado de https://www.youtube.com/watch?v=jDPtfCJfdSM