Concevez un bloc logique programmable
Implémentez plusieurs fonctions logiques
Le bloc logique programmable doit pouvoir implémenter toutes les fonctions logiques de base, à savoir INV, AND, NAND, OR, NOR, XOR, XNOR, etc. Plusieurs approches sont utilisées dans l'industrie des FPGA pour atteindre cet objectif.
La première approche consiste à utiliser un multiplexeur, la seconde à utiliser des tables (Look-Up-Table).
Exemple d'implémentation à base de multiplexeurs
Rappelons la table de vérité du multiplexeur, vue dans le cours "Concevez vos premiers circuits combinatoires" :
| en | i0 | i1 | f |
| 0 | 0 | x | 0 |
| 0 | 1 | x | 1 |
| 1 | x | 0 | 0 |
| 1 | x | 1 | 1 |
En résumé :
- La sortie du multiplexeur f = i0 si l'entrée de sélection en = 0
- La sortie du multiplexeur f = i1 si l'entrée de sélection en = 1
De manière assez surprenante, un multiplexeur à deux entrées peut être utilisé comme générateur de fonctions programmables, comme illustré dans le tableau ci-dessous.
| Fonction | Expression logique équivalente | i0 | i1 | en |
| BUF(A) | f=A | 0 | A | 1 |
| NOT(A) | f=~(A) | 1 | 0 | A |
| AND(A,B) | f=A&B | 0 | B | A |
| OR(A,B) | f=A|B | B | 1 | A |
Par exemple, l'inverseur (NOT) est créé si l'entrée i0 du multiplexeur est égale à 1, l'entrée i1 est égale à 0 et l'entrée de sélection en est connecté à A. Dans ce cas, la sortie f est le ~ A. Cela veut donc dire qu'il suffit de programmer les entrées i0, i1 et en pour obtenir des fonctions logiques différentes.
La figure ci-dessous décrit l'utilisation du multiplexeur pour produire les fonctions OR, NOT, AND et BUF.
Configuration d'un multiplexeur 2 entrées en différentes fonctions logiques élémentaires
D'autres fonctions logiques, telles que NAND, NOR et XOR ne peuvent pas être créées directement à l'aide d'un seul multiplexeur à 2 entrées.
Elles nécessitent au moins deux circuits de multiplexage, comme illustré ci-dessous pour la porte XOR.
Réalisation d'une porte XOR 2 entrées avec 2 multiplexeurs
Look-Up-Table (LUT) utilisé dans les FPGA
La table de correspondance (Look-Up-Table ou LUT) est de loin le circuit le plus polyvalent pour créer une fonction logique configurable. Le tableau de correspondance présenté ci-dessous comporte 3 entrées F0, F1 et F2. La sortie est Fout, dont la valeur logique dépend de F0, F1 et F2. La sortie Fout est définie par les valeurs attribuées à Value[0] .. Value[7]. Les trois entrées F0, F1, F2 représentent en fait une adresse sur 3 bits, comprise entre 0 et 7, qui place en sortie la donnée stockée dans Value[i].
N'importe quelle table de vérité peut être stockée dans Value[i], ce qui rend cette architecture très versatile.
Dans l'exemple ci-dessous, l'entrée F0=1, F1=0, F2=1 active l’adresse @5, le contenu de la mémoire Value[5] est acheminé vers Fout.
![Principe de la Look-Up-Table - 8 cases Value[i] selon la valeur de F0..2, produisant une sortie Fout](https://user.oc-static.com/upload/2019/05/24/15586995217041_M3P4C2-FPGA-LUT.PNG)
Principe de la Look-Up-Table - 8 cases Value[i] selon la valeur de F0..2, produisant une sortie Fout
Dans l'exemple ci-dessous, on a réalisé la fonction "F0 & F1" en programmant des 0 et des 1 dans les cellules Value[x] , de telle sorte que lorsque la cellule est connectée à la sortie grâce à l'adresse binaire formée par F2 F1 F0 , la sortie prenne la valeur de NOT (F0).
| F2 | F1 | F0 | V(7) | V(6) | V(5) | V(4) | V(3) | V(2) | V(1) | V(0) | FOUT=NOT(F0) |
| 0 | 0 | 0 | 0 | V(0) | |||||||
| 0 | 0 | 1 | 0 | V(1) | |||||||
| 0 | 1 | 0 | 0 | V(2) | |||||||
| 0 | 1 | 1 | 1 | V(3) | |||||||
| 1 | 0 | 0 | 0 | V(4) | |||||||
| 1 | 0 | 1 | 0 | V(5) | |||||||
| 1 | 1 | 0 | 0 | V(6) | |||||||
| 1 | 1 | 1 | 1 | V(7) |
La table des valeurs Value[i] correspondant à quelques fonctions communes est donnée ci-dessous.
![Valeurs stockées dans la mémoire Value[i] pour réaliser quelques fonctions logiques élémentaires](https://user.oc-static.com/upload/2019/05/29/15591332808638_M3P4C2-FPGA-LUT-examples.PNG)
Valeurs stockées dans la mémoire Value[i] pour réaliser quelques fonctions logiques élémentaires
Une LUT à 4 entrées — et donc 16 valeurs Value[i] — peut aussi être réalisée. Il n'existe toutefois dans DSCH qu'une LUT à 3 entrées.
Exemple : porte XOR 3 entrées
Dans le cas du XOR à 3 entrées (F0^F1^F2), la séquence Value[i] est 01101001. Ce sont ces valeurs qui sont prépositionnées sur les 8 entrées du schéma ci-dessous. Nous devons affecter manuellement la table de vérité désirée (tableau ci-dessus) à chacun des 8 boutons Value[i]. Une fois la programmation effectuée, la sortie Fout vaut F0 XOR F1 XOR F2. Par exemple, si F0=0, F1=0 et F2=1, Fout vaut 1. On peut ainsi vérifier toutes les combinaisons d’entrées.
Programmation du LUT pour obtenir une porte XOR 3 entrées
Les points mémoire sont des composants essentiels des blocs logiques configurables. Le point mémoire est utilisé pour stocker une valeur logique, correspondant à une information élémentaire de la table de vérité. Pour une fonction à 3 entrées (F0, F1, F2 dans la LUT précédente), nous avons besoin d'un ensemble de 8 points mémoire pour stocker les informations Value [0] .. Value [7]. Il existe plusieurs approches pour stocker un seul bit d’information. Celle illustrée ci-dessous est constituée de cellules D-reg.
Chaque registre stocke une information logique Value[i]. Les cellules Dreg sont chaînées afin de limiter les signaux de commande à une horloge ClockProg et à un signal de données DataProg.
Ajout de points mémoire D-Reg pour stocker la table de vérité de la fonction désirée - Donnée injectée via "DataProg" dans les registres reg7..0 : 1,0,0,1,0,1,1,0
Programmation du point mémoire
La donnée logiqueValue[i] est entièrement programmée par un mot de 8 bits envoyé en série au signal DataProg. L'assignation des 8 données élémentaires de la table nécessite 8 cycles d'écriture en chaîne. La configuration obéit donc à un protocole et des séquences temporelles strictes, comme décrit ci-dessous.
Une série de 8 fronts actifs doit être générée sur le signal ClockProg (le registre Dreg est actif sur les fronts descendants de l'horloge, donc au moment du passage de 1 à 0). Sous DSCH, nous utilisons un générateur d'impulsions "PWL" (Piece-Wise-Linear) dans le menu "Advanced", item "Sources", que nous configurons avec une série de 0-1 comme indiqué ci-dessous. Il faut s'assurer que 8 transitions 1 vers 0 sont générées, ni plus ni moins.
Création de 8 fronts actifs sur ClockProg
À chaque front actif, le registre à décalage est alimenté par une nouvelle valeur présentée séquentiellement à l'entrée DataProg. Comme le registre D est actif sur le front descendant, les données peuvent être modifiées sur chaque front montant. Notez que la dernière donnée de DataProg correspond à Value [7]. Par conséquent, Value[7] doit être inséré en premier et Value[0] en dernier. Cela signifie que DataProg doit décrire la table de vérité dans l'ordre inverse, comme indiqué ci-dessous. Nous utilisons un deuxième élément PWL pour DataProg.
Synchronisation des données du LUT avec l'horloge - La donnée Data est modifiée quand Clock est inactif (à gauche). La donnée est stockée à un front actif de l'horloge. Quand Clock est désactivé (à droite), la XOR3 est opérationnelle
La fonction XOR est complétée quand le dernier front actif a permis de stocker la dernière donnée. Les fils DataProg et ClockProg sont inactifs et le calcul de F0 XOR F1 XOR F2 peut alors débuter.
Symbole LUTDans DSCH, un symbole LUT est proposé dans le menu de symboles > Advanced > Switches.
Une propriété importante du symbole LUT est sa capacité à conserver la programmation interne comme le ferait une mémoire non volatile.
L'interface utilisateur du symbole LUT est donnée à la figure ci-dessous.
Symbole LUT avec 3 modes de déclaration de la table de vérité
Il y a trois manières de remplir la table de vérité :
- En définissant chaque élément du tableau avec un 0 ou un 1, en haut à gauche dans la colonne "Value ". Par exemple, le n°4 est codé 100 en binaire, ce qui correspond à F2 = 1, F1 = 0 et F0 = 0. Pour cette combinaison d'entrées, Value vaut 1.
- En choisissant la description de la fonction dans la liste. Les informations logiques Fout affectées à chaque combinaison d'entrées mettent à jour la table de vérité.
- Une troisième solution est également proposée : saisir une description basée sur les entrées F0, F1 et F2, combinant différents opérateurs logiques "~" (NON), "& '(ET)," | "(OR) et" ^ "(XOR). Cliquez ensuite sur le bouton "Fill LUT" pour transférer le résultat de l'expression dans la table.
Dans ce chapitre, vous avez appris à programmer et implémenter des fonctions logiques sur FPGA. Dans le chapitre suivant, vous découvrirez le point d'intersection programmable.
