Diseñando un reloj digital con displays 7 segmentos

Existen varias configuraciones para manipular los displays de 7 segmentos cuando se desea realizar proyectos. En esta ocasión, estaremos mostrando algunas de estas configuraciones indicando las ventajas y desventajas de cada configuración y se diseñará un reloj digital con la más adecuada (según los criterios del autor).

Se asume que los displays 7 segmentos están controlados por un microcontrolador que se encuentra en el módulo Arduino.  

1. Conexión directa

Aquí se conecta el display directamente a los pines del microcontrolador. Este display puede ser de ánodo común o de cátodo común. En la figura 1 se muestra la conexión del display de cátodo común.

Figura 1. Conexión directa

En esta conexión se consumen 7 pines del uC por display. Para el reloj digital necesitamos 6 displays, entonces estaríamos requiriendo un uC de 6 x 7 = 42 pines. Esto sería un desperdicio de pines y de potencia, ya que cada pin maneja entre 20 a 30 mA entonces para 42 pines la potencia media consumida sería 25mA X 42 = 1.05 A. (lo cual es bastante para un uC).

Solo se podría usar 1 ó 2 displays con esta configuración, pero la programación sería más sencilla.  

2. Multiplexión en paralelo

Aquí se conectan varios displays en paralelo en un mismo puerto que puede ser el A0 - A7 y la tierra o alimentación de los displays se conectan a transistores bipolares que funcionan como interruptores, activando sólo un display por un periodo de tiempo pequeño. Este periodo tiene que ser menor a la persistencia visual tp < 100ms. La configuración se muestra en la figura 2.

Figura 2. Conexión directa en paralelo.

La ventaja de esta configuración es que se pueden usar más displays pero se utiliza un pin adicional por cada display, además de los pines de un puerto, digamos A0 - A7. Por otro lado, la programación es un poco más compleja.

3. Conexión en serie

 

Esta conexión es útil cuando se desea trabajar con cantidades mayores de displays usando un uC que tiene pocos pines de entrada/salida. En este caso se usan sólo 2 pines para controlar un gran número de displays conectados en serie (tipo cascada). Uno de los pines es el pin de datos y el otro es el pin de reloj usado para el desplazamiento de los datos. Esta configuración se ve en la figura 3.

Figura 3. Conexión en cascada.

 

La ventaja de esta conexión es que se puede manejar mayor cantidad de displays que la multiplexión en paralelo (el número puede superar sobradamente los 10 displays), pero la desventaja es que se tiene que usar ICs adicionales para cada display (como los registros de desplazamiento y los arreglos de transistores), encareciendo un poco el proyecto. La programación también es un poco más compleja.

 

DISEÑO DEL RELOJ DIGITAL

 

Nuestro reloj digital tendrá 6 displays y tres botones/interruptores de nivelación. Entonces se usará la 3ra. configuración o la conexión serial para implementar este proyecto. El diagrama circuital del reloj se muestra en la figura 4.

Figura 4. Reloj completo

En la figura 4 se observa que se usan 6 pines de salida (dos para las horas, dos para los minutos y dos para los segundos) y 3 pines de entrada (dos botones de nivelación y un interruptor de selección entre minutos y horas). El programa del arduino implementado se muestra a continuación:

Programa de control

//control de display de 7 segmentos //implementación del reloj digital //Oscar Carrión P. Fecha: 2022-02-03 #define boton_a 8 #define boton_b 9 #define select 10 int num_serie = 0; int seg = 0, minu = 10, hrs = 10; //contador de los digitos del reloj byte digito; bool show = false; //variable para habilitar la escritura serial void setup() { DDRD = 0xff; //El puerto 0-7 como salida pinMode(boton_a,INPUT); pinMode(boton_b,INPUT); pinMode(select,INPUT); //configuracion del timer 1 segundo TCCR1A = 0;// registro de configuracion TCCR1B = 0;// registro de configuracion TCNT1 = 0;// contador del timer1 (16 bits) empieza a contar en 0 // establece el registro de comparacion para que demore un tiempo dado. OCR1A = 15617;// = (16*10^6) / (1.0005*1024) - 1 para .9995 s // seleccion de Modo de comparacion CTC y borrado de temporizador TCCR1B |= (1 << WGM12); // Set CS11 bit for 1024 prescaler TCCR1B |= (1 << CS12) | (1 << CS10); // enable timer compare interrupt TIMSK1 |= (1 << OCIE1A); } //mapeo de los numeros decimales a 7 seg. int mapea_numero(int n) { //mapeo de 0 a 9 en lazo ->gfedcba switch(n) { case 0: digito = B00111111; break;//0 case 1: digito = B00000110; break;//1 case 2: digito = B01011011; break;//2 case 3: digito = B01001111; break;//3 case 4: digito = B01100110; break;//4 case 5: digito = B01101101; break;//5 case 6: digito = B01111101; break;//6 case 7: digito = B00000111; break;//7 case 8: digito = B01111111; break;//8 case 9: digito = B01101111; break;//9 } return digito; } //transmision serial del los datos mapeados void envio_serial(int number, int pinout, int clkout, int len) { for (int x = (8*len)-1; x >= 0; x--) //empieza por el bit mas significativo { boolean b = bitRead(number, x); switch(b) //escritura del dato { case 0: //si el bit es 0 digitalWrite(pinout, LOW); //la salida del dato es 0 break; case 1: //si el bit es 1 digitalWrite(pinout, HIGH); //la salida del dato es 1 break; } // reloj para desplazamiento digitalWrite(clkout, HIGH); //el reloj hace medio ciclo alto delayMicroseconds(5); digitalWrite(clkout, LOW); //y medio ciclo bajo delayMicroseconds(5); // el ciclo total demora 10us } // tiempo total de envio de digitos seriales es: 10us x b bits = 160us } //Configuracion del reloj (exacto) ISR(TIMER1_COMPA_vect) {//timer1 interrupt 1Hz cli(); seg++; //contador de los segundos show = true; //muestra los digitos del reloj if (seg == 60) //reinicio del conteo decimal { seg = 0; minu++; if (minu == 60) { minu = 0; hrs++; if (hrs == 24) hrs = 0; } } sei(); } //programa principal void loop() { int dd, du; //digitos de decenas y unidades //ENVIO SERIAL DE LOS DATOS if(show) { //division de los segundos y mapeo dd = seg / 10; dd = mapea_numero(dd); //decenas du = seg % 10; du = mapea_numero(du); //unidades num_serie = (dd<<8) + du; //se conforma el numero mapeado envio_serial(num_serie,0,1,2); //se envia los segundos por el puerto A1 //division de los minutos y mapeo dd = minu / 10; dd = mapea_numero(dd); //decenas du = minu % 10; du = mapea_numero(du); //unidades num_serie = (dd<<8) + du; //se conforma el numero mapeado envio_serial(num_serie,2,3,2); //se envia los minutos por el puerto A2 //division de las horas y mapeo dd = hrs / 10; dd = mapea_numero(dd); //decenas du = hrs % 10; du = mapea_numero(du); //unidades num_serie = (dd<<8) + du; //se conforma el numero mapeado envio_serial(num_serie,4,5,2); //se envia las horas por el puerto A3 show = false; //se deshabilita el envio serial } //toda la muestra demora 0.48 ms por segundo //boton ascendente test_1: if (digitalRead(boton_a) == HIGH){ delay(20); //tiempo antirrebote if (digitalRead(boton_a) == HIGH) goto test_1; else { if (digitalRead(select) == LOW) { minu++; //incrementa numero minutos if(minu > 59) minu = 0; } else { hrs++; //incrementa numero minutos if(hrs > 24) hrs = 0; } } } //boton descendente test_2: if (digitalRead(boton_b) == HIGH){ delay(20); //tiempo antirrebote if (digitalRead(boton_b) == HIGH) goto test_2; else { if (digitalRead(select) == LOW) { minu--; //incrementa numero minutos if(minu < 0) minu = 59; } else { hrs--; //incrementa numero minutos if(hrs <0) hrs = 23; } } } }  

Comentarios acerca del programa: 

• En la función setup, además de configurar los pines de entrada y salida usados también se configura el Timer1 para que cuente cada segundo. El timer1 es de 16 bits y comienza a contar en 0. Cuando el contador llega al valor de OCR1A, la cuenta se reinicia a 0 y se produce una interrupción interna. El valor de OCR1A se determina de acuerdo a la siguiente fórmula:

$OCR1A=\frac{f_{OSC}\times T_p}{Prescaler}-1$

En esta ecuación, fosc es la frecuencia de oscilación del Arduino UNO que es típicamente 20 MHz.

El prescalador divide esta frecuencia haciendo que el temporizador cuente más lento. En este caso particular el prescalador se configura con 1024.

Tp es el tiempo deseado en segundos.

 

• Cuando se produce la interrupción interna el programa salta a la función de interrupción ISR(TIMER1_COMPA_vect) y ejecuta lo que esta dentro de la función. Dentro de esta función se incrementa la cuenta de segundos, minutos y horas. Cuando termina la ejecución de la función, el vector del programa vuelve donde se quedó, en algún punto del programa principal (void loop()).
  

 

Simulación del proyecto

Se probó el correcto funcionamiento del proyecto usando el programa de simulación de circuitos SimulIDE, el cual es un software libre con capacidad de simular microcontroladores y tarjetas embebidas como el Arduino. Dejo el enlace en el nombre para más información.

Los resultados de la simulación del proyecto se pueden apreciar en el siguiente video. Para mayores detalles también pueden revisar los vídeos relacionados en las sugerencias al final del vídeo. Estos vídeos tratan acerca del desarrollo del proyecto paso a paso y acerca de la utilización del software.

$\mathrm{}$

 

 

Gracias por ver este tutorial, espero vuestros comentarios. Todos los derechos de autor están reservados.