Contador 7 segmentos con dos botones

Estoy de vuelta! Tras los atracones navideños, ya era hora de que publicara algo nuevo y para ello os traigo el primero de una serie de minitutoriales sobre Arduino.

¿Quieres saber como montar un contador con un display de 7 segmentos? Vamos a verlo!

No soy un experto en electrónica pero desde que descubrí el mundo de Arduino cada vez soy más aficionado a ella porque me permite realizar multitud de proyectos de manera fácil y barata. 

Antes de empezar, para los que no sepan que es Arduino, les diré que es una plataforma de hardware libre. Se basan en placas con un microcontrolador y un entorno de desarrollo que permite el uso de componentes electrónicos de forma sencilla. Podemos utilizar todo tipo de sensores (como sensores de  agua, de luz o de infrarrojos), diodos led, pantallas lcd y multitud de componentes para hacer realidad tus proyectos.

Para iniciarme en el mundillo, decidí comprar un kit de arduino, pero en vez del kit original, compré un kit compatible (más baratos) que puedes encontrar en amazon o en mi caso, en dx.com.

Contienen todo lo que necesitas para iniciarte en el mundillo y realizar muchos miniproyectos para ir aprendiendo.

Tras esta pequeña introducción, voy a enseñaros a preparar un contador de siete segmentos manejado con un par de minipulsadores. Es capaz de contar de 0 a 19 (utilizando el punto decimal para contar a partir del 10, es decir, 10 será "0." y 19 será "9."). Al pulsar el botón izquierdo sumaremos uno al contador y pulsando el derecho restaremos uno.

Este es el material que vamos a necesitar:

• Una placa Arduino Uno o compatible.
• Una protoboard
• Un par de minipulsadores
• Resistencias de 220 Ohm
• Un display de 7 segmentos
• Cables para conexion

Antes de nada, hay que aclarar que hay dos tipos de display de 7 segmentos, los de ánodo común y los de cátodo común.

Según el que tengamos (en mi caso es de ánodo común) tendremos que conectar a GND o a VCC cualquiera de los pines centrales y poner los demás pines en alta o baja para encender los segmentos.

El esquema de conexión para nuestro pequeño y sencillo circuito es el siguiente:

Hay un pequeño error en el esquema. Las conexiones de 5V y GND de la placa van a la parte superior derecha (las lineas negativo y positivo) de la protoboard, faltaría puentear la parte izquierda con la derecha para que también estén conectadas a tierra y a 5V. Es importante que montes el circuito sin conectar la placa a la corriente y que revises todo antes.

Como veis, consta de dos pulsadores conectados a las entradas digitales 2 y 4 de la placa arduino, y los pines del display a los pines 6 a 13 de la placa que se corresponden con los 7 segmentos (diodos led) del display mas uno para el punto decimal. No os olvidéis de las resistencias si no queréis freir algún segmento del display.

Una vez el circuito esté montado, pasaremos a cargarle el siguiente código con el entorno de arduino:

int boton1 = 2; //pin del botón 1
int boton2 = 4; //pin del botón 2
int contador=0;

void setup()
{
pinMode(boton1, INPUT); //Entradas de los botones
pinMode(boton2, INPUT);
pinMode(6, OUTPUT); // Asignación de las salidas digitales
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
digito1(contador); //inicializamos el display con el valor inicial del contador.
}

void loop() //Funcion principal
{
int EstadoBoton1 = digitalRead(boton1); //Leemos el estado del botón 1
int EstadoBoton2 = digitalRead(boton2); //Leemos el estado del botón 2

// actualizar contador:
if(EstadoBoton1==1){ //sumamos uno al contador
if(contador<19) contador++; //Siempre que el contador sea menor que 19 (valor máximo)
digito1(contador);
delay(300); // Retraso para mejorar la estabilidad a la hora de las lecturas de los botones
}

if(EstadoBoton2==1){ //restamos uno al contador
if(contador>0) contador--; //siempre que contador sea mayor que 0 (valor mínimo)
digito1(contador);
delay(300); // Retraso para mejorar la estabilidad a la hora de las lecturas de los botones
}
}

void display (int a, int b, int c, int d, int e, int f, int g, int p)
// Funcion del display. Se asignarán el valor recibido a cada pin del display
{
digitalWrite (6,p);
digitalWrite (7,a); //Se reciben 8 variables y se asignan
digitalWrite (8,b); //a cada una de las salidas
digitalWrite (9,c);
digitalWrite (10,d);
digitalWrite (11,e);
digitalWrite (12,f);
digitalWrite (13,g);
}

void digito1(int num){
switch ( num ) {
case 0:
display (0,0,0,0,0,0,1,1); //escribe 0
break;
case 1:
display (1,0,0,1,1,1,1,1); //escribe 1
break;
case 2:
display (0,0,1,0,0,1,0,1); //escribe 2
break;
case 3:
display (0,0,0,0,1,1,0,1); //escribe 3
break;
case 4:
display (1,0,0,1,1,0,0,1); //escribe 4
break;
case 5:
display (0,1,0,0,1,0,0,1); //escribe 5
break;
case 6:
display (0,1,0,0,0,0,0,1); //escribe 6
break;
case 7:
display (0,0,0,1,1,1,1,1); //escribe 7
break;
case 8:
display (0,0,0,0,0,0,0,1); //escribe 8
break;
case 9:
display (0,0,0,1,1,0,0,1); //escribe 9
break;
case 10:
display (0,0,0,0,0,0,1,0); //escribe 10
break;
case 11:
display (1,0,0,1,1,1,1,0); //escribe 11
break;
case 12:
display (0,0,1,0,0,1,0,0); //escribe 12
break;
case 13:
display (0,0,0,0,1,1,0,0); //escribe 13
break;
case 14:
display (1,0,0,1,1,0,0,0); //escribe 14
break;
case 15:
display (0,1,0,0,1,0,0,0); //escribe 15
break;
case 16:
display (0,1,0,0,0,0,0,0); //escribe 16
break;
case 17:
display (0,0,0,1,1,1,1,0); //escribe 17
break;
case 18:
display (0,0,0,0,0,0,0,0); //escribe 18
break;
case 19:
display (0,0,0,1,1,0,0,0); //escribe 19
break;
default:
display (1,1,1,1,1,1,1,0); //escribe punto
break;
}

}

Para comprender un poco el código, tenemos una función llamada digito1, que recibe un entero que es el que pintará en el display. Si no está entre 0 y 19, pintará por defecto un punto. Para encender los leds del display, hace a su vez uso de la función display, donde definimos las señales (ALTA o BAJA) que debemos mandar para encender o apagar cada segmento. Por ejemplo, vemos que para pintar el 1 deberemos poner la señal a BAJA en los segmentos b y c, y en ALTA en los demás segmentos.

En todos lo programas tendremos dos bloques diferenciados: el bloque setup y el bloque loop. En la función setup inicializaremos las entradas y salidas de nuestra placa y todos los componentes que queramos para el inicio del programa. En la función loop implementaremos la lógica del programa. Como su nombre indica, esta función se repite indefinidamente.

En el bloque setup de mi código, inicializo las entradas y salidas digitales de la placa y pinto el display con el valor por defecto del contador, que es el valor 0.

En el bloque loop leemos los estados de los botones, en el caso de que esté alguno pulsado, sumaremos o restaremos uno al contador y volveremos a pintar el display. Añadimos un pequeño retardo en milisegundos (delay) para mejorar la estabilidad de las lecturas porque el bucle se repite muchas veces por segundo. Podéis probar distintos valores y ajustarlo a vuestro gusto.

Y en el siguiente vídeo tenéis el resultado:

Espero que os haya gustado y nos vemos en el siguiente tutorial de Arduino.