Comment éviter les verrous pendant la synthèse

Je veux concevoir un bloc de logique combinatoire à l'aide de VHDL, mais parfois le résultat synthétisé contient un verrou involontaire.

Quelles directives de codage dois-je suivre pour éviter que le synthétiseur infère des verrous?

Exemple: dans un petit segment de code, dois-je utiliser des instructions if-else?

Pour éviter les verrous, vous devez vous assurer que toutes vos sorties sont affectées à toutes les branches possibles du code.

par exemple,

if a = '1' then
   b(0) <= '1';
else
   b(1 downto 0) <= "00";
end if;

générerait un verrou, car dans la première condition, la valeur de b (1) n'est pas spécifiée, donc le compilateur a décidé que vous vouliez conserver la valeur précédente de b (1). Une façon d'écrire ceci qui ne générerait pas de verrou est:

if a = '1' then
   b <= prev_b;
   b(0) <= '1';
else
   b(1 downto 0) <= "00";
end if;

...

if rising_edge (clk)
    prev_b <= b;
end if;

Ici, vous indiquez explicitement que b doit conserver son ancienne valeur, puis remplacer b (0) par la nouvelle valeur.

Une autre façon est de donner une valeur par défaut à ba, comme dans la réponse de @ TomiJ.

Si vous publiez le code sur lequel vous obtenez un verrou, nous pourrions vous aider à trouver la raison spécifique.

Si vous utilisez des processus pour la logique combinatoire (et je le déconseille pour cette raison), assurez-vous que chaque chemin à travers le processus affecte quelque chose à chaque signal que le processus conduit. Aucune des sorties ne peut dépendre de l'une des sorties de la "dernière fois" que le processus s'est exécuté.

Sinon, vous déduisez un verrou car la prochaine fois que le processus est planifié, il doit conserver la valeur du signal qui n'a pas obtenu de nouvelle valeur la dernière fois.

Je préfère garder la logique purement combinatoire en tant qu'affectations continues et utiliser des processus pour la logique cadencée, alors je n'ai pas de verrous.

Quatre règles pour éviter les verrous:

• Ne lisez pas les signaux auxquels vous écrivez.
• Avoir une liste de sensibilité correcte (tous les signaux que vous lisez doivent être dans la liste de sensibilité)
• Assurez-vous que tous les signaux auxquels votre écriture est affectée dans chaque chemin. (par exemple: dans chaque branche d'une instruction if-else)
• Pour les processus qui utilisent une variable, assurez-vous que chaque variable est initialisée à une valeur par défaut avant de la lire (dans une autre variable ou un autre signal).

De plus, si vous avez plusieurs processus combinatoires, assurez-vous de ne pas créer de boucle.

Plusieurs styles de codage peuvent vous aider à respecter ces règles, par exemple le style dans la réponse de @ TomiJ. Comme le souligne @Martin Thompson, il peut être préférable d'éviter la logique combinatoire tous ensemble. Mettez tout à la place dans un processus cadencé.

Comme cela a été souligné par @fbo et @Martin Thompson, vous devez vous assurer que chaque signal piloté par le processus se voit attribuer une valeur dans chaque branche du processus, et cette valeur ne doit pas dépendre de l'état précédent de l'une des sorties du processus.

La façon la plus simple de garantir cela est d'attribuer une valeur par défaut à chaque sortie au tout début du processus, par exemple (exemple de cooptation de fbo):

COMBO: process(a)
begin
    b <= (others => '0'); -- Assign default value to b
    if a = '1' then
        b(0) <= '1';
    else
        b(1 downto 0) <= "00";
    end if;
end process COMBO;