FSM von ISE nicht erkannt

[T.M. (Gast)]

Hallo,
habe ein Problem mit dem Webpack bei einem kleinen Versuch ein LCD
anzusteuern. Ich habe eine FSM implementiert, die auch von Modelsim
ordentlich wir gewünscht simuliert wurde, nur erkennt das Webpack diese
nicht als FSM an, und synthetisiert stattdessen einzelne Register...
Hier mein Codeausschnitt:

  aktualisierung: process(clk_in)
  begin
    if clk_in'event and clk_in = '0' then
      if cs_intern = '0' then
      zustand <= folgezustand;
      end if;
    end if;
  end process aktualisierung;

  zustandsermittlung: process(zustand)
  begin
    case zustand is
      when 0 => folgezustand <= 1;
      when 1 => folgezustand <= 2;
      when 2 => folgezustand <= 3;
      when 3 => folgezustand <= 4;
      when 4 => folgezustand <= 5;
      when 5 => folgezustand <= 6;
      when 6 => folgezustand <= 7;
      when 7 => folgezustand <= 8;
      when 8 => folgezustand <= 9;
      when 9 => folgezustand <= 10;
      when 10 => folgezustand <= 11;
      when 11 => folgezustand <= 12;
      when 12 => folgezustand <= 13;
      when 13 => folgezustand <= 14;
      when 14 => folgezustand <= 15;
      when 15 => folgezustand <= 16;
      when 16 => folgezustand <= 17;
      when 17 => folgezustand <= 18;
      when 18 => folgezustand <= 19;
      when 19 => folgezustand <= 20;
      when 20 => folgezustand <= 21;
      when 21 => folgezustand <= 22;
      when 22 => folgezustand <= 23;
      when 23 => folgezustand <= 24;
      when 24 => folgezustand <= 25;
      when others => folgezustand <= 0;
    end case;
  end process zustandsermittlung;

  ausgabe: process(zustand, befehl_intern)
  begin
    sid_out <= befehl_intern(zustand-1);
   if (zustand = 0 or zustand = 25) then 
     sid_out <= '0';
    end if;
  end process ausgabe;

folgende Fehlermeldung erscheint, die ich mir nicht erklären kann:

INFO:Xst:1813 - Unable to extract FSM on signal <zustand> : outputs
depend on both state and next state.

Ich weiss was sie heisst, nur sehe ich nicht wo die Ausgabe vom akt.
Zustand und Folgezustand abhängen soll?

Danke schonmal für eure Ratschläge...

Grüße
T.M.

[Dirk (Gast)]

Hi,

ich bin ein blutiger Anfaenger aber koennte da sowas in der richtung
Fehlen?

  type state_type is (IDLE, LESE, READY,SCHREIBE,COUNT);
  signal next_state, current_state: state_type;

Gruß,

Dirk

[T.M. (Gast)]

Ich habe das Problem gelöst.
In einem weiterem Prozess, der nicht oben mit steht, hatte ich den
Folgezustand mit abgefragt. Und das hat mir die Synthese übel
genommen.
Naja, habs entfernt, nur richtig ging das trotzdem nicht. Bin grad
dabei das Ganze mit nem Zähler zu lösen, hänge nun aber auch fest...
Naja, mal sehen ob nochwas rauskommt heute...

Grüße
T.M.

[high_speed (Gast)]

Hallo T.M.

In was für eine Zielhardware soll das Modell implementiert werden.

Für einen CPLD ist eine Zählerstruktur günstig.
Bei einem FPGA sollte man lieber auf eine Schieberegisterstruktur
zurückgreifen, weil dadurch für die Vergleichsoperationen weniger
Logikelemente benötigt werden.

Aber hier erst einmal der Zähler.

library ieee ;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity Controll_Counter is
  generic( N_Zustand  : natural := 26 ;
           N_Bit      : natural := 5
         );
  port(    clk_in     :in  std_logic;
           cs_intern  :in  std_logic;
           Reset      :in  std_logic;
           sid_out    :out std_logic_vector((N_Bit - 1) downto 0)
      );
end Controll_Counter;


architecture Verhalten of Controll_Counter is
signal zustand    : std_logic_vector((N_Bit - 1) downto 0);
begin

  aktualisierung: process(clk_in)
  begin
    if Reset = '0' then 
       zustand <= (others => '0');
    elsif clk_in'event and clk_in = '0' then
      if cs_intern = '0' and zustand <= (N_Zustand - 2) then
         zustand <= zustand + 1;
      elsif cs_intern = '0' then
          zustand <= (others => '0');
      end if;
    end if;
  end process aktualisierung;
  
  ausgabe: process(zustand) --, befehl_intern)
  begin
    sid_out <= zustand ; -- befehl_intern(zustand-1);
   if (zustand = 0 or zustand = 25) then 
     sid_out <= (others => '0');
    end if;
  end process ausgabe;

end Verhalten;

MfG
Holger

[T.M. (Gast)]

Danke. Werd den Code mal mit einbeziehen in meine Überlegungen. Das
ganze ist dazu gedacht, ein LCD-Display seriell über CS, SCLK und SID
anzusteuern. Dazu werden 24 bits von befehl_intern bei jeder steigenden
Flanke von SCLK eingelesen, wenn CS_intern 0 ist. Ich möchte es aber so
machen, dass ich von aussen nur kurz CS und den Befehl anlege, deshalb
das speichern in die internen Signale. Und diese sollen halt während
die 24 bits eingelesen werden in dem gespeicherten Zustand bleiben. Der
Befehl von aussen liegt als 8bit Vektor vor, der intern in einen 24bit
Vektor gespeichert wird.

Ja, und das im Anhang hab ich gestern Abend noch hinbekommen, mich
stört nur der kurze Spike bei sclk am Ende, kurz bevor cs_intern auch
wieder auf '1' geht...Hat jemand ne Ahnung an was das liegt,
eigentlich müsste der Zähler doch anstandslos zu 0 zurückkehren...
Im Anhang befinden sich Design, Testbench und nen Bild der Simulation.

Grüße
T.M.

[Positron (Gast)]

>mich stört nur der kurze Spike bei sclk am Ende, kurz bevor cs_intern
>auch wieder auf '1' geht...Hat jemand ne Ahnung an was das liegt

Du generierst "sclk_intern" kombinatorisch:

    if (cs_intern = '0' and zustand > 0) then
        sclk_intern <= clk;
    else
      sclk_intern <= '1';
    end if;


Wenn der Zähler den Wert 24 hat, und "clk" von '1' auf '0'
wechselt,
ist der Ausdruch oben (cs_intern = '0' and zustand > 0) für einen
Simulationszyklus wahr, und "sclk_intern" wird '0'.
Einen Simulationszyklus später werden dann die Zählerflipflops
upgedatet und der Ausdruck ist wieder falsch.
Deshalb der mimimale Spike.

Wenn Du eine Timingsimulation machst, wirst Du feststellen, daß diese
Minimalspike dann eine reelle Länge hat, bei mir z.B. knappe 1,5 ns.
(ich habe die clk-Frequenz in der Testbench auf vernünftige Werte
erniedrigt, 100 ns anstatt 100 ps)


"sclk" rein kombinatorisch zu generieren, ist keine gute Idee.
Mach noch ein Flip-Flop dahinter.