Bin vers BCD pour un compteur mod 100 en VHDL

[Matlabo]

Bonjour,
J'essaie d'implémenter un compteur modulo 100.

Je rencontre quelques problèmes avec la partie Bin2BCD.
Le fait est que l'incrémentation du chiffre des dizaines se fait deux par deux, ça passe de 0 à 2 puis à 4 etc... et je ne comprends pas
pourquoi ?

La structure du compteur mod100: schema.png

Code de la partie Bin2BCD: bin2bcd.txt


Merci pour toutes éventuelles aides

P.S: Voici également le code des autres blocs Codes.rar .
P.S2: J'exécute la simulation sur ISE et cela prend trop de temps. Un truc à me proposer pour réduire le temps de simulation ? (réduire la résolution temporelle ou un truc du genre)
-----

[Matlabo]

Voici le code de Bin2BCD pour ceux qui ne veulent pas forcément télécharger le fichier:

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;        -- for addition & counting
use ieee.numeric_std.all;               -- for type conversions


entity Bin_2_BCD is
port(  Q    : in std_logic_vector(3 downto 0);
	   co   : in STD_LOGIC;
	   unit : out std_logic_vector(3 downto 0);
	   diz  : out std_logic_vector(3 downto 0) := "0000"
	);
end Bin_2_BCD;

architecture Behavioral of Bin_2_BCD is

	signal compteur_diz : integer range 0 to 9 := 0;

begin	
	diz <= std_logic_vector(to_unsigned(compteur_diz,4));

	process (Q, co)
		begin
		if co = '1' then
				if compteur_diz = 9 then
					compteur_diz <= 0;
				else
					compteur_diz <= compteur_diz + 1;
				end if;

			unit <= "0000";
		else 
			unit <= Q;
		end if;
	end process;			



end Behavioral;

[jiherve]

bonsoir
que cherches tu à faire ?
un convertisseur binaire BCD , là c'est raté
ou bien un compteur modulo 10?
nota ton process s'active si c0 change d’état ou si Q change d’état, je te laisse réfléchir!
JR

[Matlabo]

un convertisseur binaire BCD , là c'est raté

Pourquoi ?
Regardez le schéma en pièce jointe, l'entrée du convertisseur Binaire BCD est la sortie de compteur modulo 10.

[A voir en vidéo sur Futura]

[jiherve]

Bonjour,
Si on utilise un compteur modulo 10 alors le résultat c'est déjà du BCD !?!?
JR

[Matlabo]

Bonjour,
L'idée de la partie Bin2BCD est d'incrémenter le chiffre des dizaines à chaque fois que Co = 1.
On peut se passer de Co et faire en sorte que le chiffre des dizaines s'incrémente à chaque fois que la sortie du compteur mod10 arrive à 9.

[jiherve]

re
si tu cascades des compteur modulo 10 en utilisant la carry pour autoriser l'incrementation du compteur de poids fort cela se fera tout seul, mais il te faudra un process synchrone, donc utilisant une horloge.
un convertisseur BinBCD ne se justifie que si les compteurs sont modulo 2^n et que l'on désire une valeur BCD.
https://en.wikipedia.org/wiki/Double_dabble.
JR

[Matlabo]

Il s'agit d'utiliser un seul compteur modulo 10, et lui cascader un bout de code qui aura comme sortie un chiffre sur 4 bits pour les unités et un autres pour les dizaines (du BCD donc).

Vous dîtes qu'il faudrait ajouter une horloge, du coup je suppose que le code va donner un truc du genre if rising_edge (clk) then vérifie si Co = 1 et incrémente le chiffre des dizaines

D'accord mais ça me parait un peu bancal, ne peut-on pas se passer de l'horloge ?

[jiherve]

re
j'ai essayé avec Modelsim et si les signaux Q et C0 sont tous issus de bascules cela fonctionne ; Par contre si c0 est généré de façon asynchrone ( t_c0 <='1' when unsigned(t_data_in)= 9 else '0'; ) alors cela compte par 2 ce qui est logique car tu passes deux fois dans l'instruction d’incrémentation de ton process , la première fois lorsque c0 passe a '1' avec Q = 9 et la seconde lorsque c0 étant encore à '1' Q repasse a zéro.
une affectation comme celle entre parenthèses induit toujours un "delta" entre l'entrée et la sortie.
L'usage d'un process synchrone pallie ce problème.
JR

[Matlabo]

Re;
Que voulez-vous dire par des signaux issus de bascules ? j'ai déjà lu quelque chose du genre que les processus créaient des flips flop et que des signaux d'entrés non inclus dans la liste de sensibilité du processus créaient des bascules (Latch), possible d'avoir plus d'explication sur ce sujet ?

L'usage d'un process synchrone pallie ce problème.

J'allais faire ceci, puis je me suis dit que je pouvais tout simplement enlever co de la liste de sensibilité et faire if Q = 9 on incrémente. Ça a marché mais je vais quand même essayer avec le process synchrone.

Je n'ai aussi pas compris ceci.

une affectation comme celle entre parenthèses induit toujours un "delta" entre l'entrée et la sortie.

Selon ce que j'ai compris un delta cycle n'est crée que lorsque l'exécution du code rencontre un wait ?

Je suis pas encore assez bon en VHDL.

Merci.

[jiherve]

re
non des qu’apparait "<=" il y a un delta c'est la grande différence entre un signal et une variable:
titi <= tata signifie qu'il faut attendre un delta avant qu'une modification de tata soit "visible" sur titi , c'est indispensable pour le déroulement des simulations , titi est un signal
tutu := toto , tutu est immédiatement modifié si toto change, tutu est une variable.
un peu de lecture :https://vhdlwhiz.com/delta-cycles-explained/
JR

[Matlabo]

Je venais justement de lire l'article
Un autre point que j'ai du mal à bien comprendre c'est pourquoi il faut de préférence inclure les entrées qui affectent la sortie du processus dans la liste de sensibilité ?

[jiherve]

Re
ben parce que tu as écrit çà unit <= Q; dans ton process.
Si Q n'est pas dans la liste de sensibilité alors ta sortie "unit" ne changera pas souvent car le process englobant ne se réveillera que sur les changements d’état de c0.
Tu peux faire la simulation pour t'en convaincre.
JR

[Matlabo]

Non la je parle du cas général. J'au cru comprendre qu'il n'était pas bon de ne pas inclure les entrées qui affectent la sortie du processus dans la liste de sensibilité, car cela créait des bascules (hein ?) ?! un système peu stable ?!
Merci.

[jiherve]

re
pour créer des bascules il faut :
soit un process clocké, auquel cas il n'y a pas besoin d'entrer autre chose que l'horloge et le reset(à ne pas oublier) mais ces bascule ne concerneront que les signaux explicitement utilisés , rajouter les autres signaux d'entrée serait nuisible car activerait le process de façon inutile et ralentirait les simulations sans produire rien d'utile.
soit un process asynchrone qui induit des latch de façon explicite par ses affectations dans ce dernier cas il sera nécessaire ou non de déclarer les signaux impactés.
JR

[Matlabo]

C'est très clair.

Merci pour votre temps !

[jiherve]

re
c'est avec plaisir que j'aide quelqu'un qui s'intéresse au VHDL.
JR

[Matlabo]

Re-Bonsoir,
J'ai essayé d'implémenter le code dans une carte FPGA, et .... ça n'a pas fonctionné.
Lors de la synthétisation (XST) sur ISE j'ai reçu ce Warning:

WARNING:Xst:737 - Found 4-bit latch for signal <compteur_diz>. Latches may be generated from incomplete case or if statements. We do not recommend the use of latches in FPGA/CPLD designs, as they may lead to timing problems.

En fait, le chiffre des unités est bien généré mais le chiffre des dizaines fait n'importe quoi, il affiche de valeurs aléatoires.
Je suppose que je devrais opter pour la solution synchrone ?

Merci pour d'éventuelles suggestions.

[Matlabo]

Compteur_diz est la variable que j'ai utilisé dans le process de ce code là: (Bin2BCD)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;        -- for addition & counting
use ieee.numeric_std.all;               -- for type conversions


entity Bin_2_BCD is
port(  Q    : in std_logic_vector(3 downto 0);
	   co   : in STD_LOGIC;
	   unit : out std_logic_vector(3 downto 0);
	   diz  : out std_logic_vector(3 downto 0) := "0000"
	);
end Bin_2_BCD;

architecture Behavioral of Bin_2_BCD is
begin
	process (Q, co)
		variable compteur_diz : integer range 0 to 9 := 0;
		begin
		if co ='1' then
				if compteur_diz = 9 then
					compteur_diz := 0;
				else
					compteur_diz := compteur_diz+1;
				end if;

			diz <= std_logic_vector(to_unsigned(compteur_diz,4));
			unit<="0000";
		else 
			unit <= Q;
		end if;
	end process;			
end Behavioral;

[Matlabo]

Je me suis trompé dans les postes #19 et #18.

ERRATUM 1:
Les warnings que j'ai eu:

WARNING:Xst:819 - "/home/senulo/Bureau/FPGA/Codes-20230424T214135Z-001/Codes/bin2bcd.vhd" line 22: One or more signals are missing in the process sensitivity list. To enable synthesis of FPGA/CPLD hardware, XST will assume that all necessary signals are present in the sensitivity list. Please note that the result of the synthesis may differ from the initial design specification. The missing signals are:
   <compteur_diz>
WARNING:Xst:737 - Found 4-bit latch for signal <compteur_diz>. Latches may be generated from incomplete case or if statements. We do not recommend the use of latches in FPGA/CPLD designs, as they may lead to timing problems.
WARNING:Xst:646 - Signal <co> is assigned but never used. This unconnected signal will be trimmed during the optimization process.
WARNING:Xst:1426 - The value init of the FF/Latch en100h hinder the constant cleaning in the block u_1.
   You should achieve better results by setting this init to 1.
WARNING:Xst:1426 - The value init of the FF/Latch en100h hinder the constant cleaning in the block diviseur.
   You should achieve better results by setting this init to 1.
WARNING:Xst:2677 - Node <u_1/u_2/co> of sequential type is unconnected in block <Top_counter_7Seg_mod100>.

*
Pour co je l'ai juste pas encore enlevé de tous les blocs de code, mais je ne l'utilise plus.
*


ERRATUM 2:
Le code Bin2BCD:

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;        -- for addition & counting
use ieee.numeric_std.all;               -- for type conversions


entity Bin_2_BCD is
port(  Q    : in std_logic_vector(3 downto 0);
	   --co   : in STD_LOGIC := '0';
	   unit : out std_logic_vector(3 downto 0);
	   diz  : out std_logic_vector(3 downto 0) := "0000"
	);
end Bin_2_BCD;

architecture Behavioral of Bin_2_BCD is

	signal compteur_diz : integer range 0 to 9 := 0;

begin	
	diz <= std_logic_vector(to_unsigned(compteur_diz,4));

	process (Q)
		begin
		if Q = "1001" then
				if compteur_diz = 9 then
					compteur_diz <= 0;
				else
					compteur_diz <= compteur_diz + 1;
				end if;

			unit <= "0000";
		else 
			unit <= Q;
		end if;
	end process;			


end Behavioral;