Afficheur 7 segments

Les afficheurs 7 segments sont un type d’afficheur très présent sur les calculatrices et les montres à affichage numérique : les caractères s’écrivent en allumant ou en éteignant des segments, au nombre de sept.

Quand les 7 segments sont allumés, on obtient le chiffre 8.

 

L’objectif de l’exercice est de réaliser un décodeur dont la fonction est de convertir un chiffre hexadécimal (codé sur 4 bits a, b, c d) en un caractère sur l’afficheur.

 

Analyse

Compléter la table de vérité du décodeur 7 segments.
  a b c d A B C D E F G
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
×

 

Et tester avec l’application Geogebra ci dessous (cocher les cases et déplacer le curseur) :

En déduire les expressions « brutes » (non simplifiées) des valeurs booléennes des sorties (A à G) en fonction des valeurs d’entrée (a à d).
Simplifier ces expressions en utilisant les règles de l’algèbre de Boole.

 

Implémentation

L’objectif de cette partie est de réaliser 2 implémentations de ces expressions logiques, une en langage Python, l’autre en logigramme dans un modèle MATLAB/Simulink…

Python

Exprimer ces mêmes expression en langage Python.

 

Le programme Python suivant comporte :

  • une fonction affiche_7s(A, B, C, D, E, F) qui affiche un caractère au format « 7 segments » à partir des valeurs booléennes A, B, C, D, E et F passées en argument.
  • une fonction conversion_7s(n) qui réalise la conversion depuis le nombre n passé en argument, en un tuple des valeurs booléennes A, B, C, D, E et F de l’afficheur 7 segments.
def affiche_7s(A, B, C, D, E, F, G):
    """ Affiche un caractère au format "7 segments"
        à partir des valeurs booléennes des 7 segments A, B, C, D et F
    """
    l = [[False]*5 for _ in range(7)]

    if A: l[0][1] = l[0][2] = l[0][3] = True
    if B: l[1][-1] = l[2][-1] = True
    if C: l[4][-1] = l[5][-1] = True
    if D: l[6][1] = l[6][2] = l[6][3] = True
    if E: l[4][0] = l[5][0] = True
    if F: l[1][0] = l[2][0] = True
    if G: l[3][1] = l[3][2] = l[3][3] = True

    s = "\n".join(["".join(["#" if t else " " for t in c]) for c in l])
    print(s)

def conversion_7s(n):
    """ Convertit le nombre n (0<=n<=15)
        en une liste de booléens des 7 segments
        à allumer(True)/éteindre(False)
    """
    # conversion de n en code binaire naturel --> booléens a, b, c et d
    l = []
    while n > 0:
        l.insert(0, n % 2)
        n = n // 2
    while len(l) < 4:
        l.insert(0, 0)
    a, b, c, d = l

    A = 
    B = 
    C = 
    D = 
    E = 
    F = 
    G = 

    return A, B, C, D, E, F, G

 

 

Compléter la fonction conversion_7s puis tester ce programme.

 

Logigramme

Réaliser sur papier un logigramme pour ces 7 expressions logiques (un seul logigramme avec 4 entrées et 7 sorties).

📥 Télécharger le modèle Simulink du convertisseur numérique → 7 segment : sept_segments_2021b.slx ou bien sept_segments.slx (R2018b)

Compléter le bloc « Conversion 7 segments » (accès par double-clic) en utilisant uniquement des blocs AND OR et NOT (3 exemplaires sont déjà fournis, faire autant de copier/coller que nécessaire). Tester le fonctionnement en lançant la simulation , puis en modifiant le bloc du nombre décimal.

 

Logique câblée

Les circuits intégrés proposant des portes logiques pour réaliser de la logique câblée ne comportent souvent qu’un seul type d’opérateur : soit NON-ET, soit NON-OU. Ces opérateurs étant complets, il est possible de réaliser n’importe quelle fonction avec un seul de ces types (voir activité dans Opérateurs logiques).

Exprimer ces mêmes valeurs en n’utilisant que des opérateurs NON-ET.

 

 

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *