[VHDL] Aiuto urgente

[tonio123]

So che come domanda è un po atipica, ma se qualcuno mi potesse aiutare gliene sarei grato.
Allora praticamente devo realizzare una rete asincrona con 2 ingressi A e B e 2 uscite P e Q. La rete parte con P e Q a "00", al primo fronte di salita di A la rete passa allo stato con uscite "01", in seguito al primo fronte di salita di B le uscite passano a "10", infine quando B torna a '0' le uscite ritornano a "00" e il processo può ripartire.
Il codice che sono riuscito a creare è il seguente

-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity asincrone_8 is
    Port ( A : in  STD_LOGIC;
           B : in  STD_LOGIC;
           P : inout  STD_LOGIC;
           Q : inout  STD_LOGIC);
end asincrone_8;

architecture Behavioral of asincrone_8 is
signal stato_interno_rete: STD_LOGIC_VECTOR(1 downto 0):="00"; --tiene traccia dello stato interno in cui si trova la rete
signal a_last: STD_LOGIC:='0'; --ultimo valore di a
signal b_last: STD_LOGIC:='0'; --ultimo valore di b

begin
	
	funzionamento : process(A, B, P, Q, a_last, b_last, stato_interno_rete ) is 
	begin
	
		case stato_interno_rete is
				when "00" => if a_last='0' and A='1' then  --transizione da fase 0 a fase 1
									P<='0'; Q<='1'; stato_interno_rete<="01";
									a_last<=A; b_last<=B;
									else --se non ci sono le condizioni per la transizione aggiorno i valori di a_last e b_last
									a_last<=A; b_last<=B;
									end if;
				when "01" => if b_last='0' and B='1' then  --transizione da fase 1 a fase 2
									P<='1'; Q<='0';  stato_interno_rete<="10";
									a_last<=A; b_last<=B;
									else
									a_last<=A; b_last<=B;
									end if;
				when "10" => if b_last='1' and B='0' then --transizione da fase 2 a fase 0
									P<='0'; Q<='0';  stato_interno_rete<="00";
									a_last<=A; b_last<=B;
									else 
									a_last<=A; b_last<=B;
									end if;
				when others=>	 a_last<=A; b_last<=B;	stato_interno_rete<="00"; 
		end case;
			
	end process funzionamento;
	
end Behavioral;

Quando vado a simularla funziona perfettamente facendo una simulazione funzionale, cioè basata solo sul codice. Mentre se faccio una simulazione post-sintesi e routing la rete smette di funzionare e le due uscite rimangono fisse sullo 0.
Spero di essere stato abbastanza chiaro, spero che qualcuno possa aiutarmi.
Grazie in anticipo.

[ingframin]

Che tool hai usato per la sintesi? Hai fatto la sintesi per FPGA o per un asic?

[tonio123]

Originariamente inviato da ingframin

Che tool hai usato per la sintesi? Hai fatto la sintesi per FPGA o per un asic?

Ho usato xilinx ISE e la sintesi è per FPGA

[starfred]

per esperienza, metti sempre dei FF agli ingressi. Spesso e volentieri risolve il problema

[tonio123]

Originariamente inviato da starfred

per esperienza, metti sempre dei FF agli ingressi. Spesso e volentieri risolve il problema

si ma è asincrona, non ho un clock con cui comandare i FF. Comunque saprei come realizzarla tramite schematico sintetizzandola direttamente, ma in questo caso la dovevo realizzare tramite codice vhdl e non riesco a farla funzionare una volta sintetizzata, anche se prima della sintesi funziona tutto perfettamente.

[kevinpirola]

Tu dici che secondo te non dovresti usare i flipflop, invece a me è venuta in mente una cosa del genere.

Si suppone che abbiamo come ingressi A e B.

Da come l'hai detto sai che A viene prima di B a quanto ho capito

perciò hai che al fronte di salita di A devi avere in uscita 01

e al fronte di salita di B devi avere 10.

Io l'ho immaginato così:

A ---- [Buffer Tristate]---C[FlipFlop T]--- uscita bit - signific
B --------|>--^
L---------------------C[FlipFlop T]--- uscita bit + signific (questa uscita è collegata all'ingresso di clock del flipflop sopra insieme alla linea che già c'è)

Un B_n va collegato al reset (che supporremo negato ovvero che si aziona a livello basso) del secondo flipflop.

Entrami i T sono collegati alla costante 1.

Succederà questo.

A sale a 1, B = 0 perciò il buffer tristate è aperto (tra b e il buffer c'è un inverter) il FlipFlop 1 sente un fronte di salita e commuta, T è 1 perciò nega il suo valore (che supponiamo aver settato inizialmente a 0). Avremo in uscita 01

A questo punto B sale da 0 a 1, disattiva il buffer, il secondo flipflop sente un fronte di salita e commuta da 0 (iniziale) a 1, essendo però questa uscita collegata anche al primo flipflop (al clock) anche esso sente un fronte di salita e commuta (da 1 di prima a 0). In uscita avrò perciò 10.

Quando B torna a 0 il flipflop B si resetta.



Io l'ho pensata così tu cosa ne dici? Come hai fatto tu l'analisi cartacea?