Multiplexación Display de 7 Segmentos con PIC

En esta entrada aprenderás paso a paso a usar la Multiplexación del display 7 segmentos con PIC, que es una técnica muy común en electrónica digital que nos permite conectar displays 7 segmentos de 2 dígitos, 4 dígitos o los dígitos que desees a nuestro microcontrolador.

Antes que nada te hago la invitación para que veas todo el curso completo y gratuito de Microcontroladores PIC.

Y que te suscríbas al canal de YouTube para seguir aprendiendo como programar microcontroladores:

Multiplexar Display 7 Segmentos PIC C

En muchas ocasiones se requiere mostrar números en el display de más de un dígito, es decir, 2, 3, o 4 dígitos. En la entrada pasada vimos como usar un único 👉 display de 7 segmentos con PIC, en esta entrada vamos a generalizarlo para la cantidad de displays que queramos colocarle a nuestro proyecto. Quizas te pueda interesar como usar el 👉 display 7 segmentos con Arduino.

Notemos que si se pretende controlar cada display, se necesitan siete (7) líneas del microcontrolador por cada uno, esto ocuparía todas las líneas disponibles en cada puerto del microcontrolador, sin embargo existe una técnica llamada multiplexación que consiste en conectar a las mismas 7 líneas los 2,3 o 4 display e ir encendiendo uno a uno los display, a través de un transistor, tan rápidamente que parece encenderse todos al mismo tiempo.

Cualquier elemento que se encienda y apague con una frecuencia mayor a 25Hz es imperceptible para el ojo humano, éste lo verá encendido en todo momento.

Display 7 Segmentos de vários Dígitos con PIC

A continuación vemos un esquemático para Multiplexar 2 Display 7 Segmentos con PIC, sin embargo lo podemos extender para el numero de displays que queramos, puedes usarlo para multiplexar 3 display de 7 segmentos con pic, para multiplexar 4 display de 7 segmentos con pic, etc.

Nota: los segmentos de cada display van unidos entre sí, es decir a con a, b con b, hasta el g con g, por cada display adicional se necesita un transistor y sólo una línea más del microcontrolador. También es importante que entiendas que en el mercado ya venden displays de varios digitos, como el caso del display de 4 digitos.

En este diagrama se asume que las unidades están en el display de la derecha y las decenas en el display de la izquierda.

A continuación veremos un ejemplo para multiplexar display 7 segmentos con PIC C, que muestra como multiplexar 2 display de 7 segmentos con PIC, pero el mismo ejemplo lo puedes usar para controlar 4 display 7 segmentos con PIC. La única diferencia es aumentar el numero de displays y repetir en la linea de código los mismo para las centenas y millares.

Es importante destacar que para la construcción de nuestros proyectos electrónicos con microcontroladores podemos comprarlos también desde la comodidad de nuestra casa en Amazon que tiene envios para cualquier lugar de latinoamerica y para europa:

No products found.

Display 7 Segmentos Tabla en Hexadecimal

A continuación te dejo la tabla del Display 7 Segmentos Hexadecimal para Cátodo y Ánodo común:

Cátodo Común

Para manejar una estructura en C, lo único que se debe hacer es añadir la estructura al encabezado.

Para Cátodo Común adicionar el siguiente arreglo:

Byte CONST display[10]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};

La conexión a cátodo común se realiza a través de transistores NPN llevando el común del display a tierra como se observa en la siguiente ilustración:

Ánodo Común

Para Ánodo Común adicionar el siguiente arreglo:

Byte CONST display[10]= {0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x18};

El número 10 indica la cantidad de posiciones de la estructura, los códigos 7 segmentos están en hexadecimal.

La conexión a ánodo común se realiza a través de transistores PNP llevando el común del display a VCC como se observa en la siguiente ilustración:

Display 7 Segmentos de 2 Dígitos – Ejemplo

Realizar un temporizador con display de 7 segmentos de 0 a 99 que incremente cada segundo.

A continuación te dejo el código para que lo puedas copiar y pegar en tu compilador y de esta manera puedas reproducirlo en tu computador. Recuerda que para ver el código solo debes compartir el contenido de este post. Gracias por apoyar la página.

#INCLUDE <16F887.h>
//#USE DELAY(CLOCK=4000000) //Reloj interno 4MHz
#use delay(clock=4000000,crystal)//Crystal Externo 4MHz
#FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
Byte CONST display[10]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};
#BYTE PORTB= 6
#BYTE PORTC= 7
#DEFINE TUNI PORTC,0 //Definición de variables
#DEFINE TDEC PORTC,1 //Definición de variables

INT CONT;   //Declarar la variable CONT como
            //un entero, es decir de 8 bits
LONG CONTRET;  //Declarar la variable CONTRET
               //como long, es decir de 16 bits
               
               
VOID MOSTRAR( ) //Rutina mostrar
{
   INT UNI,DEC;   //Declarar las variables UNI, DEC
                  //como un entero, es decir de 8bits
   DEC=CONT/10;
   UNI=CONT%10;
   PORTB=(DISPLAY[UNI]);   //Muestra lo que hay en unidades
                           //en el display
   BIT_SET (TUNI);         //Enciende el display de unidades
   DELAY_MS(1);            //Retardo de 1 milisegundos
   BIT_CLEAR(TUNI);        //Apaga el display de unidades
   PORTB=(DISPLAY[DEC]);   //Muestra lo que hay en unidades
                           //en el display
   BIT_SET (TDEC);         //Enciende el display de decenas
   DELAY_MS(1);            //Retardo de 1 milisegundos
   BIT_CLEAR(TDEC);        //Apaga el display de decenas
   
}


VOID RET1SEG() //Rutina RET1SEG
{
   CONTRET=500; //Cargue con 500 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
   }
}

void MAIN()
{
   SET_TRIS_B(0); //El puerto B esta configurado como salida
   SET_TRIS_C(0); // El puerto C esta configurado como salida
   CONT=0;  //la variable CONT se inicializa con cero

   WHILE(TRUE) //Haga por siempre
   {
      CONT=0;
      WHILE(CONT<100) //mientras la variable CONT es menor que 100
      {
         RET1SEG( ); //Llama la rutina RET1SEG
         CONT++; //Incrementa la variable CONT
      }
      
   }
}

En el ejemplo anterior se utilizan funciones, que son pequeños subprogramas que se pueden llamar desde el programa principal (MAIN). Se debe digitar antes del programa principal que es quien las llama.

Las dos funciones empleadas son: «MOSTRAR» que es una pequeña rutina que se encarga de hacer la multiplexación entre los dos displays. Y la otra funcion es «RET1SEG» que es una rutina de retardo de 1 segundo, que va llamando en todo momento a multiplexación para que de este modo mientras se está esperando a que el retardo de 1 segundo se cumpla, vaya mostrando el valor del temporizador actual.

Si la función no retorna ningún valor se pone la directiva VOID antes del nombre de la función indicando que no retorna ningún valor.

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.