En efecto podemos construir nosotros mismos nuestros propios Display de  leds  de la medidas que necesitemos  simplemente con una placa Arduino  ( y todos  su derivados) o una  Raspberry Pi ( y todos su clónicos y derivados ) y !por supuesto  un poco de bricolaje!

Un dígito led  en realidad esta formado por  7 segmentos  o mas   y es un componente que se utiliza para la representación de caracteres o números en muchos dispositivos, debido en gran medida a su simplicidad y bajo coste

Aunque externamente difiere considerablemente de un led típico, internamente están constituidos por una serie de leds con unas determinadas conexiones internas, estratégicamente ubicados de tal forma que forme un número ‘8’.

Por ejemplo para representar el numero 15 lo conseguiremos , activando los segmentos B y C del primer dígito  y  los segmentos AF,G C y D  para el segundo dígito

 

 

En la imagen podemos ver el desmontaje de la estructura interna de un display led de 4 cifras comercial, apreciándose unos puntos minúsculos que en realidad son leds SMD (lo demás es un plástico difusor que se coloca encima).

Los displays de 7 segmentos pueden ser de dos tipos principales: ánodo común y cátodo común. En un display de ánodo común, todos los ánodos de los segmentos están conectados juntos y cada segmento se activa encendiendo el cátodo correspondiente. En un display de cátodo común, todos los cátodos están conectados juntos (es decir el positivo) y cada segmento se activa encendiendo el ánodo correspondiente (o negativo). La elección entre estos tipos depende del diseño del circuito y las preferencias del diseñador, pero es obvio que sólo no son compatibles unos modelos con otros especialmente en el aspecto de que sean de cátodo o ánodo común.

En la siguiente imagen mostramos un display muy conocido ( el 5643BS) de ánodo común y que usaremos en la reparación de una olla de cocción lenta. Claramente lo importante es destacar la correspondencia de los pines : los 7 segmentos A,B,C,D,E, F (que se conectan a negativo) y las 4 cifras: D1,D2,D3 y D4 ( que se conectan al positivo común de cada cifra ).

Existen dos diferentes métodos para controlar los displays de 7 segmentos:

• • Multiplexación: Esta técnica implica alternar rápidamente los dígitos mostrados, creando la ilusión de visualización simultánea de múltiples dígitos. Esta técnica es la mas comúnmente utilizada en casi todos los electrodomésticos serie blanca. Es especialmente habitual cuando usamos microcontroladores pues se necesitan mucha menos electrónica para su control (normalmente 7 segmentos mas 1 línea más por cada cifra) .
  • Decodificadores BCD: Los decodificadores BCD convierten datos binarios en señales de control específicas para activar los segmentos individuales, representando así el número deseado.

 

Montaje

Ahora que entendemos como funciona un display de 7 segmentos, la idea  es realmente sencilla  pues básicamente  consiste en auto-construirnos  dicho dígito  pensando en los  7 segmentos    de los que lo compone   usando para ellos  7 leds  acoplados a un caja  con    difusores para todos los leds  ¿sencillo verdad ?

Para el montaje  necesitaremos los siguientes elementos:

• Trozos de cartón
• Trozos de cartulina
• 7 LEDs difusa
• 7 resistencias de 50 ohm
• Cinta carrocera (usada por los pintores )
• Pegamento
• Soporte con Esquema del display
• Cables
• Arduino uno
• Un trozo de papel contacto

Una vez que tengamos el dígito compuesto por 7 los leds lo conectaremos a 7 salidas binarias de Arduino  siguiendo el siguiente esquema de conexiones;

• PD2  segmento a;
• PD3 segmento b
• PD4 segmento c
• PD5 segmento d
• PD6 segmento e
• PD7 segmento f
• PD8 segmento g

Y para facilitar la gestión del display  también dos pulsadores ( para avanzar o retroceder en el conteo):

•  PP1
• PB2

Y finalmente   en la siguiente imagen podemos ver el esquema donde se aprecian claramente las resistencias de 50ohm para los leds   y las de 10 K para los pulsadores.

 

 

Según la configuración ya decidida  para gestionar el display solo necesitamos mapear  cada combinación  de segmentos asociado a cada numero que queramos representar  ,  y por medio delos pulsadores incrementamos o decrementamos una unidas representando el siguiente o el anterior digito respectivamente

Como en muchos otros casos ,es de señalar que debemos controlar los rebotes en las pulsaciones para lo cual leeremos varias veces el valor de la entrada hasta asegurarnos que el valor esta estables.

Y finalmente en este vídeo  podemos ver el proceso constructivo al mas estilo casero y el sencillo  montaje en funcionamiento:

Veamos el código para nuestro proyecto

El código Arduino es bien sencillo:

//definiciones de segmentos con las primeras pines digitales puerto A

const int a = 2;
const int b = 3;
const int c = 4;
const int d = 5;
const int e = 6;
const int f = 7;
const int g = 8;

//Definición de pines de entrada para los pulsadores
const int botonIncremento = 9;
const int botonDecremento = 10;

//valor para controlar los antirrebotes

const int tiempoAntirebote = 10;

//Al encender parece este numero

int cuenta = 0;  
int estadoBotonIncremento;
int estadoBotonAnteriorIncremento;
int estadoBotonDecremento;
int estadoBotonAnteriorDecremento;

boolean antirebote(int pin) {
int contador = 0;
boolean estado;
boolean estadoAnterior;

do {
estado = digitalRead(pin);
if(estado != estadoAnterior) {
contador = 0;
estadoAnterior = estado;

}
else {
contador = contador + 1;
}
delay(1);
} while(contador < tiempoAntirebote);

return estado;

}

void actualizarNumero() {
switch(cuenta) {
case 0:     // digito 1
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
break;

case 1:// valor 2

digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 2:
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
break;
case 3: //digito 3
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
break;
case 4://digito 4
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 5: //digito 5
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 6: //digito 6
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 7: //digito 7
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 8: //digito 8
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 9: //digito 9
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
}

}

//programamos lo 7 primeros pines del puerto A como salida 

//y los dos primeros del puerto B como entrada 
void setup() {
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
pinMode(botonIncremento, INPUT);
pinMode(botonDecremento, INPUT);
}
void loop() {
estadoBotonIncremento = digitalRead(botonIncremento);
if(estadoBotonIncremento != estadoBotonAnteriorIncremento) {
if(antirebote(botonIncremento)) {
cuenta++;
if(cuenta > 9) {
cuenta = 9;

}
}
}
estadoBotonAnteriorIncremento = estadoBotonIncremento;

estadoBotonDecremento = digitalRead(botonDecremento);

if(estadoBotonDecremento != estadoBotonAnteriorDecremento) {
if(antirebote (botonDecremento)) {
cuenta–;
if(cuenta < 0)

{
cuenta = 0;
}
}
}
estadoBotonAnteriorDecremento = estadoBotonDecremento;

actualizarNumero();
}

Este código Arduino es un ejemplo de cómo controlar un display de 7 segmentos utilizando dos botones para incrementar y decrementar un número mostrado en el display. Te explicaré paso a paso qué hace cada parte del código:

1. Definición de pines: Se definen constantes para los pines del Arduino que están conectados a los segmentos del display de 7 segmentos (a, b, c, d, e, f, g) y para los pines que están conectados a los botones de incremento y decremento (botonIncremento y botonDecremento).
2. Variables y constantes adicionales: Se define una constante tiempoAntirebote que controla el tiempo de antirrebote de los botones, y algunas variables para el estado actual y anterior de los botones y el número que se está mostrando en el display (cuenta).
3. Función antirrebote: Esta función se encarga de evitar los falsos disparos cuando se presionan los botones. Utiliza un contador que se incrementa cada vez que el estado del botón es igual al estado anterior, y devuelve el estado del botón solo si el contador supera el tiempo de antirrebote definido.
4. Función actualizarNumero: Esta función actualiza los segmentos del display de 7 segmentos según el valor de cuenta utilizando un switch-case. Cada case representa un dígito del 0 al 9 y enciende o apaga los segmentos correspondientes para mostrar ese dígito.
5. Configuración inicial en el setup: Se configuran los pines como entrada o salida en el setup().
6. Bucle principal en el loop(): En el bucle principal se lee el estado de los botones de incremento y decremento. Si se detecta un cambio en el estado de alguno de los botones, se llama a la función antirrebote y se incrementa o decrementa el valor de cuenta según corresponda. Se asegura que cuenta no exceda los límites (0-9). Luego, se actualiza el número mostrado en el display llamando a la función actualizarNumero().

En resumen, este código controla un display de 7 segmentos para mostrar un número que puede ser incrementado o decrementado mediante dos botones, evitando falsos disparos utilizando la técnica de antirrebote.