VHDL binaire de 4 bits diviseur

Je suis en train de faire un diviseur binaire de faire partie d'une calculatrice à l'aide de VHDL, j'ai écrit le code qui je pense devrait fonctionner, mais ont été bloqués pendant des heures, quelqu'un peut s'il vous plaît aider moi.

    library IEEE;
    use IEEE.STD_LOGIC_1164.ALL;
    use IEEE.STD_LOGIC_ARITH.ALL;
    use IEEE.STD_LOGIC_UNSIGNED.ALL;


    entity Div is
    Port ( Ain   : in  STD_LOGIC_VECTOR (3 downto 0);
       Bin   : in  STD_LOGIC_VECTOR (3 downto 0);
       Q   : out  STD_LOGIC_VECTOR (3 downto 0);
       R   : out  STD_LOGIC_VECTOR (3 downto 0));
    end Div;

architecture Behavioral of Div is
Signal Atemp : Std_Logic_Vector (3 downto 0);
begin


Proc1: Process (Ain,Bin, Atemp)
variable cnt : STD_LOGIC_Vector(3 downto 0);
begin


if (Ain < Bin) then
        cnt := "0000";
        Atemp <= Ain;
elsif (Ain = Bin) then
        cnt := "0001";
elsif (Ain > Bin) then
        cnt := "0001";
        Atemp <= (Ain - Bin);
        while (Atemp >= Bin) loop
            if(Atemp >=Bin) then
                Atemp <= (Atemp - Bin);
                cnt := cnt + "0001";
            end if;
        end loop;
end if;
Q <= cnt;
R <= Atemp;
end process Proc1;
end Behavioral;

De quoi êtes-vous coincé sur? Avez-vous des erreurs de compilation? Êtes-vous à la simulation de votre conception? Nous avons besoin de plus de détails sur ce que votre problème spécifique.
je reçois des avertissements AVERTISSEMENT:Xst:1710 - FF/Loquet <0> (sans initialisation de la valeur) a une valeur constante de 0 dans le bloc <2>(<3><div>). Ce FF/Loquet sera revue à la baisse au cours du processus d'optimisation. et ATTENTION:Xst:737 - 4-bits loquet pour signal <cnt> (et Atemp). Loquets peuvent être générés à partir incomplète cas ou si des instructions. Nous ne recommandons pas l'utilisation de verrous dans le FPGA/CPLD dessins, car ils peuvent conduire à des problèmes de calendrier.

InformationsquelleAutor user3034001 | 2013-11-25

3

Dans l'itération partie de la ligne de partage processus, lorsque Ain > Bin, l'affecter
Atemp <= (Ain - Bin) est toujours effectuée, même si l'itération doit être
terminé. Processus d'attribuer à un signal aussi de la sensibilité de la liste, est
dur pour obtenir le droit.

Le code peut être mis à jour avec Atemp comme une variable à la place, quelques autres
simplifications à l'enlèvement de la unrequired code, et en ajoutant de la valeur pour le reste
lorsque Ain = Bin, résultant dans l'architecture comme:
```
architecture Behavioral of Div is
begin

  Proc1 : process (Ain, Bin) is
    variable cnt   : std_logic_vector(3 downto 0);
    variable Atemp : std_logic_vector(3 downto 0);
  begin
    if (Ain < Bin) then
      cnt   := "0000";
      Atemp := Ain;
    elsif (Ain = Bin) then
      cnt := "0001";
      Atemp := (others => '0');  -- Added to give correct remainder
    elsif (Ain > Bin) then
      cnt   := "0001";
      Atemp := (Ain - Bin);
      while (Atemp >= Bin) loop
        -- Removed trivial true if statement, since condition identical to condition in while
        Atemp := (Atemp - Bin);
        cnt   := cnt + "0001";
      end loop;
    end if;
    Q <= cnt;
    R <= Atemp;
  end process Proc1;

end Behavioral;
```
Le processus intérieur déclarations peuvent effectivement être réduite à:
```
cnt   := "0000";
Atemp := Ain;
while (Atemp >= Bin) loop
  Atemp := (Atemp - Bin);
  cnt   := cnt + "0001";
end loop;
Q <= cnt;
R <= Atemp;
```
Si cela se synthétiser de la fréquence avec le déroulé
while est une autre question, qui dépend de la cible de la fréquence et de
de la technologie.

Une solution alternative, étant donné le peu de Ain et Bin, est de mettre en œuvre la
diviseur à l'aide d'une constante recherche de la table, avec adresse Ain & Bin et de sortie
de Q & R. Cela permettra d'évaluer en temps fixe, et la synthèse est très probable
réduire considérablement si le fait que la logique combinatoire.

Dernier commentaire, c'est que vous pouvez également gérer la division par zéro, lorsque Bin
est égal à zéro.
- Merci @MortenZdk, cela a bien fonctionné, tout ce que j'avais à faire, c'est ajouter ET (cnt < "1111") de la boucle while de sorte que le compilateur acceptera qu'il n'était pas infinie.
- si cette solution a fonctionné pour vous, veuillez cliquez sur la Case à cocher en regard de la réponse pour la question est marqué comme réponse.
InformationsquelleAutor Morten Zilmer

Afin d'éviter des erreurs, il est conseillé d'utiliser explicitement le type non signé ou signé lors de la mise en œuvre des circuits arithmétiques. Le numeric_std paquet contient les opérateurs arithmétiques suivants pour les types suivants: +, -, *, /, abs, rem, mod.

Proposée ci-code (non signé) de la division. Notez que certaines lignes de l'arc peuvent être éliminés, mais ont été utilisés pour rendre le code plus "didactique".

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity divider is
  generic (size: natural := 4);
  port ( 
    A: in std_logic_vector(size-1 downto 0);
    B: in std_logic_vector(size-1 downto 0);
    Q: out std_logic_vector(size-1 downto 0);
    R: out std_logic_vector(size-1 downto 0));
end entity;

architecture direct of divider is 
  signal Auns, Buns, Quns, Runs: unsigned(size-1 downto 0);
begin 

  --Convert inputs to unsigned:
  Auns <= unsigned(A);
  Buns <= unsigned(B);

  --Do the division:
  Quns <= Auns/Buns;
  Runs <= Auns rem Buns; --Or: Runs <= Auns - resize(Quns*Buns, size);

  --Covert results to std_logic_vector:
  Q <= std_logic_vector(Quns);
  R <= std_logic_vector(Runs);  

end architecture

InformationsquelleAutor VAP

Vous devez vous connecter pour publier un commentaire.