Saltar al contenido
Control Automático Educación

Display 7 Segmentos

Hola controleros y controleras en esta entrada aprenderemos a programar los displays 7 segmentos usando MicroPython en nuesto microcontrolador Raspberry Pi Pico y también en el NodeMCU ESP8266.

Antes de comenzar te invito a que le des un vistazo a nuestro curso de MicroPython con enfoque en la Raspberry Pi Pico.

Y que te suscríbas al canal si te interesa la programación de microcontroladores y la teoría del control.

Display 7 Segmentos

Un display 7 segmentos es un dispositivo que internamente posee 7 leds para representar un número y adicionalmente un octavo led para representar un punto decimal.

Estos dispositivos son usados para poder mostrar en nuestros proyectos determinados valores númericos.

En el mercado existen dos tipos de Displays de 7 Segmentos: Ánodo y Catodo común y dependiendo del display que poseas la conexión y su programación van a diferir ligeramente.

Display 7 Segmentos
display 7 segmentos

Si quieres entrar en mayor detalla sobre los displays de 7 segmentos, te invito a que veas nuestras entradas pasadas donde usamos un Display para el Arduino o un Display para el PIC.

Aquí nos vamos a centrar en la implementación con Micropython.

Números en Display 7 Segmentos

Para mostrar los números en un display de 7 segmentos, debemos programar la tabla de verdad de los displays de Cátodo o Ánodo común:

Display 7 Segmentos Anodo Común
Display 7 Segmentos Catodo Común

Para mostrar los dígitos en nuestra Raspberry Pi Pico o en la NodeMCU vamos a colocar en Micropython los valores en hexadecimal almacenados en una Tupla, para mayor facilidad.

#Display Cátodo Común
catodo = (int('3f',16),int('06',16),int('5b',16),int('4f',16),int('66',16),int('6d',16),int('7d',16),int('07',16),int('7f',16),int('67',16))
#Display Ánodo Común
Anodo = (int('40',16),int('79',16),int('24',16),int('30',16),int('19',16),int('12',16),int('02',16),int('78',16),int('00',16),int('18',16))
        

Módulos en Python

Ciclo For en Python

Ciclo FOR en Python

Cadenas de Caracteres en Python

Métodos String en Python

Display 7 Segmentos Micropython ejemplo

Vamos a programar un único display 7 segmentos en nuestra Raspberry Pi PICO o en nuestra NodeMCU8266 donde hagamos un conteo de forma ascendente de 0-9 y nos devolvamos con un conteo descendente de 9-0.

Inicialmente recordemos el Pinout para facilitar nuestra programación:

Raspberry Pi Pico Pines
Esquema Display 7 Segmentos Cátodo Común Raspberry Pi Pico
Esquema Display 7 Segmentos Cátodo Común Raspberry Pi Pico
Esquema Display 7 Segmentos Cátodo Común NodeMCU8266
Esquema Display 7 Segmentos Cátodo Común NodeMCU8266

El código es el siguiente:

"""
Display 7 Segmentos usando MicroPython
by: Sergio Andres Castaño Giraldo
Referencia: https://controlautomaticoeducacion.com/
"""
from machine import Pin
import utime


def show(digito, display):
    """
        Muestra el digito en el display 7 segmentos
        
        llamado de la función:
        show(digito, display)
        
        Parametros de entrada:
        digito -> Digito a mostrar
        display -> Lista con los pines del display (Pin.OUT)
        
        by: Sergio Andres Castaño Giraldo
        controlautomaticoeducacion.com/
    """
    #Tupla con los números de un display 7 segmentos catodo común
    catodo = (int('3f',16),int('06',16),int('5b',16),int('4f',16),int('66',16),int('6d',16),int('7d',16),int('07',16),int('7f',16),int('67',16))
    
    bit = 1;    
    for i in range(7):
        if (catodo[digito]  & bit) == 0:
            display[i].off()
        else:
            display[i].on()
        bit = bit << 1
    

def main():
    
    #Configura los pines del display 7 segmentos
    display_pins = (19, 18, 13, 15, 14, 16, 17) #Raspberry Pi Pico
    #display_pins = (16, 5, 4, 0, 2, 14, 12) #NodeMCU8266
    display = list()
    for i in range(7):
        display.append( Pin( display_pins[i], Pin.OUT ) )

    
    #Inicia las variables
    contador = 0
    sentido = True
    
    
    while True:
        #Muestra el valor del contador en el display
        show(contador, display)
        
        #Verifica si incrementa o decrementa el contador
        if sentido:
            contador += 1
        else:
            contador -= 1
        
        #Si contador es nueve coloque el sentido del contador a decrementar
        if contador == 9:
            sentido = False
        
        #Si contador es cero coloque el sentido del contador a incrementar
        if contador == 0:
            sentido = True
        
        #Esperar por 1 segundo
        utime.sleep(1)
    

#Entry Point
if __name__ == '__main__':
    main()

En el código anterior, usamos una función show para mostrar los digitos en un display de 7 segmentos de cátodo común. Vamos a crear nuestro propio módulo creando una nueva clase, con el objetivo de poder hacer importaciones de módulos propios y que además sea genérico para displays de cátodo y ánodo común.

Crear Módulos en MicroPython – Raspberry Pi Pico ESP8266

En un nuevo archivo de micropython vamos a crear la siguiente clase y la vamos a grabar dentro del dispositivo (Raspberry Pi Pico o NodeMCU8266) con el nombre display7seg.py

"""
Clase de Display 7 Segmentos usando MicroPython
by: Sergio Andres Castaño Giraldo
Referencia: https://controlautomaticoeducacion.com/
"""

from machine import Pin


class Display:
    
    
    def __init__(self, Pins, kind = 'C'):
        self.kind = kind        

        display = list()
        for i in range(7):
            display.append( Pin(Pins[i], Pin.OUT) )
        
        #Tupla con las posiciones del display
        self.display = display
        
            
    
    def show(self, digit):
        bit = 1;
        
        #Display Cátodo Común
        if self.kind.upper() == 'C':
            numbers = (int('3f',16),int('06',16),int('5b',16),int('4f',16),int('66',16),int('6d',16),int('7d',16),int('07',16),int('7f',16),int('67',16))
        #Display Ánodo Común
        elif self.kind.upper() == 'A':
            numbers = (int('40',16),int('79',16),int('24',16),int('30',16),int('19',16),int('12',16),int('02',16),int('78',16),int('00',16),int('18',16))
        else:
            return
        
        for i in range(7):
            if (numbers[digit]  & bit) == 0:
                self.display[i].off()
            else:
                self.display[i].on()
            bit = bit << 1

        

Ahora podemos volver a realizar nuestro ejemplo, pero importando esa nuevo módulo que hemos creado. Colocando al inicio la instrucción:

import display7seg

Finalmente nuestro código queda así:

"""
Display 7 Segmentos usando MicroPython
Importación de nuestro propio módulo display7seg

by: Sergio Andres Castaño Giraldo
Referencia: https://controlautomaticoeducacion.com/
"""

from machine import Pin
import utime
import display7seg



def main():
    display_pins = (16, 5, 4, 0, 2, 14, 12)
    display7 = display7seg.Display(display_pins, 'A')
    
    #Inicia las variables
    contador = 0
    sentido = True
    
    
    while True:
        #Muestra el valor del contador en el display
        #mostrar_display(numeros[contador], display)
        display7.show(contador)
        
        #Verifica si incrementa o decrementa el contador
        if sentido:
            contador += 1
        else:
            contador -= 1
        
        #Si contador es nueve coloque el sentido del contador a decrementar
        if contador == 9:
            sentido = False
        
        #Si contador es cero coloque el sentido del contador a incrementar
        if contador == 0:
            sentido = True
        
        #Esperar por 1 segundo
        utime.sleep(1)
    

#Entry Point
if __name__ == '__main__':
    main()

Multiplexación del Display de 7 Segmentos con MicroPython

Cuando nuestro proyecto en nuestra raspberry pi pico o nodemcu esp va a utilizar más de un display, lo más conveniente es utilizar el concepto de multiplexación para economizar pines en nuestro microcontrolador.

El concepto de la multiplexación también fue explicada en detalle en nuestro curso de arduino y en nuestro curso de pic.

La multiplexación de un Display, consiste en encender un único display, mostrar el numero y luego apagarlo, para luego encender el display que le sigue.

El truco consiste en encender y apagar el display a una alta velocidad para poder engañar al ojo humano, y tener la sensación de que todos los displays se encuentran energizados al mismo tiempo.

En cámara lenta se vería de la siguiente forma:

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 para la Multiplexación

Para conectar varios displays 7 segmentos a nuestra Raspberry Pi PICO, NodeMCU8266 o cualquier otro microcontrolador, vamos a necesitar de resistencias y transistores como se ve a continuación:

Cátodo Común

Display de 7 Segmentos Catodo común

Ánodo Común

Display 7 Segmentos Anodo Común

Ejemplo de Multiplexación con Micropython

Vamos a conectar un display de 4 digitos a nuestra Raspberry Pi Pico y vamos a visualizar un contador sobre el display:

Display 4 digitos
Esquema Raspberry Pi PICO habilitando 4 dígitos display 7 segmentos
Esquema NodeMCU8266 habilitando 2 dígitos display 7 segmentos
"""
Display 7 Segmentos usando MicroPython
Importación de nuestro propio módulo display7seg

by: Sergio Andres Castaño Giraldo
Referencia: https://controlautomaticoeducacion.com/
"""

from machine import Pin
import utime
import display7seg

def temporizacion(display7, contador): 
   contret=50        #Cargue con 50 la variable CONTRET
   while (contret>0): #Mientras que la variable CONTRET sea mayor que cero
      display7.show(contador)      #Llamar la rutina MOSTRAR
      contret -= 1      #Decremente la variable CONTRET

def main():
    
    #Raspberry Pi PICO (4 digitos)
    display_pins = (16, 18, 13, 14, 15, 17, 12) #(a, b, c, d, e, f, g)
    transistor_pins = (22, 21, 20, 19)
    
    #NodeMCU 8266v3 (2 Digitos)
    #display_pins = (16, 5, 4, 0, 2, 14, 12)
    #transistor_pins = (13, 15)
    
    display7 = display7seg.Display(display_pins,transistor_pins = transistor_pins )
    
    #Inicia las variables
    contador = 0
    sentido = True
    
    
    while True:
        #Muestra el valor del contador en el display
        temporizacion(display7, contador)
        
        #Verifica si incrementa o decrementa el contador
        if sentido:
            contador += 1
        else:
            contador -= 1
        
        #Si contador es nueve coloque el sentido del contador a decrementar
        if contador == 9999:
            sentido = False
        
        #Si contador es cero coloque el sentido del contador a incrementar
        if contador == 0:
            sentido = True
        
    

#Entry Point
if __name__ == '__main__':
    main()

Pero para que funcione, debes cargar en el microcontrolador el siguiente módulo con el nombre display7seg.py

"""
Clase de Display 7 Segmentos usando MicroPython
by: Sergio Andres Castaño Giraldo
Referencia: https://controlautomaticoeducacion.com/
"""

from machine import Pin
import utime

class Display:
    
    
    def __init__(self, Pins, kind = 'C', transistor_pins = 1):
        self.kind = kind
        self.number_digit = len(transistor_pins)
        
        #Configura los pines del display como salida
        display = list()
        for i in range(7):
            display.append( Pin(Pins[i], Pin.OUT) )
        
        #Configura los pines de los transistores como salida
        transistors = list()
        for i in range(self.number_digit):
            transistors.append( Pin(transistor_pins[i], Pin.OUT) )
        
        #Tupla con las posiciones del display
        self.display = display
        
        #Tupla con las posiciones de los transistores
        self.transistors = transistors
        
    def show(self, digits):
        #Realiza la multiplexación
        for i in range( self.number_digit ):
            number = int((digits % 10 ** (i+1)) / 10 ** i)
            self._show_one_display(number)
            self.transistors[i].on()
            utime.sleep_ms(1)
            self.transistors[i].off()
            
    
    #Metodo provado para mostrar número en un solo display
    def _show_one_display(self, digit):
        bit = 1;
        
        #Display Cátodo Común
        if self.kind.upper() == 'C':
            numbers = (int('3f',16),int('06',16),int('5b',16),int('4f',16),int('66',16),int('6d',16),int('7d',16),int('07',16),int('7f',16),int('67',16))
        #Display Ánodo Común
        elif self.kind.upper() == 'A':
            numbers = (int('40',16),int('79',16),int('24',16),int('30',16),int('19',16),int('12',16),int('02',16),int('78',16),int('00',16),int('18',16))
        else:
            return
        
        for i in range(7):
            if (numbers[digit]  & bit) == 0:
                self.display[i].off()
            else:
                self.display[i].on()
            bit = bit << 1

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.