[vhdl] Kürze schreibweise für eine State machine

[K. S. (vhdl-kasi)]

Hallo alle zusammen,

ich möchte eine state machine erstellen, die 16 states hat. Jeder dieser 
states sieht ungefähr wie im unten aufgeführten Ausschnitt aus, nur das 
die if/elsif/else Anweisungen routieren. Das ganze funktioniert auch 
wunderbar, aber ich wollte mal nachfragen ob Ihr für solche Konstrukte 
ne kürzere Schreibweise kennt? Vielleicht irgendwas mit "for loop".

Zur Funktion: Die state machine soll nur einen Multiplexer steuern 
(mux_controll), aber dabei nur die Eingänge des Multiplexer ansteuern, 
die noch aktiv sind (working(x) = 1), ohne dabei einen Takt zu 
verlieren.

Ausschnit aus dem Quellcode:
[/vhdl]
        case state is
           when q1 => mux_control <= x"0";
                      if (working(1)='1') then
                        state <= q1;
                      elsif (working(2)='1') then
                        state <= q2;
                      elsif (working(3)='1') then
                        state <= q3;
                   ....usw...
                      elsif (working(15)='1') then
                        state <= q15;
                      elsif (working(0)='1') then
                        state <= q0;
                      elsif (working = 0) then
                        state <= q_finish;
                      else
                        state <= q_fault;
                      end if;
        end case;

[alex (Gast)]

Hallo,

ich kenne keine kürzere Schreibweise und meiner Meinung nach, ist es 
besser, die Beschreibung so zu lassen, wie Du sie hast. Eine kürzere und 
dadurch kryptische Schreibweise würde den Code nicht wartbar bzw. nicht 
"debugbar" machen. In eins-zwei Wochen weisst Du dann auch selbst nicht 
mehr, was Du da im kreativen Moment zusammengeschrieben hast... Es 
sollte kein "write-only-Code" werden.

Mfg,
Alex

[K. S. (vhdl-kasi)]

Hallo Alex,

ich denke ich werde es aus den von die Genannten gründen so lassen. 
danke für die schnelle Antwort. ;)

Grüße Kasi

[Gast (Gast)]

Warum nimmst du nicht das working selbst als state? Scheint doch immer 
genau ein Bit 1 zu sein.

[K. S. (vhdl-kasi)]

Hi Gast,

ich glaub, ich verstehe deinen Vorschlag nicht richtig. Das working ist 
ein 16 Bit breiter Vektor, in dem einfach nur gespeichert ist welcher 
eingang des Multiplexers überhaupt noch aktiv ist. Inaktive Eingänge 
muss der Multiplexer nämlich nicht mehr durchschalten.

[Christian K. (morpheus421)]

ich glaube gast meint, dass du statt "state" abzufragen, auch einfach 
working abfragen kannst. Würde dir deine if then else if Abfrage 
sparen...

also irgendwie so halt

case working is
 when "0000000000000001" => foo_out <= "0001";  
 when "0000000000000010" => foo_out <= "0010";  
 when "0000000000000100" => foo_out <= "0011";  
 when "0000000000001000" => foo_out <= "0100";  
 when "0000000000010000" => foo_out <= "0101";  
 when "0000000000100000" => foo_out <= "0110";  
 when "0000000001000000" => foo_out <= "0111";  
 when "0000000010000000" => foo_out <= "1000";  
 when "0000000100000000" => foo_out <= "1001";  
 when "0000001000000000" => foo_out <= "1010";  
 when "0000010000000000" => foo_out <= "1011";  
 when "0000100000000000" => foo_out <= "1100";  
 when "0001000000000000" => foo_out <= "1101";  
 when "0010000000000000" => foo_out <= "1110";  
 when "0100000000000000" => foo_out <= "1111";  
 when "1000000000000000" => foo_out <= "0001";  
 when "0000000000000000" => foo_out <= "0000";
 when others => foo_out <= "0000";
end case;

dann machst halt satt foo_out zu setzen deine Anweisungen, was in q0 bis 
q15 passieren soll. Deine Fehler fängst du im others state ab...

Müßte funktionieren... nicht?

Gruß

[K. S. (vhdl-kasi)]

nee, das funktionier leider so nicht, weil working durch aus mehr als 
eine 1 hat und sogar muss. Ich möchte nur zur "nächsten 1" in working 
springen. Das was ihr meint wäre ja eine "One-hot"-Codierung für state.

Grüße

[Gast (Gast)]

Folgender Ansatz:
Mach einen state, in dem du working links shiftest (einmal pro 
Aufenthalt in diesem state) und dabei einen Zaehler mit laufen laesst. 
Steht als MSB des geshifteten working eine 1, dann gehst du in einen 
state der das macht was du willst (der Zaehler verweist auf den state, 
den du brauchst). Steht eine 0, bleibst du im Ausgangsstate und shiftest 
wieder. Wenn einmal durch, Zaehler wieder 0 setzen und neu anfangen.

[K. S. (vhdl-kasi)]

stimmt, das wäre sinnig ;-)

danke für den Tipp und eure Mühe mit mir.

Damit wäre das Thema geschlossen.