ISE: bad synchronous description

1. Fehler :
die VHDL-Beschreibung ist falsch, bei Deiner Sensitivity-List
mit 4 Signalen erwartet die Synthese einen rein kombin.
Prozess, also nur eine Gatter-Beschreibung,
dann kommt aber plötzlich in Zeile 5 eine Taktabfrage -
das geht nicht

2. :
Ist die Statemachine extra oder soll sie in diesem
Prozess realisiert werden ? (Ich nehme mal an, da
gibts irgendwo noch einen Clock im Design???)
Warum muss "fusstaster" auf die steigende Flanke
abgefragt werden ?
Kann man hier nicht den Zustand '1' abfragen und dann
in einem folgenden State warten, bis "fusstaster" wieder
0 ist ?
andere Idee:
Fusstaster mit 2 Flip-Flops einlesen, dann ist eine synchrone
Flankenerkennung möglich, etwa so:

reg1 <= fusstaster; -- mit einem vorh. Clock eintakten
reg2 <= reg1,

if (reg1 ='1' and reg2 = '0') then  -- steigende Flanke
...
evt. sind noch Maßnahmen zum entprellen erforderlich

Verstehe ich richtig, dass man bei getakteten Prozessen dann keine
anderen Signale ausser dem Clock in der Sens.liste stehen haben darf?

Das Problem mit dem Taster ist, dass er nicht nur bei der Flanke von
clk erkannt werden soll, sondern auch dazwischen. Ne Möglichkeit wäre
wohl, das Signal des Tasters zu speichern bis zur nächsten Flanke. An
dem Punkt kam ich aber nicht weiter, nen Latch schied da aus, oder habe
es nicht hinbekommen wie ich es wollte.

Hier mal der komplette Code:

1

entity FSM is

2

port(

3

  clk : in bit;

4

  reset : in bit;

5

  fusstaster : in bit;

6

  autoampel : out bit_vector(2 downto 0);

7

  fussampel : out bit_vector(1 downto 0));

8

end FSM;

9

10

architecture Verhalten of FSM is

11

12

-- interne Signale

13

14

signal clk_geteilt: bit;

15

signal lauf: natural := 0;

16

signal timer_1: natural := 0;

17

signal timer_2: natural :=0;

18

19

type phasen is (strasse, warten, fussgaenger);

20

signal status: phasen;

21

signal folge_status: phasen;

22

23

-- Beginn für Synthese

24

attribute clock_signal : string;

25

attribute clock_signal of clk_geteilt : signal is "yes";

26

--  Ende

27

28

begin

29

30

31

--  Zustandsaktualisierung

32

33

  ampel: process (clk_geteilt, reset)

34

  begin

35

    if reset = '1' then

36

      status <= strasse;    

37

    elsif clk_geteilt'event and clk_geteilt='1' then

38

      status <= folge_status;

39

    end if;

40

  end process ampel;  

41

42

43

-- Folgezustand ermitteln

44

45

  folge: process (status, fusstaster, timer_1, timer_2)

46

  begin

47

      case status is

48

        when strasse =>

49

          if fusstaster = '1' and fusstaster'event then

50

            folge_status <= warten;

51

          end if;

52

        when warten =>

53

          if timer_1 = 10 then

54

            folge_status <= fussgaenger;

55

          end if;

56

        when fussgaenger =>

57

          if timer_2 = 10  then

58

            folge_status <= strasse;

59

          end if;

60

        when others => folge_status <= strasse;

61

      end case;

62

  end process folge;

63

64

65

-- Ausgangskombinatorik

66

67

  ausgang: process (status)

68

  begin

69

    case status is

70

      when strasse => autoampel <= "001";

71

                      fussampel <= "10";

72

      when warten => autoampel <= "001";

73

                     fussampel <= "10";

74

      when fussgaenger => autoampel <= "100";

75

                          fussampel <= "01";

76

      when others => autoampel <= "001";

77

                     fussampel <= "10";

78

    end case;

79

  end process ausgang;

80

81

82

-- Timer

83

84

  timer: process (clk_geteilt, status)

85

  begin

86

    if clk_geteilt'event and clk_geteilt = '1' then

87

      case status is

88

        when strasse =>

89

          timer_2 <= 0;

90

        when warten =>

91

          timer_1 <= timer_1 +1;

92

        when fussgaenger =>

93

          timer_1 <= 0;

94

          timer_2 <= timer_2 + 1;

95

        when others => timer_1 <= 0;

96

                       timer_2 <= 0;

97

      end case;

98

    end if;

99

  end process timer;

100

101

102

-- Taktteiler

103

104

  taktteiler: process(clk)

105

  begin

106

    clk_geteilt <= '0';

107

    if clk'event and clk = '1' then

108

      lauf <= lauf +1;

109

    end if;

110

    if lauf = 48000000 then

111

      clk_geteilt <= '1';

112

      lauf <= 0;

113

    end if;

114

  end process taktteiler;

115

116

end Verhalten;

Grüße
T.M.

du könntest das Signal z.B. im Prozess ampel
mit clk_geteilt in einem Flip-Flop speichern:

fusstaster_q <= fusstaster;


Ein asynchrones Signal in einer Statemachine abzufragen
ist sehr gefährlich. Alle Signale, die einen Einfluss
auf die States haben können, müssen mit dem Takt
der Statemachine einsynchronisiert sein, sonst
kann es zu unerwünschten Effekten kommen.

Mhm, ich werd am besten den Takt mal nicht soweit runterteilen, damit
ich bei kurzen Drücken des Tasters auch ne Flanke erwische. In dem
obigen Design sind es ja nach Teilung nur noch 1Hz...mit 100Hz dürfte
ich wohl hinkommen. Damit würden sich ja dann die Probleme erledigen.
Da kann ich dann wieder alles synchron machen... Danke für die Hinweise
:-)

So. Hab jetzt mal nur auf 100Hz geteilt. Damit geht es nun, frage nur
noch den Zustand von dem Taster ab und alles funzt. Ausserdem hab ich
mal die 3 Latches im Prozess folge weggemacht, is mir vor der Synthese
gar ni aufgefallen. Für was Warnungen alles gut sind ;-)

Grüße
T.M.

na gut :-)
noch zu Deiner Frage :
ja, in der Sens-Liste von getakteten Prozessen gibt es
normalerweise das Clock-Signal und evt. noch 1 bis 2
Signale für asynchronen Set / Reset.
Du musst übrigens die Statemachine nicht in Register
und Kombinatorik trennen, es geht auch beides in einem
Prozess, das ist manchmal besser lesbar.