Saltar al contenido
Control Automático Educación

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

displays 7 segmentos varios digitos

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:

Multiplexación Display 7 Segmentos

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.

xbee con PIC

XBEE modo AT

Comunicación Serial con Arduino

Comunicación Serial con Arduino

Cátodo Común

Display de 7 Segmentos Catodo 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

Display 7 Segmentos Anodo 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.

Display 4 digitos
Display 7 Segmentos de 4 Digitos con Arduino

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.

Entradas relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Comentarios (35)

buenas estimado chamo megusta este código en ve de otros que ya e probado y
muy poco compilo con esto micro controladores ya que tuve problema
con esto micro controladores antes. Ya que utilizo mas los micro controladores pic
son mas compresivos y fasir de entender, compilar y configurar.

bueno aqui estoy intenta de nuevo probar compilar con esto micro controladores atmel en atmega328p son los mas comunes que utiliza en arduino y configurar los fucel
ya que bloquie una ves este micro.

También como hacer compilaciones para I2C para eeprom externo como la memorias 24cxxx que no encuentro mucha información de ellas y me cuesta como hacer su código y hace varios proyectos

Bueno hablan de este código de multiplexacion de 7 segmentos
tube que cambiar en código hexadecimal de los números ya que en este display la tengo invertido.
0X01,0X4F,0X12,0X06,0X4C,0X24,0X20,0X0F,0X00,0X0C

Responder

Hola muy bueno y claro en general. Me surge una duda en el caso de tener un display de Ando común. ¿el código que pusiste sirve? Veo que tiene lo display7A pero no me doy cuenta sobre el Transistor PNP. ¿Cómo se conectaría?

Saludos desde Montevideo Uruguay

Responder

Hola Marcelo, la conexión está en el mismo post, solo que está es en conexión electrónica, no esta en formato de protoboard, sin embargo la conexión es muy parecida, la base va al arduino, el emisor vá a positivo y el colector va al pin común del display 7 segmentos. En el código solo debes modificar donde diga display7c por display7a. Saludos!

Responder

Gracias recién hoy pude comprar los transistores PNP y esto viendo nuevamente el video para lograr el proyecto. Te cuento que estoy usando una Micro Bit para manejar el contado 24 segundos. Me quedan un para de dudas.
A ¿Tengo que poner una resistencia de 1K en la base entre la placa y el transistor? para que no se queme el transistor ni la placa.
B ¿El positivo del emisor lo saco de la placa?
C ¿ El colector se conecta al pin del display?
D ¿ En el programa no varia nada si va un transistor PNP o NPN?

Gracias por tu tiempo y ayuda.

Responder

Hola Marcelo, antes que nada, recuerda identificar cual es el pin de la base, emisor y colector del transistor que has comprado:
A. Correcto debes colocar la resistencia de 1k entre la placa y el transistor.
B. Si, el vcc (+5v) que conectas al emisor lo obtienes de la placa, o en su defecto de la fuente que usas para energizar el circuito.
C. El colector se conecta al pin común del display.
D. lo único que debes substituir en el programa es reemplazar dentro de la función mostrar, donde dice display7c lo reemplazas por display7a.

Responder

hola me gustaria , que me ayudarias en mi caso que no entiendo Realice un programa en Arduino para contar de forma descendente los números pares del 0 al 9. ES ESTE PRBLEMA MUCHAS GRACIAS

Responder

muy buenos videos, me gustaría como hacer este proceso y en lugar de hacer un contador quisiera conectar un teclado matricial 4×4 y poder teclear los números y talvez poder realizar operaciones matemáticas simples

Responder

Hola Jesus, debes primero conectar y leer el teclado matricial al microcontrolador, en esta entrada explicamos el teclado 4×4: https://controlautomaticoeducacion.com/microcontroladores-pic/teclado-matricial/
Debes capturar los números, transformarlos de caracter a numérico, y luego internamente hacer la operación matemática que desees, para finalmente mostrarla bien sea en los displays o un lcd.

Responder

Hola sergio, necesito su ayuda, en mi caso estoy haciendo un reloj 24hrs, ya confiure la parte de los minutos, que al llegar 60 minutos aumente una hora, pero ahora quiero agregar que cuando llegue a 24 horas el reloj se resetee, sabe usted como podria hacer eso? le dejo mi codigo.

int display7c[10]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};
byte a=2;
byte b=3;
byte c=4;
byte d=5;
byte e=6;
byte f=7;
byte g=8;

byte t1=9;
byte t2=10;
byte t3=11;
byte t4=12;
int leds=13;
long temporM=0,temporm=0, temporS=0, tempors=0, contret=0;
void puerto(int bits,int ini,int fin){
for(int i=ini;i<=fin;i++)
{
digitalWrite(i,bitRead(bits,i-ini));
}
}
void mostrar( )
{
int dig[4];
dig[0]=temporM;
dig[1]=temporm;
dig[2]=temporS;
dig[3]=tempors;

for(int i=t1;i0)
{
mostrar();
contret–;
}
}

void setup() {

for(int i=a;i<=t4;i++){
pinMode(i,OUTPUT);
pinMode(leds,OUTPUT);
}
}
void loop() {
digitalWrite(leds,HIGH);
tempors=0;
while(tempors<10)
{
temporizacion();
tempors++;
}
if (tempors==10){
tempors=0;
temporS++;
}
if (temporS==6){
temporS=0;
temporm++;
}
if (temporm==10){
temporm=0;
temporM++;
}
}

Responder

Hola Sergio necesito una pequeña ayuda, estoy realizando un reloj 24 horas, y estoy utilizando como base su video, yo ya programe mi arduino para que al llegar las 24 horas empieze desde 0 de nuevo a contar horas, sin embargo, para los minutos que serian los display de decenas y unidades sobrepasan los 60 minutos, so mi pregunta es que codigo deberia agregar a su codigo para que cuando marque 60 minutos aumente 1 hora, seria de mucha ayuda si me proporciona los cambios que debo de realizar para el caso de los minutos.

Responder

Tenemos bien las conexiones, tenemos bien el código, pensamos que pueden dar falso al poner las conexiones ya que al hacerlo funcionar solo prenden 3 dígitos de izquierda a derecha. Para nada se distinguen los números, tenemos el display de Ánodo común, los transistores correctos, tenemos todo. AYUDAAAA!!!

Responder

Es complicado saber que pueda estar fallando, debes ir probando estapa por etapa, verificar las conexiones. Te dejo el link con la simulación del circuito, quizas te ayude: https://www.tinkercad.com/things/jtbO0befxXV

Responder

Gracias por los tutoriales, me han sido de mucha utilidad. Sería bueno también incluir algunos tutoriales sobre decodificadores, codificadores, demultiplexadores y demás.

Responder

Gracias Pepe por el comentário y las recomendaciones. Saludos y muchos éxitos!!

Responder

MUY BUENA EXPLICACION, GRACIAS POR SER TAN EXPLICATIVO, APRENDI MUCHAS COSAS MAS HOY.

Responder

De nada Alfredo, que bueno que te ha gustado. Saludos.

Responder

tienes algun video para calcular las corrientes amplificadas por el transistor y resistencias que deben usarse ?

Responder

Excelente tu sitio web, en especial para novatos yo. Esta todo explicado y me sirvió de mucho. Muchas gracias por compartir tus conocimientos, seguramente trabajas como yo, para un mundo mejor y más equilibrado.

Responder

Muchas gracias José por el comentário. Me alegra mucho que te guste el contenido del sitio web. La idea es aportar un poco a esta sociedad. Saludos!!

Responder

Hola tuve problemas para pasarlo a proteus ya q en display me sales los números con sus figuras incompletas..
Bueno muy buenos los videos.

Responder

buenos días Sergio, no se desbloquean los códigos

Responder

Hola Victor, lo probé y está funcionando. Es solo ayudarme a difundir el contenido de este sitio web usando los botones de redes sociales que salen sobre el código, pues es una labor que me toma mucho tiempo hacer. Saludos!

Responder

Hola, muy buena explicacion, pero como hago para reemplazar los 7 segmentos “chicos” por led mas grandes, digamos de 6.5″. La corriente ya no sera soportada por arduino. que circuito se usa en ese caso? hay algun “accesorio” para arduino que pueda manejar mayor corriente? gracias

Responder

Muy interesante todos sus vídeos se aprende lo que el profe no nos deja ni siquiera copiar Gracias por dedicar tiempo para nosotros los que nos gusta el Arduino siga siga sin parar que es muy Bueno todo su material y que dios le bendiga grande mente
desde Bogota

Responder

Gracias Cristo, poco a poco iré montando más videos a nuestro curso de Arduino. Saludos para ti también!!

Responder

que referencia tienen los 4 trancistores y las redcistencias ? son 4 de 200k y 7 de 230?

Responder

transistor: 2N3904, resistencias del transistor: 1k, resistencia de los displays: 220ohms

Responder

Puedo incrementar la variable tempor por medio de una interrupción y así medir una frecuencia. Verdad.

Interesante tu video. Muy bien comentado. Excelente

Responder

Claro que si Juan Ortiz, puedes hacer lo que comentas. Gracias por el comentário. Saludos!!

Responder

Gracias!!, tratare de hacerlo con RTC, y desplegar solo las horas. Buen aporte.

Responder

De nada Abdul, me alegro que te haya servido. Saludos.

Responder

si quisiera hacer que contara de 25 min a 0 tendria quecambiar el codigo general y la parte de los dig[4]

Responder

No cambia el código no. Solo cambia la variable que lleva la cuenta, en este caso tempor quien debe decrementar, sería tempor–; E claro adicionando la lógica de tu programa. Saludos.

Responder

Buenísimo Sergio, me has ayudado mucho para recordar la implementación de unos displays multiplexados. Mi aporte seria el siguiente : en la función mostrar() se puede utilizar el operador % que es modulo residuo de la división de un numero entero. es ideal para descomponer números enteros.
Hice uno de seis dígitos 999999 para hacer unas pruebas de desbordamiento en micros de 8 Bits y su uso en micros de 32 bits quedando así

int dig[6]; //Declarar las variables

dig[5]=tempor/100000;
dig[4]=(tempor % 100000)/10000; // básicamente es una división con residuo solo se toma el residuo
dig[3]=(tempor % 10000)/1000;
dig[2]=(tempor % 1000)/100;
dig[1]=(tempor % 100)/10;
dig[0]= tempor % 10;

Se que da el mismo resultado pero yo también me enredé un poco al tratar de modificarlo 🙂

Siempre agradecido por la explicación del código.

Responder

Gracias Luis, nuevamente por el aporte. Un saludo grande!!!

Responder