statemachine if else vhdl

Dat blijft toch een if else, ook in je statemachine?

Stel dat je vb. met een switch case de state controleert:

if(rising_edge(clk)) then
 case state is
  when state1 =>
   if(blabla) then
    --doe dit;
   else
    --doe dat
   end if;
  end case;
end if;

Of bedoel je iets anders?

[Bericht gewijzigd door jommeke op vrijdag 25 december 2009 15:46:44 (38%)]

En je hebt het woordje PROCESS (en aanhang) nog nodig:
http://www.people.vcu.edu/~rhklenke/tutorials/vhdl/modules/m12_23/sld0…

Ik boel het dan in deze vorm.

maar deze is ook maar van het web geplukt dus weet ook niet wat hier gebeurt.

Ge kunt zo'n statemachinetjes vb. tekenen met Active-HDL en hem dan zelf de VHDL laten genereren.

Voor een synchrone automaat wordt dit bijvoorbeeld:

architecture parking_architecture of parking is

-- SYMBOLIC ENCODED state machine: Detection
type Detection_type is (
    S2, S3, S4, S1
);
-- attribute enum_encoding of Detection_type: type is ... -- enum_encoding attribute is not supported for symbolic encoding

signal Detection, NextState_Detection: Detection_type;

-- Declarations of pre-registered internal signals
signal next_Counter: INTEGER range 0 to 200;

begin

-- concurrent signals assignments

-- Diagram ACTION

----------------------------------------------------------------------
-- Machine: Detection
----------------------------------------------------------------------
------------------------------------
-- Next State Logic (combinatorial)
------------------------------------
Detection_NextState: process (A, B, Counter, Detection)
-- machine variables declarations
variable Count1: INTEGER range 0 to 200;

begin
	NextState_Detection <= Detection;
	-- Set default values for outputs and signals
	next_Counter <= Counter;
	case Detection is
		when S2 =>
			if A='1' then	
				NextState_Detection <= S3;
			elsif B='0' then	
				NextState_Detection <= S1;
			else
				NextState_Detection <= S2;
			end if;
		when S3 =>
			if A='0' then	
				NextState_Detection <= S2;
			elsif B='0' then	
				NextState_Detection <= S4;
				Count1 := Count1+1;
				next_Counter <= Count1 after 5 ns;
			else
				NextState_Detection <= S3;
			end if;
		when S4 =>
			if A='0' then	
				NextState_Detection <= S1;
			elsif B='1' then	
				NextState_Detection <= S3;
				Count1 := Count1-1;
				next_Counter <= Count1 after 5 ns;
			else
				NextState_Detection <= S4;
			end if;
		when S1 =>
			if A='1' then	
				NextState_Detection <= S4;
			elsif B='1' then	
				NextState_Detection <= S2;
			else
				NextState_Detection <= S1;
			end if;
--vhdl_cover_off
		when others =>
			null;
--vhdl_cover_on
	end case;
end process;

------------------------------------
-- Current State Logic (sequential)
------------------------------------
Detection_CurrentState: process (Clk)
begin
	if Clk'event and Clk = '1' then
		Detection <= NextState_Detection;
	end if;
end process;

------------------------------------
-- Registered Outputs Logic
------------------------------------
Detection_RegOutput: process (Clk)
begin
	if Clk'event and Clk = '1' then
		Counter <= next_Counter;
	end if;
end process;
end architecture;

Je merkt mooi de opsplitsing tussen het combinatorische gedeelte (berekening van de nieuwe toestanden en outputs op basis van vorige toestanden en inputs) en het sequentiele gedeelte (de flipflops in de terugkoppeling) die op de stijgende klokflank de nieuwe toestand laten doorpropageren.

Dit is een veilige oplossing...

Da's inderdaad een nette opsplitsing van je comb en sequentiele deel. Die opsplitsing is o.a handig als je veel uitgangssignalen hebt. Als je de hele statemachine in een clocked process hebt staan, en van daaruit ook je uitganssignalen toekend, dan worden dat allemaal flipflops in hardware. Dat kan duur worden, EN het geeft een vertraging van een clock cycle. Je kunt ze ook vanuit het combinatorische process toekennen. Je krijgt dan een Mealy machine.

Daar denkt een ASIC engineer natuurlijk aan die flipflops wil sparen

Nooit een blok verlaten met combinatorische signalen.... baaaad idea.
voor je het weet knop een of andere hufter dat aan een i/o poot en dan kijken ze raar op als de ganse zwik glitcht tot en met ..

Of je wel of niet wilt registeren op block boundaries hangt helemaal van je totale design af. Als je overal uit princiepe een FF tussen hangt, dan gaat je performance van je design wel heel erg achteruit. Vaak is dat niet erg, maar vaak ook wel. Je zult dus het totaal moeten bekijken en niet per blok. Als het blok wat groter is dan is het wel verstandig ja.
Zoals ik het mbt de statemachine noemde hierboven heeft een FF op elk uitgaant signaal helemaal geen zin.

@jommeke: eigenlijk speelt het bij FPGA designs veel meer. Daar heb je maar een beperkte hoeveelheid logica voorhanden. Bij een ASIC is de grens veel minder hard (vaak).

[Bericht gewijzigd door flipflop op zaterdag 26 december 2009 11:22:52 (16%)]

|--------|    1       |-------|
| rest   |------------|state1 |
|--------|            |-------| 



                      |-------|
                      |state2 |
                      |-------| 

Ik wil inderdaad een vhld code laten genereren.
Maar nu wil ik bij 1 een voorwaarde in stelen. Als deze waar is ga dan naar state1. Maar als deze voorwaarde niet waar is ga dan naar state2.

Hoe maak ik nu de @else.

Is dat nu in godsnaam zo moeilijk?

De oplossing is al gegeven, kijk naar de VHDL-code van hierboven! Daar zie je ook dat voor de bepaling van de volgende toestand een aantal voorwaarden worden gecheckt (if..elsif, enz)

@flipflop: ik zal eraan denken als ik nog eens iets schrijf voor op de FPGA tot nu toe nog niet echt een design gehad waar ik moest optimaliseren omdat de resources beperkt waren...

[Bericht gewijzigd door jommeke op zaterdag 26 december 2009 17:54:08 (30%)]

In code vorm lukt het mij ook wel. Maar het gaat om de
statemachine. Hoe voer ik het daar in

Die code hierboven IS toch een statemachine?! Wat is de vraag nou eigenlijk? Of wil je iets in een grafische tool instellen? Dan zullen we toch moeten weten welke tool dat is. Ik doe het zelf ALTIJD in VHDL/Verilog. Zelfs het toplevel.