Logisim est un logiciel qui permet de concevoir visuellement des circuits simples.
On distingue traditionnellement deux types de circuits :
- Les circuits logiques combinatoires, dont, à chaque instant, les sorties ne dépendent que des entrées.
- Les circuits logiques séquentiels, dont, à chaque instant, les sorties dépendent des entrées et de l'état courant. Dans un circuit séquentiel, l'état courant reflète les entrées passées. Un tel circuit utilise nécessairement des composants permettant de mémoriser de l'information (p.ex. bascules, registres, ...).
Dans les exercices qui suivent, on se concentre sur les circuits logiques combinatoires.
[[_TOC_]]
## Un premier circuit
Réaliser un premier circuit comportant deux entrées sur 1 bit nommées $`a`$ et $`b`$, et une sortie $`s = a.b + \bar{a}.b`$.
## Décodeur et Encodeur
Un décodeur k-n est un circuits ayant $`k`$ entrées 1 bit (étiquetée de $`0`$ à $`k-1`$), et $`n`$ sorties 1 bits (étiquetées de $`0`$ à $`n-1`$), avec $`n`$ et $`k`$ tels que $`n = 2^k`$.
Ce circuit calcule la fonction suivante : la seule sortie à 1 est celle dont l'étiquette correspond au nombre binaire codé par les entrées.
Un encodeur n-k est un circuits ayant $`n`$ entrées 1 bit (étiquetée de $`0`$ à $`n-1`$), et $`k`$ sorties 1 bits (étiquetées de $`0`$ à $`k-1`$), avec $`n`$ et $`k`$ tels que $`n = 2^k`$, et qui calcule la fonction inverse d'un décodeur.
On suppose dans ce cas qu'une seule des entrées est à 1, dans le cas contraire, la sortie n'est pas définie (pour )
1. Donner les tables de vérité puis les équations d'un décodeur 2-4 et d'un encodeur 4-2.
2. Construire et vérifier les circuits correspondants dans Logisim, puis les utiliser dans un troisième circuit qui à 4 entrées, 4 sorties, et calcule la fonction identité.
## Multiplexeur
Dans l'exercice 3 de la feuille d'exercice "calcul booléen et circuits combinatoires", vous avez étudié le multiplexeur.
1. Créer un circuit multiplexeur à 4 entrées de données.
2. Créer un circuit démultiplexeur à 4 sorties.
3. Créer un circuit disposant de 2 entrées de données $`a`$ et $`b`$ et deux entrées de commande $`c_0`$ et $`c_1`$, et d'une sortie $`s`$ et qui réalisent la fonction suivante :
$`c_0`$ | $`c_1`$ | $`s`$ |
--- | --- | --- |
$`0`$ | $`0`$ | $`\bar{a}`$ |
$`0`$ | $`1`$ | $`a + b`$ |
$`1`$ | $`0`$ | $`a . b`$ |
$`1`$ | $`1`$ | $`\overline{a.b}`$ |
## Additionneur 4 bits "efficace"
Dans l'exercice 4 de la feuille d'exercice "calcul booléen et circuits combinatoires", vous étudier un circuit additionner efficace avec calcul anticipé des retenues.
1. Créer et valider un circuit additionneur 1 bit avec trois entrées sur 1 bit $`a`$, $`b`$ et $`r`$ (la retenue entrante), et 3 sorties sur un bit $`s`$ (le bit de poids faible de la somme de $`a`$ et $`b`$), $p$ (à 1 ssi la somme propage une retenue), et $g$ (à 1 ssi la somme engendre une retenue).
2. Créer et valider un circuit de calcul des retenues entrantes $`r_0`$ à $`r_3`$ en fonction d'une retenue initiale $`r`$ et des bits $`p`$ et $`g`$ calculés par les additionneurs 1 bit.
3. Créer et valider un circuit additionneur 4 bits à partir des circuits précédents.
4. Question optionnelle pour celles et ceux qui auront le temps : créer un circuit additionneur 16 bits à partir de 4 circuits additionneurs 4 bits (et d'un autre circuit permettant d'assurer leur interconnexion).
## Une mini UAL (Unité Arithmétique et Logique)
Dans un processeur, une Unité Arithmétique et Logique (UAL) est une unité de calcul, qui permet d'appliquer des opérations d'arithmétique entière (au minimum addition et soustraction), de logiques booléennes (négation, conjonction, disjonction), et parfois quelques opérations plus spécifique (p.ex. décalage, ou rotation). Le plus souvent, ces opérations sont appliquées sur les données contenues dans les registres et/ou des constantes. L'UAL sera souvent la seule unité de calcul d'un petit micro-contrôleur, tandis qu'un processeur haute performance moderne comptera une multitude d'unité de calcul, dont plusieurs UAL, des unités de calcul flottant, des unités vectorielles, etc.
L'objectif de cet exercice est de réaliser une UAL simple avec Logisim.
Votre UAL comportera :
- deux entrées de données, sur 16 bits, nommées `R1` et `R2` ;
- une entrée de commande, sur 3 bits, nommée `CMD`, qui code l'instruction à exécuter ;
- une sortie de données, sur 16 bits, nommées `S` ;
- une sortie de status, sur 3 bits, nommées `SR` (pour Status Register).
### Les opérations de l'UAL
`CMD`|`S`| Commentaire |
--- | --- | --- |
`000` | `S = R1 + R2` | addition
`001` | `S = -R1` | opposé
`010` | `S = R1 & R2` | conjonction (et bit à bit)
`011` | `S = R1 \| R2` | disjonction (ou bit à bit)
`100` | `S = R1 ^ R2` | disjonction exclusive (ou exclusif bit à bit)
`101` | `S = ~R1` | complément à un (non bit à bit)
`110` | `S = R1>>R2` | décalage à droite
`111` | `S = R1<<R2` | décalage à gauche
### Les bits de status
Les bits de status sont mis à jour automatiquement lors de chaque opération de l'UAL en fonction de la valeur du `S`.
Ils permettent d'une part de faire des comparaisons entre nombre (p.ex. plus grand, plus petit, égal, ...).
Et d'autre part d'identifier quand une opération arithmétique déborde, c'est-à-dire que son résultat nécessite plus de bit que ce qui est disponible pour être codé.
L'UAL à construire comportera 3 bits de status :
-`SR0`, le bit de poids faible, est à `1` ssi `S == 0`
-`SR1`, le second bit, est à `1` ssi la retenue sortante de l'additionneur est à `1`
-`SR2`, le bit de poids fort, est à `1` ssi le résultat de l'opération arithmétique est négatif, c'est-à-dire si le bit de poids fort de `S` est à 1.
**Question optionnelle** : comment construire un 4ème bit de status indiquant qu'une opération arithmétique a débordé si on considère ses opérandes et son résultat comme étant codé en complément à 2 ?
