Comment écrivez-vous le code Verilog pour l’encodeur de cabine modifié ?
module modifié_booth_encoder (
multiplicande d'entrée [3:0], // multiplicande 4 bits
multiplicateur d'entrée [3:0], // multiplicateur 4 bits
produit de sortie [7:0] // produit 8 bits
);
// Registres internes des produits partiels
reg [7:0] produit_partial [0:3] ;
// Initialisation des produits partiels à 0
début initial
produit_partial[0] <=0 ;
produit_partial[1] <=0 ;
produit_partial[2] <=0 ;
produit_partial[3] <=0 ;
fin
// Logique d'encodage Booth
toujours @(*) commencer
// Parcourir chaque bit du multiplicateur
pour (entier i =0; i <4; i =i + 1) commencer
// Vérifie les modèles d'encodage du stand
cas ({multiplicateur[i], multiplicateur[i-1]})
2'b00 :début
produit_partial[i] <=produit_partial[i];
fin
2'b01 :début
partial_product[i] <=partial_product[i] + multiplicande ;
fin
2'b10 :début
partial_product[i] <=partial_product[i] - multiplicande ;
fin
2'b11 :début
produit_partial[i] <=produit_partial[i];
fin
par défaut :commencer
produit_partial[i] <=produit_partial[i];
fin
cas final
fin
fin
// Calculer le produit final
attribuer un produit =partial_product[0] + (partial_product[1] <<1) + (partial_product[2] <<2) + (partial_product[3] <<3) ;
module final
```
Explication :
1. Entrées et sorties :
- `multiplicande` :entrée 4 bits représentant le multiplicande.
- `multiplicateur` :entrée 4 bits représentant le multiplicateur.
- `product` :sortie 8 bits représentant le produit du multiplicande et du multiplicateur.
2. Registres internes :
- `partial_product` :Un tableau de 4 registres, chacun stockant un produit partiel. Ces registres seront mis à jour en fonction du codage Booth.
3. Initialisation :
- Le bloc initial met tous les registres de produits partiels à 0 au début.
4. Logique d'encodage du stand :
- Le bloc `always @(*)` implémente l'algorithme d'encodage Booth.
- Il parcourt chaque bit du multiplicateur (de MSB à LSB).
- Pour chaque bit, il vérifie le bit actuel et le bit précédent pour déterminer le modèle de codage Booth.
- En fonction du modèle, il effectue l'opération appropriée sur le produit partiel :
- 00 : Aucune opération (le produit partiel reste inchangé).
- 01 : Ajoutez le multiplicande au produit partiel.
- 10 : Soustrayez le multiplicande du produit partiel.
- 11 : Aucune opération (le produit partiel reste inchangé).
5. Calcul du produit final :
- L'instruction `assign` calcule le produit final en ajoutant les produits partiels décalés.
- Chaque produit partiel est décalé vers la gauche de sa position de bit correspondante.
Fonctionnement du code :
L'algorithme de codage Booth modifié remplace le processus de multiplication par une série d'additions et de soustractions basées sur les modèles du multiplicateur. En inspectant des paires de bits consécutifs dans le multiplicateur, nous pouvons effectuer efficacement la multiplication.
Exemple :
Supposons que « multiplicande =5 » (binaire :« 0101 ») et « multiplicateur =3 » (binaire :« 0011 »).
1. Itération 1 : `multiplicateur[3:2] =00` - Aucune opération.
2. Itération 2 : `multiplier[2:1] =01` - Ajoutez `multiplicande` à `partial_product[1]`.
3. Itération 3 : `multiplicateur[1:0] =11` - Aucune opération.
Après la boucle, nous aurons :
- `produit_partial[0] =0`
- `produit_partial[1] =5`
- `produit_partial[2] =0`
- `produit_partial[3] =0`
Enfin, `product =0 + (5 <<1) + (0 <<2) + (0 <<3) =10` (binaire :`1010`), qui est le produit correct de 5 et 3.