Notebook

Logique combinatoire - PLD - CORRECTION¶

Sommaire

Présentation
1. Historique
2. La fonction "décodage"
Enoncé
Equations de la fonction "Décodage"
Simulation
1. Préparation des vecteurs de test
2. Exemple d'utilisation des vecteurs de test
3. Test des sorties RAM, ROM et OE de la fonction "Décodage"
4. Génération automatique de la table des vecteurs de test

1. Présentation¶

Les circuits électroniques (microprocesseur, chipset, System on Chip) assurent le fonctionnement de nos outils numériques (ordinateur, tablette, smartphone, etc.). Ils sont constitués de fonctions logiques complexes (unité arithmétique et logique, multiplexeur, décodeur, etc.) issues de l'assemblage d'opérateurs logiques combinatoires (ET, OU, NON, etc.) et séquentiels (bascules).

Dans ce TP, vous allez simuler les tests à effectuer sur une fonction logique avant son intégration dans un circuit logique programmable.

1.A Historique¶

La figure ci-contre représente le boîtier DIP (Dual In Package) à 14 broches d’un circuit intégré de type SSI (Small Scale Integration) contenant quatre portes ET à deux entrées.
Apparus en 1964, les circuits logiques SSI sont encore utilisés. Ils contiennent de 1 à 12 portes. Dans les années 80, une fonction logique telle que celle représentée par le logigramme ci-dessous nécessitait l’utilisation de trois circuits intégrés de type SSI intégrant chacun quatre portes logiques.

Ces composants étaient soudés et interconnectés par des pistes de cuivre sur un circuit imprimé.

On dispose aujourd’hui de circuits logiques programmables (Programmable Logic Devices) capables, selon leur complexité, de remplacer quelques dizaines à plusieurs centaines de milliers de circuits logiques "classiques". Le mot "programmable" ne signifie pas que le circuit exécute un programme, mais que les opérateurs logiques qu'il contient sont interconnectés à l'aide d'un programme ! Si la fonction réalisée ne correspond pas à celle attendue ou si on souhaite la faire évoluer, le composant pourra être "effacé" et reprogrammé.
Pour en savoir plus.

Un circuit logique programmable renferme un grand nombre d’opérateurs logiques combinatoires (ET, OU, NON, etc.) et séquentiels (bascules). Ce type de composant est utilisé lors de la conception ou lors de la réorganisation d’un produit nécessitant la mise en œuvre d’un grand nombre d’opérateurs logiques, car il améliore la fiabilité du produit, diminue son coût de fabrication et lui confère une certaine évolutivité. Wikipédia.

On assure l’interconnexion des opérateurs logiques avec un outil de programmation (ordinateur + logiciel).

Lorsque la fonction à intégrer dans le PLD est combinatoire et suffisamment simple, il suffit d'écrire les équations logiques booléennes de ses sorties avec le logiciel de programmation

La "programmation" d'un circuit logique programmable est réalisée avec un langage de description matériel ou un outil de saisie graphique. Après compilation de cette description, on obtient un fichier de configuration pour le circuit choisi.
VHDL et Verilog sont les deux langages de description les plus répandus. Il existe cependant un outil, migen, basé sur Python qui vise à automatiser davantage le processus de conception.

1.B La fonction "Décodage"¶

La fonction logique "Décodage" est une fonction combinatoire. Elle reçoit n bits en entrée (2ⁿ combinaisons) et délivre M bits en sortie telle que M ≤ 2ⁿ. La fonction "Décodage" est courante en électronique numérique. Elle est notamment utilisée dans les microprocesseurs pour réaliser le décodeur d'instructions.

2. Enoncé¶

Dans le cadre de la modification d’une carte électronique, on souhaite intégrer une fonction Décodage, initialement réalisée avec trois composants logiques, dans un PLD. Le logigramme de cette fonction est donné ci-dessous.

Logigramme¶

Dessiné avec Scheme-it.

3. Equations de la fonction "Décodage"¶

On limite l'étude à trois des six sorties de la fonction.

Activité 1

Si l'activité n'a pas été préparée en cours, écrivez les équations de RAM, ROM et OE sur le document réponse.

Correction

RAM = A15 + /PSEN
ROM = (/A15 . PSEN) + (RD . PSEN)
OE = A15 . A14 . A13 . A12

4. Simulation¶

Après la phase de programmation d’un PLD, il est nécessaire d’en vérifier le fonctionnement. Dans le cas du test d’une fonction combinatoire, il suffit de placer sur ses entrées toutes les combinaisons logiques qu’elle est susceptible de recevoir et de comparer chaque état de sa sortie avec celui attendu. Ceci est fait automatiquement par l’outil de programmation. Seule l’écriture des vecteurs de test incombe au concepteur.

Un vecteur de test se compose des valeurs à placer sur les entrées (E1, E2, .., En) de la fonction à tester et du résultat attendu sur sa sortie (S). Le vecteur de test i peut s'exprimer sous la forme : Vi(E1, E2, .., En, S)

Exemple : test d’une fonction f() implantée dans un PLD telle que S = /E1.E2 + E1./E2 (/ <=> not)

Dans l’exemple ci-dessus, les vecteurs V1(0,0,0), V2(0,1,1), V3(1,0,1) et V4(1,1,0) sont placés successivement sur les entrées du PLD reliées à la fonction f().

Pour tester une sortie logique combinatoire, il est nécessaire d’écrire 2ⁿ vecteurs.
n représente le nombre d’entrées de la fonction.

4.A Préparation des vecteurs de test¶

Activité 2

Si l'activité n'a pas été préparée en cours, complétez les tables de vérité du document réponse avec les résultats attendus sur les sorties RAM, ROM et OE.

Correction

4.B Exemple d'utilisation des vecteurs de test¶

Ressources : listes, tuples, tests, boucle for... et f-strings en Python.

Le langage Python dispose des opérateurs logiques and, or et not pour écrire des équations logiques. Les états logiques peuvent être représentés par des 1 et des 0. 0 <=>False, 1 <=> True.

L'exemple ci-dessous illustre le test d'un opérateur Ou Exclusif à 2 entrées.

In [ ]:

# Exemple introductif
# Code de test d'une fonction XOR
'''
Test d'une porte OU Exclusif à 2 entrées
E1, E2 : entrées
S : sortie (on note Sa la sortie attendue et So est la sortie obtenue !)
'''
Vecteurs_XOR = [(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)] # Une liste de tuples matérialise la table des vecteurs de test
print("[E1,E2] -> S ")
for E1, E2, Sa in Vecteurs_XOR:
    So = (not(E1) and E2 or E1 and not(E2)) # Equation de la porte OU Exclusif, parenthèses INDISPENSABLES !
    if Sa == So:                            # Remplacer and par or pour simuler des erreurs dans la table
        print(f"[{E1},{E2}] -> {Sa}") 
    else:
        print(f"[{E1},{E2}] -> Erreur")

Activité 3. Simulons des erreurs de frappe !

Testez les situations suivantes :

le vecteur (0,1,1) a été remplacé par (0,1,0)

l'opérateur or a été remplacé par un and

a) Comment identifie-t-on une erreur dans la table ?
b) Quelles sont les causes d'erreur lors du test d'un circuit logique programmable réel ?

Répondez ci-dessous.

Correction

a) Une erreur (So=/=Sa) est identifiée dans la table par le mot "Erreur"

b) Lors du test d’un composant réel, les causes erreurs peuvent être :

liées à l’écriture des vecteurs de test,
liées à l’écriture des équations,
le composant est défectueux.

Activité 4. Amélioration de l'affichage dans l'exemple introductif
En reprenant l'exemple introductif, complétez le code ci-dessous pour que le résultat du test affiche Sa, So et précise la position des erreurs.

Exemple de résultat attendu
[E1,E2] -> Sa So
[0,0] -> 0,0
[0,1] -> 0,1->Erreur
[1,0] -> 1,1
[1,1] -> 0,0

In [ ]:

# Exemple introductif modifié (à compléter)
# Code de test d'une fonction XOR
'''
Test d'une porte OU Exclusif à 2 entrées
E1, E2 : entrées
S : sortie (on note Sa la sortie attendue et So est la sortie obtenue !)
'''
Vecteurs_XOR = [(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)] # Une liste de tuples matérialise la table des vecteurs de test
print("[E1,E2] -> Sa So ")
for E1, E2, Sa in Vecteurs_XOR:
    So = (not(E1) and E2 or E1 and not(E2)) # Equation de la porte OU Exclusif, parenthèses INDISPENSABLES !
                                            # Remplacer and par or pour simuler des erreurs dans la table
    if Sa == So: 
        print(f"[{E1},{E2}] -> {Sa},{int(So)}") 
    else:
        print(f"[{E1},{E2}] -> {Sa},{int(So)} -> Erreur")

4.C Test des sorties RAM, ROM et OE de la fonction "Décodage"¶

Activité 5

En vous inspirant de l'exemple introductif modifié et en utilisant les résultats des activités 1 et 2, écrivez le code de test de la sortie RAM. Simulez des erreurs de frappe.

In [ ]:

# Code de test de la sortie RAM
Vecteurs_RAM = [ # Correction
  # A15,PSEN,RAMa 
    (0, 0, 1), 
    (0, 1, 0), 
    (1, 0, 1), 
    (1, 1, 1)] 
print("[A15,PSEN] -> RAMa RAMo")
# Correction
for A15, PSEN, RAMa in Vecteurs_RAM:
    RAMo = (A15 or not(PSEN)) # Remplacer or par and pour simuler des erreurs dans la table
    if RAMa == RAMo:
        print(f"[{A15},{PSEN}] -> {RAMa},{int(RAMo)}")
    else:
        print(f"[{A15},{PSEN}] -> {RAMa},{int(RAMo)} ->Erreur")

Activité 6

En vous inspirant de l'exemple introductif modifié et en utilisant les résultats des activités 1 et 2, écrivez le code de test de la sortie ROM. Simulez des erreurs de frappe.

In [ ]:

# Code de test de la sortie ROM
Vecteurs_ROM = [ # Correction
  # A15,RD,PSEN,ROMa
    (0, 0, 0, 0),
    (0, 0, 1, 1),
    (0, 1, 0, 0),
    (0, 1, 1, 1),
    (1, 0, 0, 0),
    (1, 0, 1, 0),
    (1, 1, 0, 0),
    (1, 1, 1, 1)
]
print("[A15,RD,PSEN] -> ROMa ROMo")
# Correction
for A15, RD, PSEN, ROMa in Vecteurs_ROM:
    ROMo = ((not(A15) and PSEN) or (RD and PSEN)) # Remplacer and par or pour simuler des erreurs dans la table
    if ROMa == ROMo:
        print(f"[{A15},{RD},{PSEN}] -> {ROMa}, {int(ROMo)}")
    else:
        print(f"[{A15},{RD},{PSEN}] -> {ROMa}, {int(ROMo)} ->Erreur")

Activité 7

En vous inspirant de l'exemple introductif modifié et en utilisant les résultats des activités 1 et 2, écrivez le code de test de la sortie OE. Simulez des erreurs de frappe.

In [ ]:

# Code de test de la sortie OE
Vecteurs_OE = [ # Correction
 # A15,A14,A13,A12,OEa
    (0, 0, 0, 0, 0),
    (0, 0, 0, 1, 0),
    (0, 0, 1, 0, 0),
    (0, 0, 1, 1, 0),
    (0, 1, 0, 0, 0),
    (0, 1, 0, 1, 0),
    (0, 1, 1, 0, 0),
    (0, 1, 1, 1, 0),
    (1, 0, 0, 0, 0),
    (1, 0, 0, 1, 0),
    (1, 0, 1, 0, 0),
    (1, 0, 1, 1, 0),
    (1, 1, 0, 0, 0),
    (1, 1, 0, 1, 0),
    (1, 1, 1, 0, 0),
    (1, 1, 1, 1, 1),
]
print("[A15,A14,A13,A12] -> OEa OEo")
# Correction
for A15,A14,A13,A12,OEa in Vecteurs_OE:
    OEo = (A15 and A14 and A13 and A12) # Remplacer and par or pour simuler des erreurs dans la table
    if OEa == OEo:
        print(f"[{A15},{A14},{A13},{A12}] -> {OEa}, {int(OEo)}")
    else:
        print(f"[{A15},{A14},{A13},{A12}] -> {OEa}, {int(OEo)} ->Erreur")

4.D Génération automatique de la table des vecteurs de test¶

Ressources : listes, tuples, tests, boucle for..., f-strings et sélection dans une chaîne (slicing) en Python.

Lorsque le nombre d'entrées augmente, la table des vecteurs de test devient imposante. Pour n=6, il faut écrire 64 vecteurs. L'écriture d'une telle table devient fastidieuse et le risque d'erreur augmente. Il devient alors nécessaire de disposer d'une fonction de génération automatique de la table des vecteurs de test.

On propose l'algorithme ci-dessous.

Algorithme creerVecteursTest(n,vs) Entrées n : nombre d'entrées de la fonction à tester vs : liste des valeurs attendues pour la sortie S de la fonction, notée Sa Sortie vecteurs : table des vecteurs de test début pour i variant de 0 à (nombre_de_vecteur - 1) par pas de 1 faire Construire le vecteur Vi(b_n-1, b_n-2,..., b0, Sa) Ajouter Vi à vecteurs fin faire Renvoyer vecteurs fin

Remarque : Python dispose de la fonction native bin. Cette fonction convertit un nombre entier en binaire dans une chaîne avec le préfixe 0b.

In [ ]:

# Exemple 
bin(8)

Activité 8

Complétez la fonction creerVecteursTest ébauchée ci-dessous.
Conseil : développer la fonction dans un éditeur (VSCode, etc.) avant de la tester dans le notebook.

Résultat attendu pour n=3
vecteurs = [(0, 0, 0, 0), (0, 0, 1, 1), (0, 1, 0, 0), (0, 1, 1, 1), (1, 0, 0, 0), (1, 0, 1, 0), (1, 1, 0, 0), (1, 1, 1, 1)]

In [ ]:

def creerVecteursTest(n, vs):
    vecteurs = []
    # Correction
    vecteur_i = []  # Vecteur de la ligne i dans la table
    for i in range(2**n):  # Pour n entrées, la table contient les lignes 0 <= i <= (2^n) - 1
        # Suppression de '0b' dans la représentation binaire de i
        binaire_i = bin(i)[2:] # pour i = 3 binaire_i='11'
        # conversion du nombre binaire_i en une liste de booléens
        for j in binaire_i:
            vecteur_i.append(int(j)) # pour i = 3 vecteur_i = [1,1]
        # si la taille du vecteur < n, il est complété par des 0
        for _ in range(n-len(vecteur_i)):
            vecteur_i.insert(0, 0) # pour i = 3 et n = 3 vecteur_i = [0,1,1]
        vecteur_i.append(vs[i])  # Ajout de la valeur attendue pour s 
                                 # pour i = 3, n = 3 et vs[i] = 1 vecteur_i = [0,1,1,1]
        # Ajout du vecteur i à la table des vecteurs
        vecteurs.append(tuple(vecteur_i))  # sous la forme d'un tuple
                          # pour i = 3, n = 3 et vs[i] = 1, on ajoute (0,1,1,1) à vecteurs
        vecteur_i = []  # on vide le vecteur i en cours pour le calcul du vecteur i+1
    return vecteurs

# Test de la sortie Rom
Roma = [0, 1, 0, 1, 0, 0, 0, 1]
tableVecteurs = creerVecteursTest(3, Roma)
print(tableVecteurs)

Activité 9. Synthèse

utilisez la fonction creerVecteurTest pour tester la sortie OE.

In [ ]:

# Code de test de OE avec la fonction creerVecteurTest
# Exécuter creerVecteursTest avant !!!!!!!!!!!!!!!!!
# --------------------------------------------------
OEa = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1] # OE attendu
Vecteurs_OE = creerVecteursTest(4, OEa)
print("[A15,A14,A13,A12] -> OEa OEo")
# Correction
for A15,A14,A13,A12,OEa in Vecteurs_OE:
    OEo = (A15 and A14 and A13 and A12) # Remplacer and par or pour simuler des erreurs dans la table
    if OEa == OEo:
        print(f"[{A15},{A14},{A13},{A12}] -> {OEa}, {int(OEo)}")
    else:
        print(f"[{A15},{A14},{A13},{A12}] -> {OEa}, {int(OEo)} -> Erreur")

In [ ]: