Con esta conexión se obtendrán los valores registrados por una Fotocelda en distintos momentos del día, como en la mañana, el medio día, por la tarde y por la noche, para ser implementados en el nuevo proyecto, el sistema de riego automático.
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int pinFoto=A0;
void setup() {
pinMode(pinFoto,INPUT);
lcd.begin(16, 2);
}
void loop() {
int dato=analogRead(pinFoto);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(dato);
}
martes, 12 de noviembre de 2019
martes, 24 de septiembre de 2019
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.
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);
}
}
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);
}
}
viernes, 13 de septiembre de 2019
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:
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
martes, 10 de septiembre de 2019
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
martes, 28 de mayo de 2019
Reflexión fin del parcial
Reflexión fin del parcial
Con este parcial aprendí muchas cosas. Tuve que instruirme sobre nuevas formas de trabajo y aprender con mis compañeros a lo largo del desarrollo de nuestro proyecto. Si bien se me dificultó al inicio, he progresado en cuanto hemos trabajado en este parcial, y reconozco que todavía tengo que mejorar mi desempeño en las clases de Informática.
La actividad principal en este parcial se refiere a la etapa de Indagación y Análisis de nuestro proyecto. Esta etapa se enfocó, como lo dice su nombre, en la investigación y análisis previo a la fabricación del juego de Pinball, en la cual trabajamos en un documento compartido los distintos aspectos del proyecto y planeamos su producción acorde al Ciclo de Diseño. En esta etapa aprendí mucho acerca del programa del Bachillerato Internacional y sus métodos para desarrollar este tipo de proyectos, así como los requisitos y lineamientos fijados para presentar documentos y otros archivos, al igual que al trabajar con diversas herramientas para desarrollar nuevas habilidades.
En cuanto a los atributos del perfil IB, podría concluir que desarrollé una actitud indagadora, pues tuve que recolectar cuanta información podía para no quedarme atrás en las actividades, incluyendo lo que ya sabía, abriendo paso a nuevas ideas y herramientas. Considero que, respecto a las habilidades de enfoques del aprendizaje, las habilidades de investigación y de pensamiento cumplieron un papel importante en mi desempeño en este primer parcial, pues en muchos aspectos estuvieron presentes y me ayudaron a desarrollar el proyecto.
Logré avanzar con mis metas en esta primera etapa. Redactar y buscar información llega a parecer tedioso, pero no se interpone en el esfuerzo que brindamos para lograr un resultado satisfactorio. Tengo presente mis errores y los aspectos que debo y puedo mejorar, así como mi meta de aprender lo mas que pueda de mis profesores y compañeros.
En cuanto a los atributos del perfil IB, podría concluir que desarrollé una actitud indagadora, pues tuve que recolectar cuanta información podía para no quedarme atrás en las actividades, incluyendo lo que ya sabía, abriendo paso a nuevas ideas y herramientas. Considero que, respecto a las habilidades de enfoques del aprendizaje, las habilidades de investigación y de pensamiento cumplieron un papel importante en mi desempeño en este primer parcial, pues en muchos aspectos estuvieron presentes y me ayudaron a desarrollar el proyecto.
Logré avanzar con mis metas en esta primera etapa. Redactar y buscar información llega a parecer tedioso, pero no se interpone en el esfuerzo que brindamos para lograr un resultado satisfactorio. Tengo presente mis errores y los aspectos que debo y puedo mejorar, así como mi meta de aprender lo mas que pueda de mis profesores y compañeros.
martes, 21 de mayo de 2019
Suscribirse a:
Comentarios (Atom)