Multiplexar Display 7 Segmentos con Arduino

En esta entrada entenderás como funciona la multiplexación y veremos como multiplexar un display de 7 segmentos con Arduino, el cual podrás aplicarlo para display de 7 segmentos de 2 dígitos, 3 dígitos, 4 dígitos, etc.

Antes que nada si no has visto todas las entradas que tenemos de Arduino, pues Mira los 👉 TUTORIALES DE ARDUINO

Multiplexar Display 7 Segmentos con Arduino

Tal y como lo vimos en la entrada pasada del Display de 7 Segmentos con Arduino, vimos que para poder usar este periferico en nuestra placa, vamos a tener que obligatoriamente ocupar 7 pines de nuestro Arduino, por lo tanto, el solo hecho de pensar en usar 2 displays, indicaría que deberíamos usar 14 pines del Arduino, lo cual comenzaría a volver inviable nuestros proyectos.

Sin embargo, para eso vamos a utilizar el concepto de Multiplexación, el cual nos va a permitir usar únicamente los 7 pines del Arduino que se conectan a un diplay sencillo y unos pines adicionales para el control, es decir si conectamos un display de 7 segmentos de 2 dígitos con arduino vamos a necesitar 2 pines de control (9 pines en total), si es de 4 dígitos serían 4 pines de control (11 pines en total del arduino).

Quizas te interese algunos productos de Arduino en Amazon a un mu buen precio.

Multiplexación Display 7 Segmentos

La multiplexación de un Display, simplemente consiste en encender un único display, mostrar el numero y luego apagarlo, para encender el display que le sigue. El truco de encender y apagar el display a una alta velocidad, permite engañar al ojo humano, y tener la sensación de que todos los displays se encuentran energizados al mismo tiempo, pero en realidad, si lo vemos en cámara lenta, los displays de 7 segmentos de ánodo o cátodo común están haciendo la siguiente secuencia de multiplexación:

Vemos que en cada segmento se le envia la secuencia del numero que se desea mostrar, y en las flechas de abajo indican la activación del respectivo display, donde si es ánodo común, indica que con un transistor PNP vamos a colocarlo a positivo para cerrar el circuito, por el contrario si es un display de catodo común, usamos un transistor NPN para mandar el display a tierra y cerrar el circuito.

Conexión del Display 7 Segmentos con Arduino – Multiplexación

Varios canales en YouTube y paginas en la web muestran que los pines de control que Activan cada display los conectan directamente a los pines del Arduino, y envían la secuencia de HIGH y LOW para activar cada display y con esto  parece que cerraría el circuito a GND y ya está.

Pero NO!!!. El consumo típico de cada segmento, (como de cada LED) es de entre 15 y 20mA. Como tenemos 8 segmentos, pensemos en el caso en el que mostramos el numero 8 junto con el punto decimal, el consumo será de 8 x 15 = 120 mA y pudiendo llegar a 160mA. Esto es más de lo que aguanta un Arduino que son 40mA, entonces corremos el riesgo de quemar nuestra placa.

Entonces, para evitar este problema, debemos usar la multiplexación a través de transistores NPN para cátodo común y PNP para ánodo común, configurados como switches.

Por ejemplo, cuando usábamos 1 solo display, no teniamos que hacer ninguna multiplexación, entonces el pin común lo colocamos directamente a positivo (ánodo común) o negativo (cátodo común).

Con vários displays tenemos que multiplexar y debemos mandar el común hacia los pines digitales del arduino y ahora no más a la alimentación, de lo contrario no podríamos multiplexar.

Vimos que el arduino aguanta 40mA por pin, pero que sucede si no conectamos el transistor? si no que hacemos la multiplexación directamente con el arduino como muchos muestran por ahi?

Pues ese PIN con el que estamos haciendo la multiplexación va a recibir 160mA, y como cada pin aguanta solo 40mA, entonces corremos el riesgo de quemar la placa.

Claro Arduino aguanta 200mA con la suma de la corriente de todos sus pines, pero lo que estamos diciendo es que sin el transistor, un único pin recibe 160mA.

Cátodo Común

Aqui vemos la conexión de displays de 7 segmentos de cátodo común con transistores NPN (2N3904) donde poniendo LOW en los pines de control (la base del transistor) los transistores están al corte, y ningún digito puede iluminarse. Si ponemos tensión en el pin de más a la derecha su transistor se satura y permite la salida a Ground del primer digito que encenderá los segmentos que le indiquen los pines del a al g.

digitalWrite(PinTransistor,HIGH); //Satura el transistor para Activar Display

Ánodo Común

En este caso la conexión de displays de 7 segmentos de ánodo común con transistores PNP (2N3906) donde poniendo HIGH en los pines de control (la base del transistor) los transistores están al corte, y ningún digito puede iluminarse. Si ponemos LOW en el pin de más a la derecha su transistor se satura y permite la salida a VCC del primer digito que encenderá los segmentos que le indiquen los pines del a al g.

digitalWrite(PinTransistor,LOW); //Satura el transistor para Activar Display

Display de 7 Segmentos 4 Dígitos con Arduino – Ejemplo con Código

El circuito que vamos a implementar en esta entrada es el siguiente, donde nos vamos a valer de un Display 7 Segmentos de 4 Digitos con Arduino, sabes que si no tienes el display de 7 segmentos de 4 digitos, puedes reemplazarlo por 4 displays sencillos, pero deberas unir todos los segmentos en el protoboard, es decir unir todos los segmentos A, todos los segmentos B, y asi sucesivamente.

En este ejemplo haremos una temporización para ir incrementando los digitos del Display 7 Segmentos, no obstante, si deseas realizar un temporizador PRECISO! deberás posteriormente usar el TIMER con ARDUINO para lograr dicho objetivo.

Lista de Materiales

• Cualquier Placa de ARDUINO
• 4 Displays de 7 Segmentos Catodo común
• 7 Resistencias de 220ohms para los displays
• 4 Resistencias de 1k para los transistores
• 4 Transistores NPN (2n3904)
• 1 Protoboard
• Cables de conexión

Conseguir Materiales en Amazon

Código

A continuación te dejo el código del Display de 7 Segmentos con Arduino para que te sirva como ejemplo y entiendas el funcionamiento de este periférico:

Pudes ver la simulación de este circuito en Tinkercad si lo deseas Dando CLICK AQUÍ y seleccionando el proyecto de multiplexación display 7 segmentos. Debes tener una cuenta en tinkercad para poder ver los esquemas.

//*************************************************************//
//*************************************************************//
//****                                                    *****//
//**** MULTIPLEXACIÓN CON DISPLAY 7 SEG                   *****//
//****                                                    *****//
//**** By: SERGIO ANDRES CASTAÑO GIRALDO                  *****//
//**** https://controlautomaticoeducacion.com/            *****//
//**** RIO DE JANEIRO - BRASIL - 2018                     *****//
//****                                                    *****//
//*************************************************************//
//*************************************************************//
//Display 7 Segmentos Catodo Común
int display7c[10]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};
//Display 7 Segmentos Anodo Común
int display7a[10]= {0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x18};
//Delcaración de Los Pines del Display
byte a=2;
byte b=3;
byte c=4;
byte d=5;
byte e=6;
byte f=7;
byte g=8;
// Declaración de los Pines de los Transistores
byte t1=9;
byte t2=10;
byte t3=11;
byte t4=12;
//Contadores para hacer el Temporizador
long tempor=0,contret=0;
//Función que coloca en el puerto de salida los bits comenzando
// desde el pin ini hasta el pin fin
void puerto(int bits,int ini,int fin){
  for(int i=ini;i<=fin;i++)
  {
    digitalWrite(i,bitRead(bits,i-ini));
  }
}
//Función encargada de la multiplexación
void mostrar( ) //Rutina mostrar
{
   int dig[4];   //Declarar las variables
                 //como un entero, es decir de 8bits
   //Dígito Millar
   dig[0]=tempor/1000;
   //Dígito Centena
   dig[1]=(tempor-dig[0]*1000)/100;
   //Dígito Decena
   dig[2]=(tempor-dig[0]*1000-dig[1]*100)/10;
   //Dígito Unidad
   dig[3]=(tempor-dig[0]*1000-dig[1]*100-dig[2]*10);
   //Rutina de Multiplexación
   for(int i=t1;i<=t4;i++){ 
     //Muestra unidades
     puerto(display7c[dig[i-t1]],a,g); 
     digitalWrite(i,HIGH);  //Enciende el display de unidades
     delay(1);               //Retardo de 1 milisegundos
     digitalWrite(i,LOW);   //Apaga el display de unidades
   }                      
}
//Función que cuenta el tiempo que le toma al temporizador
//incrementar su cuenta
void temporizacion() 
{
   contret=50;       //Cargue con 50 la variable CONTRET
   while (contret>0) //Mientras que la variable CONTRET sea mayor que cero
   {
      mostrar();        //Llamar la rutina MOSTRAR
      contret--;        // Decremente la variable CONTRET
   }
}
//Configura todos los pines como Salidas
void setup() {
  //Configura los 8 Pines digitales como SALIDAS
  for(int i=a;i<=t4;i++){
    pinMode(i,OUTPUT);
  }
}
//Programa Principal
void loop() {
   tempor=0;  //Inicializa el temporizador en Cero
      while(tempor<9999) //mientras la variable TEMPOR es menor que 9999
      {
         temporizacion(); //Llama la Función Temporizaor
         tempor++;        //Incrementa el tempor 
      }
}

Que les a parecido esta entrada? Si te ha gustado puedes compartirlo con tus amigos y suscribirte al canal para que sigas aprendiendo mucho más. Puedes suscribirte también por Correo electrónico a este sitio web para saber cuando hayan nuevas publicaciones, el formulario esta en la barra derecha de esta página, es muy fácil inscribirse.