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:

http://youtu.be/3wTuKKyUZSs

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.]

Os voy a dar los pasos a seguir para construir un display de 7 segmentos muy llamativo de una forma cómoda y sencilla. Para ello vamos a construir un dígito de un display siete segmentos con diodos Leds.

Por si el concepto siete segmentos no os es familiar, con la figura que os muestro a continuación lo vais a reconocer enseguida:

Para hacer más atractiva su visualización os voy a enseñar cómo con una electrónica muy básica podéis construir este tipo de displays para vuestro escaparate, tienda o vuestra propia casa a modo de elemento decorativo.

El primer paso y no el más sencillo es comprar los elementos. Para facilitaros este proceso os pongo la lista de todo lo que os hará falta:

• 13 diodos LED
• 13 resistencias
• 1 placa Arduino, podeís hacerlo con cualquier otra pero he elegido esta para facilitar el proceso, puesto que la programación de estos elementos es más simple.Para conectar la placa a vuestro ordenador a través del puerto USB vais a necesitar también un cable de impresora (el que es usb cuadrado)
• 1 placa de circuito perforado, si no os atrevéis con la soldadura podéis montarlo en una Proto-board.
• 1 soldador, sí vais a montarlo soldado
• Estaño, sí vais a montarlo soldado.
• Tira de pines macho hembra, sí vais a montarlo soldado
• 14 latiguillos de conexión, tanto si vais a montarlo soldado cómo si no.

Os incluyo una foto por si no tenéis claro alguno de los materiales a utilizar:

Para ver los elementos con más detalle añado estas fotos también:

Soldador y estaño

Placa perforada

Diodos Leds

Resistencias

Para construir el display lo primero que tenemos que tener claro es el circuito que vamos a montar, para ello os incluyo este pequeño esquema. Imaginemos que cada uno de los puntos de cruce de una línea horizontal y una vertical de la tabla corresponde a una conexión en nuestra placa:

Leyenda:

1.- Montando el circuito:

Una vez que hemos conseguido todos los elementos, los dispondremos en la placa perforada tal como se encuentran en el esquema para soldarlos. Os recomiendo que antes de soldar comprobéis los LEDs (ver la guía sobre encender un LED en este Blog), y midáis las resistencias.

Si es la primera vez que soldáis os recomiendo que sigáis los siguientes consejos:

1. Empezar soldando los elementos más bajos, en este caso las resistencias. Es decir colocar las resistencias y comenzar a soldar.
2. Para soldar es necesario que el soldador esté a temperatura elevada, puedes comprobarlo con el estaño cuando lo funde al colocarlo está a la temperatura correcta.
3. Soldaremos acercando el soldador al punto a soldar, acercaremos el estaño y una vez que la superficie esté cubierta de estaño se retira primero el estaño y después el soldador.

En la foto que aparece a continuación os muestro la manera correcta de colocarse para hacer una correcta soldadura:

Una correcta soldadura debe quedar brillante y sin exceso de estaño.

Para el caso de las líneas de conexión, que haremos con estaño, mi recomendación es aplicar estaño punto a punto y posteriormente ir uniendo los puntos hasta conseguir el camino completo. Os añado una foto por si os sirve de ayuda:

Una vez soldado nuestro circuito quedará tal como se muestra en las dos siguientes fotografías. Una realizada por el reverso y la otra por la parte frontal:

Reverso

Frontal

2.- Comprobando nuestro circuito:

Llegó el momento crucial, vamos a comprobar nuestro montaje:

Para comprobarlo conectaremos cada una de las salidas de nuestra placa a una de las Entradas – Salidas digitales de Arduino. No olvidaros conectar la salida Vcc a la entrada Vcc de Arduino, puesto que si no lo hacemos nuestro circuito quedaría abierto y por tanto no se encendería.

Seleccionaremos un pin cualquiera de Arduino, lo configuraremos y lo mantendremos a uno, tal como se muestra en la foto.

El código necesario para cargar en nuestra placa Arduino y trabajas con el puerto 7 (valdría cualquier otro) es el que os añado a continuación:

Conectaremos uno por uno los LEDS hasta comprobar que todos encienden. En el caso de que alguno no encienda alimentar el LED directamente para saber si es problema de la soldadura o del LED. Una vez solucionado volver a comprobar hasta que todo esté correcto.

Llegado a este punto vamos a conectar todos los LEDS a nuestra placa Arduino, siguiendo la numeración que os indico en el esquema del circuito (visto anteriormente).

A continuación os adjunto un código para que veáis cómo parpadean los LEDS del circuito que vosotros mismos habéis construido:

3.- Enhorabuena:

¡¡¡ Enhorabuena !!! por el trabajo realizado, ahora tenéis un Display con el que podéis hacer todo lo que la imaginación os deje.

Os invito a que veáis el código que os adjunto y explico detalladamente en la sesión cuenta atrás, para que lo carguéis en Arduino y veáis el resultado.

Os adjunto un enlace de un video que os sirva de muestra para ver cómo queda el parpadeo de los LEDS en funcionamiento.

http://www.youtube.com/watch?v=h8zfAhuvF-c&feature=youtu.be