por Diseña tu propio código en tú Display
septiembre 18, 2013 en Uncategorized por ZumodeZetas
En este apartado de nuestro blog vamos a generar una cuenta atrás en un Display un tanto peculiar. Os voy a enseñar el resultado lo primero para añadiros ganas de afrontar el proyecto:
Si os gusta la idea, empecemos por el principio, construir este Display tan particular. Para construir el Display debéis seguir paso a paso los consejos dados en el apartado Display.
Una vez realizado el Display, vamos a comenzar a explicar un poco los pasos a seguir para generar una cuenta atrás:
1.- Conseguir cada uno de los números del 0 al 9.
2.- Ser capaz de generar cada número en el momento oportuno.
3.- Mantener cada número encendido el tiempo exacto de un segundo.
La forma más sencilla, desde mi punto de vista, de generar cada número es creando una función por cada número con la configuración de los LED que deben estar encendidos o apagados.
Si no sabéis lo que es una función os lo explico para que entendáis el concepto. Una función es un conjunto de instrucciones a seguir por nuestro programa.
Ya debéis conocer de apartados anteriores la función con la que hemos configurado nuestra placa Arduino para que funcione cómo queremos:
en este caso nos configura los pines que pretendemos usar como salidas.
Tras esta función añadíamos un loop (o ciclo) en el que el programa va a permanecer de forma infinita, a excepción de algún fallo. Nuestro programa va a leer cada una de las líneas del mismo y realizar las instrucciones escritas mientras la placa tenga alimentación. Esta es la función, que también hemos usado anteriormente.
Por si os quedan dudas, imaginaros una receta de cocina, como por ejemplo espinacas con bechamel. Lo primero que haríamos, aunque no aparezca en la receta, es configurar nuestra cocina (Void setup) tener a mano los elementos a utilizar tanto de sarten y otros, cómo ingredientes.
Una vez que hemos configurado la cocina, pasaríamos a la bechamel para lo que estaremos moviendo sin parar los ingredientes en la sartén (Void loop). Mientras preparamos la bechamel, deberemos salir del bucle para cocer las espinacas. Esto significa que dentro de mi bucle (Void loop) deberé llamar a la función “Cocer Espinacas” cuando le toque.
Pues bien, eso es lo que vamos a hacer ahora para nuestra cuenta atrás llamaremos a cada número en su momento.
Os pongo la función para el uno y a modo de ejercicio os dejo pensar el resto de números. De todas formas os añado el código completo al final de la explicación.
Los LEDS que aparezcan con la palabra HIGH los estaremos encendiendo, y los que aparezcan cómo LOW los estaremos apagando.
Para toda función que utilicemos dentro de nuestra función principal (Void loop), debemos Declararla, Llamarla y Definirla.
1.- Definirla: es lo que hemos hecho con la función de uno, es decir escribir el conjunto de instrucciones que vamos a hacer dentro de la misma. (ej: Cuando llamemos a nuestra función cocer espinacas, dentro de ella debemos poner agua en un recipiente apto y ponerla a calentar añadiendo las espinacas y sal al final).
2.- Declararla: se hace al inicio del código al igual que las variables. Se trata de decir a nuestro compilador ¡¡Oye esto existe!!.(ej: Debemos de saber desde el inicio que vamos a cocer espinacas en nuestra receta) .Se haría de la siguiente forma:
int cero (void);
Void setup (){
3.- Llamarla: Dentro de nuestra función principal debemos indicar en el momento que hay que realizar la función. (ej: llegado el momento debemos dar la orden cocer espinaca, que ya conocíamos porque la hemos declarado y que ejecutaremos con las instrucciones que aparecen en su definición).
Void setup(){
variable = cero();
}
Para no cansaros os añado el código completo comentado para que os resulte más simple.
//**********************************************************************************************//
//*************************** CODIGO PARA CUENTA ATRAS *****************************************//
//**********************************************************************************************//
// ************************** DECLARACIÓN DE VARIABLES GLOBALES *******************************//
int cont=0; // Variable contador, para conocer cual es el siguiente número.Inicializada a 0
int llamada=0; // Variable usada para llamar a las funciones
int cero (void); // Declaración de las funciones de cada número
int uno (void);
int dos (void);
int tres (void);
int cuatro (void);
int cinco (void);
int seis (void);
int siete (void);
int ocho (void);
int nueve (void);
//************************************* FIN DECLARION ********************************************//
void setup(){
pinMode (1,OUTPUT); // configuración pines como salida
pinMode (2,OUTPUT);
pinMode (3,OUTPUT);
pinMode (4,OUTPUT);
pinMode (5,OUTPUT);
pinMode (6,OUTPUT);
pinMode (7,OUTPUT);
pinMode (8,OUTPUT);
pinMode (9,OUTPUT);
pinMode (10,OUTPUT);
pinMode (11,OUTPUT);
pinMode (12,OUTPUT);
pinMode (13,OUTPUT);
}
void loop(){
if (cont == 0){ //¿Nuestro contador está a cero?, iniciamos nuestra cuenta.//
// Si no vale cero no entramos a las instrucciones dentro de este if
llamada= nueve(); // Llamamos a la función para encender un 9 en el display
delay (1000); // Esperamos 1 segundo
cont++; // Sumamos 1 a contador, contador pasa a valer 1.
}
if (cont == 1){ //¿Nuestro contador está a uno?. El número anterior era 9, turno del 8.//
// Si no vale uno no entramos a las instrucciones dentro de este if//
llamada= ocho(); // Llamamos a la función para encender un 8 en el display
delay (1000); // Esperamos 1 segundo
cont++; // Sumamos 1 a contador, contador pasa a valer 2.//
}
//***************************** Hacemos lo mismo con el resto de los números **********************//
if (cont == 2){
llamada= siete();
delay (1000);
cont++;
}
if (cont == 3){
llamada= seis();
delay (1000);
cont++;
}
if (cont == 4){
llamada=cinco();
delay (1000);
cont++;
}
if (cont == 5){
llamada= cuatro();
delay (1000);
cont++;
}
if (cont == 6){
llamada= tres();
delay (1000);
cont++;
}
if (cont == 7){
llamada= dos();
delay (1000);
cont++;
}
if (cont == 8){
llamada= uno();
delay (1000);
cont++;
}
if (cont == 9){
llamada= cero();
delay (1000);
cont++;
}
//************************************ FIN DE LA CUENTA ATRAS ***************************************//
//cont=0; //Si queremos que la cuenta a tras se repita de forma continua debemos volver a ponera 0 contador dentro del bucle, en caso de no hacerlo hará la cuenta una vez y se quedará el 0 encendido cuando termine//
}
//*********************************** Función para encender el 0 ***********************************//
int cero (void){
digitalWrite (1, HIGH); //Encender los LEDS 1,2 .... 9
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, HIGH);
digitalWrite (7, HIGH);
digitalWrite (8, HIGH);
digitalWrite (9, HIGH);
digitalWrite (10, LOW); //Apagar el LED 10
digitalWrite (11, HIGH); //Encender los LED 11, 12 y 13
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0; //Volver al código principal en Void loop en el punto en que lo habíamos dejado.
}
//*********************************** Función para encender el 1 ***********************************//
int uno (){
digitalWrite (1, HIGH);
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, LOW);
digitalWrite (7, LOW);
digitalWrite (8, LOW);
digitalWrite (9, LOW);
digitalWrite (10, LOW);
digitalWrite (11, LOW);
digitalWrite (12, LOW);
digitalWrite (13, LOW);
return 0;
}
//*********************************** Función para encender el 2 ***********************************//
int dos (){
digitalWrite (1, HIGH);
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, LOW);
digitalWrite (5, HIGH);
digitalWrite (6, HIGH);
digitalWrite (7, HIGH);
digitalWrite (8, HIGH);
digitalWrite (9, HIGH);
digitalWrite (10, HIGH);
digitalWrite (11, LOW);
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0;
}
//*********************************** Función para encender el 3 ***********************************//
int tres (){
digitalWrite (1, HIGH);
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, HIGH);
digitalWrite (7, HIGH);
digitalWrite (8, LOW);
digitalWrite (9, HIGH);
digitalWrite (10, HIGH);
digitalWrite (11, LOW);
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0;
}
//*********************************** Función para encender el 4 ***********************************//
int cuatro (){
digitalWrite (1, HIGH);
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, LOW);
digitalWrite (7, LOW);
digitalWrite (8, LOW);
digitalWrite (9, HIGH);
digitalWrite (10, HIGH);
digitalWrite (11, HIGH);
digitalWrite (12, HIGH);
digitalWrite (13, LOW);
return 0;
}
//*********************************** Función para encender el 5 ***********************************//
int cinco (){
digitalWrite (1, HIGH);
digitalWrite (2, LOW);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, HIGH);
digitalWrite (7, HIGH);
digitalWrite (8, LOW);
digitalWrite (9, HIGH);
digitalWrite (10, HIGH);
digitalWrite (11, HIGH);
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0;
}
//*********************************** Función para encender el 6 ***********************************//
int seis (){
digitalWrite (1, HIGH);
digitalWrite (2, LOW);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, HIGH);
digitalWrite (7, HIGH);
digitalWrite (8, HIGH);
digitalWrite (9, HIGH);
digitalWrite (10, HIGH);
digitalWrite (11, HIGH);
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0;
}
//*********************************** Función para encender el 7 ***********************************//
int siete (){
digitalWrite (1, HIGH);
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, LOW);
digitalWrite (7, LOW);
digitalWrite (8, LOW);
digitalWrite (9, LOW);
digitalWrite (10, LOW);
digitalWrite (11, LOW);
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0;
}
//*********************************** Función para encender el 8 ***********************************//
int ocho (){
digitalWrite (1, HIGH);
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, HIGH);
digitalWrite (7, HIGH);
digitalWrite (8, HIGH);
digitalWrite (9, HIGH);
digitalWrite (10, HIGH);
digitalWrite (11, HIGH);
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0;
}
////*********************************** Función para encender el 9 ***********************************//
int nueve (){
digitalWrite (1, HIGH);
digitalWrite (2, HIGH);
digitalWrite (3, HIGH);
digitalWrite (4, HIGH);
digitalWrite (5, HIGH);
digitalWrite (6, LOW);
digitalWrite (7, LOW);
digitalWrite (8, LOW);
digitalWrite (9, HIGH);
digitalWrite (10, HIGH);
digitalWrite (11, HIGH);
digitalWrite (12, HIGH);
digitalWrite (13, HIGH);
return 0;
}
Por último os propongo que programéis una cuenta adelante. Pista: solo tendríamos que cambiar la condición del valor del contador.
Si no os funciona la cuenta hacia delante, no os preocupeís, porque en el código para comunicarnos con el puerto serie (apartado PUERTO SERIE del blog) podremos elegir con nuestro teclado del ordenador si queremos una cuenta hacía delante o hacía atrás.
[NOTA: Este último código estará publicado a partir del 30/09/2013.]
Comentarios recientes