www.mikrocontroller.net

Forum: FPGA, VHDL & Co. Probleme bei Synthese durch parallele Blöcke?


Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Ich will eine Alarmsteuerung entwerfen.
Die Steuerung hat 5 Sensoren (3x Chemie Alarm,2x Feuer Alarm).
Das ganze soll über einen Zustandsautomat gebaut werden. Im Prinzip 
ist das kein Problem, ich wollte das so machen:

Ich habe 2 getrennte Blöcke. Dieser Block...

current_state=next_state;
always@(posedge clock)
begin
case(current_state)
...
end

...bearbeitet mir den aktuellen Zustand.

Der zweite Block hier, berechnet mir den Folgezustand und reagiert auf 
Änderungen der Sensoren.

always@(sens_f1,sens_f2,sens_c1,sens_c2,sens_c3)
begin
case({sens_f1,sens_f2,sens_c1,sens_c2,sens_c3})
..
end

Nun ist für die Aufgabe gefordert, dass je nach Alarm unterschiedliche 
Dinge passieren sollen (z.B. soll die Firmenleitung gerufen werden und 
evakuiert werden) das wird über 8 Leds angezeigt. Eine davon simuliert 
eine Sirene und blinkt in einem bestimmten Takt.
Hier kommt auch mein Problem:
Ich habe gehört dass man wenn man zwei Blöcke baut wie oben, die ja 
parallel synthetisiert werden, man in beiden nicht auf gleiche Variablen 
zugreifen kann. Ohne das, weiß ich aber nicht wie ich die Aufgabe lösen 
kann, denn ich wollte das blinken so lösen:

Ich gehe in Block 1 in den entsprechenden Zustand. Dort setze ich die 
led Leiste erstmal, z.B. so: leds = 'b0010_1100 (was das jetzt bedeutet 
ist egal).
Das blinken wollte ich mit einer xor Verknüpfung realisieren z.B. so:
leds = leds ^ 'b0000_0001 (lässt Led 8 blinken), dafür habe ich einen 
timer gebaut.
Wenn ich aber jetzt nach einem Takt wieder in den Zustand komme, 
überschreibt mir ja leds = 'b0010_1100 wieder meine gerade gesetzte 1 
bei Led 8. Also hatte ich mir überlegt ich baue einen lock und zwar so:

if(lock==0)
leds='b0010_1100;
else
begin
 lock=1;
 timer_32=timer_32-1;
 if(timer_32==0)
   begin
   leds = leds ^ 'b0000_0001;
   timer_32=40000000; (40.000.000 da 40 MHz und ich alle 1 Sekunde 
umschalten will)
  end
end

Damit ich das so machen kann, müsste ich aber in Block 2 lock auf 0 
setzen.
Somit würde ich aber lock in beiden Blöcken verändern. Geht das? Oder 
knallts dann in der Synthese?

Ich hoffe ihr seht hier durch!
Ich wäre für Hilfe sehr dankbar!

Autor: Jan M. (mueschel)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nein, das geht nicht, Signale koennen nur in genau einem Block 
geschrieben werden, wie du richtig geschrieben hast.

Setze doch in deiner Steuerung ein Bit, ob die LED blinken soll oder 
nicht. In einem weiteren Prozess (oder Block, ich kenne Verilog nicht) 
kannst du dann die LED ansteuern auf Basis dieses bits.

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Jan!

Danke für deine Antwort! :)

Aber genau das wollte ich ja mit lock machen. lock ist nur was internes 
und wird nicht nach außen geführt (reg lock). Ich wollte lock im 
Steuerblock immer auf 0 setzen und im jeweiligen Zustand dann später auf 
1.

Autor: Jan M. (mueschel)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich meinte das so: led_blink wird nur im ersten Block gesetzt, die led 
nur im zweiten Block geschaltet. Die anderen, nicht blinkenden LED 
kannst du ja weiterhin direkt in Block1 ansteuern.

Block1:

led_blink <= 0
if error_condition
   led2_blink <= 1



Block2:

if led2_blink = 1
  if counter = 40Mio
    led2 = not led2

Autor: Günter -.. (guenter)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Martin wrote:
...
> Hier kommt auch mein Problem:
> Ich habe gehört dass man wenn man zwei Blöcke baut wie oben, die ja
> parallel synthetisiert werden, man in beiden nicht auf gleiche Variablen
> zugreifen kann. Ohne das, weiß ich aber nicht wie ich die Aufgabe lösen
> kann, denn ich wollte das blinken so lösen:
>

Der Ansatz mit den 2 Blöcken für die State Machine ist ganz gut. Dann 
mit dem Lock wird es sehr verzwickt.

Aus der State Machine hast du ja schon den leds Vektor, bei dem ein Bit 
Anzeigt das die eine LED blinken soll.

Mein Vorschlag währe einen dritten always block zu kreieren der immer 
den Takt für das Blinken erzeugt, unabhängig von der State Machine.

Dann nimmst du einen kombinatorischen Konstrukt:
assign led_blink = blink_takt & leds[x];

Das x spezifiziert das Bit für die blinkende LED im leds Vektor. Der 
blink_takt kommt von dem dritten always Block mit dem Takt. Jedes mal 
wenn deine State Machine jetzt sagt die LED soll blinke, dann wird das 
Signal mit dem Takt UND-verknüpft und schon blinkt deine LED.

Damit musst du dir keine Gedanken über irgendwelche Locks machen.

Gruß,

Günter

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Jan
Ich glaube ich hab zu der Aufgabenstellung was ausgelassen. Im Prinzip 
weiß ich schon wenn ich in Block2 bin, dass geblinkt werden soll, da das 
implizit durch den jeweiligen Zustand vorgegeben ist. Somit brauche ich 
in Block 1 nicht mehr zu sagen dass geblinkt werden soll.
Bei mir sah das bis jetzt so aus:

Block1:

lock=0;
next_state=tue_irgendwas_und_blinke;

Block2:

tue_irgendwas_und_blinke:
begin
  if(lock==0)
   begin
     lock=1;
     leds='b0010_1100;
   end
  if(lock==1)
   begin
     timer_32=timer_32-1;
     if(timer_32==0)
      begin
        leds=leds^'b0000_0001;
        timer_32=40000000;
      end
   end

Aber im Prinzip kann man den lock ja ganz weglassen und nur den Timer 
überprüfen, also so:

Block1:

next_state=tue_irgendwas_und_blinke;

Block2:

leds[0:7]='b0010_110; //Geht das?
  if(timer_32==40000000)
    leds[8]=0;
  if (timer_32>0)
    timer_32=timer_32-1;
  if(timer==0)
    begin
      leds[8]=leds[8]^1;
      timer_32=40000000;
    end

Dann fällt zwar der lock raus, aber es gibt das Problem, dass ich wieder 
nur in Block 2 timer_32 setzen kann und ich habe das gleiche Problem wie 
ich es mit lock hätte. (Oder übersehe ich was?)

@Günter
Mit deiner Lösung müsste es gehen.
Also würde ich einen dritten Block machen, der so aussieht

always@(posedge clock)
begin
  if(timer_32==40000000)
    blink_takt=0;
  if (timer_32>0)
    timer_32=timer_32-1;
  if(timer==0)
    begin
      blink_takt=1;
      timer_32=40000000;
    end
end


Block 2 würde dann so aussehen:
always@(posedge clock)
next_state=current_state;
begin
 case(...)

 tue_irgendwas_und_blinke:
 begin
  leds[0:7]='b0010_110; //Geht das?
  leds[8] = blink_takt;
 end
end

Das sollte doch gehen?!

Autor: Günter -.. (guenter)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Martin wrote:
...
>
> @Günter
> Mit deiner Lösung müsste es gehen.
> Also würde ich einen dritten Block machen, der so aussieht
>
> always@(posedge clock)
> begin
>   if(timer_32==40000000)
>     blink_takt=0;
>   if (timer_32>0)
>     timer_32=timer_32-1;
>   if(timer==0)
>     begin
>       blink_takt=1;
>       timer_32=40000000;
>     end
> end
>

Dein blink_takt wird hier nur für eine clock Periode aktive sein. Da 
wirst du nicht viel von der LED sehen.

Besser währe vielleicht den blink_takt aus dem always heraus zu nehmen 
und folgendes zu machen:
assign blink_takt = (timer_32 < 20000000);

Wenn jetzt timer_32 kleiner 20000000 ist, dann ist der Vergleich wahr 
und damit blink_takt 1. Wenn es größer/gleich 20000000 dann falsch und 
blink_takt ist 0. Damit erhälst du einen symmetrischen blink_takt.

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Das stimmt, dort müsste bei mir statt blink_led=1, blink_led = ~ 
blink_led stehen oder ich mach es so wie du.

Jetzt verbleibt für mich aber noch ein Problem. Ich brauche noch einen 
Alarmnachlaufzeit. Auch wenn die Sensoren z.B. kein Feuer mehr melden, 
soll der Alarm 3 Minuten nachlaufen. Wie ich einen Timer für 3 Minuten 
mache ist kein Problem, ich mache zum 1s Timer einfach noch eine der bis 
180 zählt.
Aber wie kann ich den Timer überhaupt von außen zurücksetzen?
Ich wollte das über ein zusätzliches Signal machen, z.b. timer_reset.
Aber ich stosse wieder auf das gleiche Prolbem wie bei den LEDs:
Wie kann ich timer_reset auslösen und dann wieder zurücksetzen?
Das müsste ich ja im Steuerblock machen, der ist aber nur 
ereignisgesteuert (Ausschnit vom Steuerblock):

always@(sens_f1, sens_f2, sens_c1, sens_c2, sens_c3)
begin
   case({sens_f1,sens_f2,sens_c1,sens_c2,sens_c3})
   .....
       'b1?1??:
        begin
            //beide Feuersensoren sind aktiv
            if(sens_f2)
            begin
               next_state=f2_chem_s3;
            end

            //nur ein Feuersensor ist aktiv
            else
               begin
                  activate_sprinkler=1;
                  next_state=f1_chem_s3;
               end
        end
        ....
        'b00111:
        begin
            next_state=c3_s3;
        end
       ....
  endcase
end

Ich müsste ja aber dort irgendwo mein timer_reset Signal triggern (Ich 
kan n es zwar auf 1 setzen, ich bekomme es ja nicht mehr auf 0) Im 
Prinzip immer genau dann, wenn ich von einem Zustand mit Alarmsignal, in 
einen Zustand ohne Alarmsignal wechsel, dazu müsste ich ja nur 
current_state mit next_state vergleichen. Ich brauche dann auch 2 Timer 
für 3 Minuten, da einmal der Chemie- und einmal der Feueralarm 
nachlaufen kann.

Autor: Günter -.. (guenter)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Martin wrote:
> Hallo!
>
> Das stimmt, dort müsste bei mir statt blink_led=1, blink_led = ~
> blink_led stehen oder ich mach es so wie du.
>
> Jetzt verbleibt für mich aber noch ein Problem. Ich brauche noch einen
> Alarmnachlaufzeit. Auch wenn die Sensoren z.B. kein Feuer mehr melden,
> soll der Alarm 3 Minuten nachlaufen. Wie ich einen Timer für 3 Minuten
> mache ist kein Problem, ich mache zum 1s Timer einfach noch eine der bis
> 180 zählt.
> Aber wie kann ich den Timer überhaupt von außen zurücksetzen?
> Ich wollte das über ein zusätzliches Signal machen, z.b. timer_reset.
> Aber ich stosse wieder auf das gleiche Prolbem wie bei den LEDs:

Du solltest die Steuerung von den LEDs, speziell der blinkenden nicht 
mit der State Machine verknüpfen.

Die State Machine sollte dir nur ein Signal geben, dass der Alarm 
anliegt. Basierend auf diesem Signal kannst du jetzt extra Logik 
hinzufügen um die LED blinken zu lassen. Jedes mal wenn du das Blinken 
mit in die State Machine zurück bringst wird diese komplizierter.

...
>
> Ich müsste ja aber dort irgendwo mein timer_reset Signal triggern (Ich
> kan n es zwar auf 1 setzen, ich bekomme es ja nicht mehr auf 0) Im
> Prinzip immer genau dann, wenn ich von einem Zustand mit Alarmsignal, in
> einen Zustand ohne Alarmsignal wechsel, dazu müsste ich ja nur
> current_state mit next_state vergleichen. Ich brauche dann auch 2 Timer
> für 3 Minuten, da einmal der Chemie- und einmal der Feueralarm
> nachlaufen kann.

Die State Machine signalisiert nur das der Alarm anliegt. Der 
Nachlauftimer wird von dem aktiven Alarm gehalten und hat einen aktiven 
Ausgang. Der Ausgang wird jetzt mit deinem Blink-Takt-Geber 
UND-Verknüpft.

Sollte der Alarm abfallen, läuft der Nachlauftimer los und zählt die 3 
Minuten runter. In der ganzen Zeit ist der Ausgang immer noch aktiv.

Da du scheinbar mehrere Nachlauftimer benötigst, macht es vielleicht 
Sinn ein extra Modul davon zu machen und es entsprechend oft zu 
instanzieren.

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!

Ersteinmal Danke für deine Geduld und Hilfe!

Entweder mir ist nicht ganz klar wie du das meinst oder ich habe einfach 
zu wenig Wissen in Sachen Verilog oder ich stelle mich einfach furchtbar 
dämlich an.

Wenn ich also in einen Zustand gehe, wo es brennt, so führe ich folgende 
Anweisung im Zustand aus:

melde_feuer=1;

Wenn ich dann in einen Zustand wechsel, wo es nicht brennt, wir daraus:

melde_feuer=0;

Die Erkennung für die Negative Flanke von melde_feuer:

always@(posedge melde_feuer, negedge melde_feuer)
begin
//negedge melde_feuer
if (melde_feuer==0) nachlauf_feuer=1;
//posedge melde_feuer
if (melde_feuer==1) nachlauf_feuer=0;
end

Der Block für den Timer, das schalten der Ausgänge:

alway@(clock)
begin
    if(timer_init)
    begin
       timer_32=40000000; //für 40 MHz
       half_sec_blink=0;
       full_sec_blink=0;
       timer_init=0;
    end
    else
    begin
    if(timer_32>0)
    begin
     timer_32=timer_32-1;
     if(timer_32==20000000) //Hälfte der Zeit
       half_sec_blink=~half_sec_blink;
    end

    if(timer_32==0)
    begin
       half_sec_blink=~half_sec_blink;
       full_sec_blink=~full_sec_blink;
       timer_32=40000000;

       //Problemstelle:
       if(nachlauf_feuer==0)
       timer_8_feuer=180;
       if(nachlauf_feuer==1)
       begin
         if(timer_8_feuer==0) nachlauf_feuer=0; //Geht so ja nicht!
         else timer_8_feuer=timer_8_feuer-1;
       end
    end

//Ausgänge schalten:
//Sobald nachlauf_feuer==0 und melde_feuer=0 ist Ausgang Null
//ansonsten blink Ausgang im Sekundentakt
ausgang_feuer_sirene=(nachlauf_feuer||melde_feuer)&blink_takt_sekunde;

end
end


Das Problem (Problemstelle ist gekennzeichnet):
Hier schalte ich ja aber nachlauf_feuer wieder in 2 Blöcken.

Also müsste es doch aber so hier gehen:
(Ich habe nur das Gefühl es geht irgendwie einfacher und ich sehs 
einfach nicht)

Die Erkennung für die Negative Flanke von melde_feuer:

always@(posedge restart_timer,posedge melde_feuer, negedge melde_feuer)
begin
if (restart_timer_8_feuer==1) nachlauf_feuer=0;
if (melde_feuer==1) nachlauf_feuer=1;
if (melde_feuer==0) nachlauf_feuer=0;
end

Der Block für den Timer, das schalten der Ausgänge:

alway@(clock)
begin
    if(timer_init)
    begin
       timer_32=40000000; //für 40 MHz
       half_sec_blink=0;
       full_sec_blink=0;
       timer_init=0;
    end
    else
    begin
    if(timer_32>0)
    begin
     timer_32=timer_32-1;
     if(timer_32==20000000) //Hälfte der Zeit
       half_sec_blink=~half_sec_blink;
    end

    if(timer_32==0)
    begin
       half_sec_blink=~half_sec_blink;
       full_sec_blink=~full_sec_blink;
       timer_32=40000000;

       //Problemstelle:
       if(nachlauf_feuer==0)
       begin
          timer_8_feuer=180;
          restart_timer_8_feuer=0;
       end
       if(nachlauf_feuer==1)
       begin
         if(timer_8_feuer==0) restart_timer_8_feuer=1;
         else timer_8_feuer=timer_8_feuer-1;
       end
    end

//Ausgänge schalten:
//Sobald nachlauf_feuer==0 und melde_feuer=0 ist Ausgang Null
//ansonsten blink Ausgang im Sekundentakt
ausgang_feuer_sirene=(nachlauf_feuer||melde_feuer)&blink_takt_sekunde;

end
end

Autor: Günter -.. (guenter)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Martin wrote:
...
>
> Wenn ich also in einen Zustand gehe, wo es brennt, so führe ich folgende
> Anweisung im Zustand aus:
>
> melde_feuer=1;
>
> Wenn ich dann in einen Zustand wechsel, wo es nicht brennt, wir daraus:
>
> melde_feuer=0;
>
> Die Erkennung für die Negative Flanke von melde_feuer:
>
> always@(posedge melde_feuer, negedge melde_feuer)

Ich weiß nicht ob du das in synthesierbarer Logik machen kannst. Immer 
wenn du posedge oder negedge nimmst dann wird in der Logik ein Register 
genommen. Der Clock-Eingang eines Registers sollte aber immer mit dem 
synchronen Takt belegt werden. Was du hier also kreierst ist ein Latch, 
aber ich glaube nicht das es funktioniert den auf beide Flanken zu 
triggern. Schau dir den Synthesebericht bezüglich Warnungen mit den 
Signalen mal an.

> begin
> //negedge melde_feuer
> if (melde_feuer==0) nachlauf_feuer=1;
> //posedge melde_feuer
> if (melde_feuer==1) nachlauf_feuer=0;
> end

Meiner Ansicht nach brauchst du das auch gar nicht. Mit melde_feuer hast 
du ja schon ein signal das den Alarm signalisiert. Das Signal nimmst du 
jetzt um den Nachlauftimer zu laden. Immer wenn melde_feuer aktiv ist, 
wird der Nachlauftimer mit den max Wert geladen. Wenn melde_feuer 
inaktive wird, fängt der Nachlauftimer an runter zu zählen.

Das ganze sieht ungefähr so aus. Ziehe den timer_8_feuer aus den 
timer_32 heraus und packe ihn in einen neuen always block:
always@(posedge clock)
  if(melde_feuer)
   timer_8_feuer = 180;
  else
   if(timer_32 == 0 && timer_8_feuer > 0)
    timer_8_feuer = timer_8_feuer - 1;

Das eigentliche Signal wird jetzt aus kombinatorischer Logik gebildet:
assign nachlauf_feuer = (timer_8_feuer > 0);
assign ausgang_feuer_sirene = machlauf_feuer & blink_takt_sekunde;

Wenn timer_8_feuer > 0 ist dann ist das Ergebnis 1 und wird 
nachlauf_feuer zugewiesen. Wenn er 0 ist dann ist der Vergleich 0 und 
wird nachlauf_feuer zugewiesen.

Um die LED blinken zu lassen wird das nachlauf_feuer mit dem 
blink_takt_sekunde UND verknüpft.

Versuche sequentielle Blöcke, also always-Blöcke mit @(posedge clock) 
nur eine Funktion ausführen zu lassen. Dann verbinde solche sequentielle 
Blöcke mit kombinatorischer Logik.

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Günter
So hats letzendlich funktioniert. :)
Vielen Dank für deine Hilfe!

Gruß,
Martin

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [vhdl]VHDL-Code[/vhdl]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.