machine d'état de moore en vhdl

[Momo54500]

Bonjour à tous

voilà j'essaie de réaliser la machine d'états suivante en vhdl :

Capture.PNGCapture.PNG

voilà mon code VHDL :

Library ieee;
USE ieee.std_logic_1164.all;
Entity exemple is 
port( --Inputs	
		E : in std_logic;
		clk, reset : in std_logic;
		Sout : out std_logic);
		
end exemple;

Architecture MyExemple of exemple is

		type state is (Q0, Q1, Q2);
		signal etat, etat_f : state;
		
	
Begin

P1 : process(clk, reset) -- Registre
begin

if(reset = '1') then
	etat <= Q0;
elsif(rising_edge(clk)) then
	etat <= etat_f;
end if;
end process P1;

P2 : process(etat) -- Description des sorties
begin

if(etat = Q0) then
	Sout <= '0';
elsif(etat = Q1) then
	Sout <= '1';
else
	Sout <= '0';
	
end if;
end process P2;

P3 : process(etat, E) -- Circuit d'excitation
begin

case(etat) is
	When Q0 => if (E = '0') then etat_f <= Q1;
				else
					etat_f <= Q2;
				end if;
	When Q1 => if (E = '1') then	etat_f <= Q2;
					else
						etat_f <= etat;
					end if;
	When Q2 => if (E = '0') then etat_f <= Q1;
					else
						etat_f <= etat;
					end if;
	When others => etat_f <= Q0;
		
end case;
end process P3;
			
end MyExemple;

cependant quand je mets "state machine Viewer" ça m'affiche ça :

Capture1.PNG

Si quelqu'un a une solution je suis preneur car franchement je ne vois pas du tout.

Merci à vous.
-----

[jiherve]

bonjour,
le code semble correct mais mefiance avec le compilo donc essaye de mettre l’évolution de la machine dans le process synchrone, plus besoin de "etat_f"
voir là :https://www.intel.com/content/www/us...e_machines.htm
nota : lorsqu'un signal ne change pas le "else" est inutile.
JR

[Momo54500]

Bonjour,

en effet j'ai changé et ça a marché. Mais c'est bizarre parce que parfois quand je fais avec 3 process ça marche et parfois non.

[jiherve]

bonsoir
je n'ai jamais été partisan du codage de machines à états dans deux process , l'un synchrone et l'autre asynchrone même si c'est normalement possible car cela "permet" d'introduire des entrées asynchrones(car on oublie le process synchrone en pissant l'asynchrone) et donc à terme un énorme bug du à la métastabilité(du vécu qui aurait pu être catastrophique, je n’étais pas le codeur mais le pompier) , ici l'entrée E doit être considérée comme asynchrone par défaut il faut donc la resynchroniser.

Il eut fallu peut être passer par une variable pour état_f et placer P3 avant P1 certains compilo sont capricieux
quel compilateur ?
JR

[A voir en vidéo sur Futura]

[Momo54500]

Bonsoir merci à vous pour votre réponse.

J'utilise Quartus, pour les machines à états vous utilisez 3 process? C'est à dire metastabilité?

[jiherve]

bonjour,
non en général je ne crée qu'un seul et unique process c'est plus compréhensible.
La métastabilité c'est le phénomène qui advient lorsqu'une bascule échantillonne un signal qui ne respecte pas son setup min ou son hold;
Dans ce cas ,suivant la technologie de la bascule alors la sortie peut prendre un état qui n'est ni l’état haut ni l’état bas donc un niveau de tension intermédiaire et ce pendant plusieurs ns voire dizaines de ns , ou bien produire un pulse dont la durée ira de qqs dizaines de ps jusqu’à qqs ns , ce phénomène représente 99% des bug souvent gravissimes dormants dans les ASIC/FPGA.
Dans le cas d'une machine à états où il y a plusieurs bascules pouvant être excitées par le même signal asynchrone celles ci pourront alors prendre un état non prévu par le concepteur car la zone de métastabilité est propre à chaque bascule ainsi sur une transition 0 1 du signal d'entrée une bascule verra le 1 car son setup sera satisfait, mais sa voisine pourra conserver son 0 et une troisième partir en vrille.
Le "when others" indispensable pour "intercepter" les états surnuméraires du VHDL ne pourra pas faire grand chose.
Donc on retient : jamais signal asynchrone tu n'entreras dans une machine.
La resynchronisation s'obtient par 2 bascules cascadées si tant est que la fréquence d'horloge et les caractéristiques de métastabilité des bascules le permettent.
C'est un sujet assez souvent ignoré par les simples pisseurs de code.
JR