Hallo Leute!

Ich hab mal ne Frage zu ner Verilog-Aufgabe, und zwar soll ich eine
Zahlenreihe als kombinatorische Logik modellieren.

an = (an-4 + an-3 + an-2) / 2

Das ist die Reihe, immer "a index n" oder "a index n-4" ist gemeint.

a0 = 1
a1 = 2
a2 = 3
a3 = 4

Das sind die Startwerte, die Rekursionsformel oben gilt also für n>3.
Die weitere Aufgabenstellung ist:
----------
Eingänge: CLK zu jeder steigenden Flanke werden N inkrementiert und A_N
aktualisiert
RESET synchron; für RESET = 1 werden N und A_N zurückgesetzt
Ausgänge: A_N aktuelles an
N aktuelles n

Die Berechnung von an soll als ein kombinatorisches Netz beschrieben
sein, welches durch kein Register unterbrochen wird. Die Register zur
Speicherung der Zwischenschritte sowie das Register für an sollen je 32
Bit breit sein. Die Berechnung findet komplett in Integer-Arithmetik
statt, d. h. bei „/ 2“ werden die Nachkommastellen abgeschnitten.
Simulieren Sie Ihr Modell mit einem von Ihnen erstellten Testrahmen, und
ver-gleichen Sie die Ergebnisse mit den manuell berechneten Werten.
----------
So, und nun bin ich verwirrt, wie ich diese rekursive Formel genau
umsetzen soll, mit den Indexwerten und so.

Natürlich ist auch ein Reset geplant, also Grundform natürlich

always @(posedge CLK, posedge RESET) begin
  if (RESET) begin
    A_N = 0;
    N = 0;
  end
  else begin
    ...
  end

Andrea Keil wrote:
> Hallo Leute!
>
> Ich hab mal ne Frage zu ner Verilog-Aufgabe, und zwar soll ich eine
> Zahlenreihe als kombinatorische Logik modellieren.
>
> an = (an-4 + an-3 + an-2) / 2
>
...
> ----------
> So, und nun bin ich verwirrt, wie ich diese rekursive Formel genau
> umsetzen soll, mit den Indexwerten und so.
>
> Natürlich ist auch ein Reset geplant, also Grundform natürlich
>
>

> always @(posedge CLK, posedge RESET) begin
>   if (RESET) begin
>     A_N = 0;
>     N = 0;
>   end
>   else begin
>     ...
>   end
> 

Der Ansatz ist ganz gut, aber vielleicht solltest du erst mal das module
definieren, damit du weißt was für Ein- und Ausgänge du hast.

Also z.B.

module folge(clk, reset, a_in, a_out)

input         clk;
input         reset;
input  [31:0] a_in;
output [31:0] a_out;

endmodule

Dann teile es auf in einen sequentiellen Teil, das ist der Teil den du
angefangen hast und einen kombinatorischen Teil.

Natürlich kannst du den sequentielle Teil mit einem indizierten Array
machen. Du kannst aber die Register auch einzeln definieren, da es nicht
so viele sind. Also z.B.:

reg [31:0] a0;
reg [31:0] a1;
reg [31:0] a2;
reg [31:0] a3;
reg [31:0] a4;

always @(posedge clk, posedge reset)
  if(reset) begin
   a0 <= 0;
   a1 <= 0;
   a2 <= 0;
   a3 <= 0;
   a4 <= 0;
  end else begin

   a0 <= a_in;
   a1 <= a0;
   a2 <= a1;
   a3 <= a2;
   a4 <= a3;

  end

Dieser Teil schiebt nun immer bei einem Takt die a Werte weiter.

Die folgende kombinatorische Logik verknüpft dann die Werte und erzeugt
das Ausgangssignal a_out, z.B. so:

assign a_out = (a4 + a3 + a2) / 2;

Den Code habe ich nicht durch einen Compiler laufen gelassen, es kann
also sein das da ein paar Syntaxfehler auftauchen. Aber das Prinzip
sollte verständlich sein. Wahrscheinlich habe ich das mit den
Startwerten falsch gemacht. Ich bin davon ausgegangen die werde einzeln
per Clk über a_in eingegeben. Natürlich kannst du die auch beim reset
setzen und dann raus schieben.

Gruß

Günter

Ah ja, danke, das macht schon erstmal Sinn! Kann es nur leider nicht
gleicht testen, weil ich dazu erstmal wieder an den Unirechner müsste.
Das mit den Modulgrenzen hab ich nur aus Redundanz weggelassen, das ist
natürlich klar, dass das drum rum muss :)

Diese assign-Formel hatte ich mir auch schon überlegt, was mein Hänger
glaub ich war, war dass ich zwischen den Startwerten und den folgenden
"a"s variablentechnisch einen Unterschied machen wollte, also zwei Sätze
Variablen dafür.

Was meinst du mit
"Natürlich kannst du die auch beim reset setzen und dann raus schieben."
? Also mit dem "rausschieben". Ich denke, ich werd die Startwerte
komplett in den RESET-Zweig tun können.

Andrea Keil wrote:
> Ah ja, danke, das macht schon erstmal Sinn! Kann es nur leider nicht
> gleicht testen, weil ich dazu erstmal wieder an den Unirechner müsste.
> Das mit den Modulgrenzen hab ich nur aus Redundanz weggelassen, das ist
> natürlich klar, dass das drum rum muss :)

Kennst du Icarus Verilog?

Hier findest du einige Informationen über den Simulator:

http://iverilog.wikia.com/wiki/Main_Page

Zum anschauen von Signalen eignet sich gtkwave:

http://home.nc.rr.com/gtkwave/

Beide sind auch für Windows erhältlich.

...
>
> Was meinst du mit
> "Natürlich kannst du die auch beim reset setzen und dann raus schieben."
> ? Also mit dem "rausschieben". Ich denke, ich werd die Startwerte
> komplett in den RESET-Zweig tun können.

Mit dem "rausschieben" meinte ich einfach, dass die Register a0-a4 ja
wie ein Schieberegister angeordnet sind. Also mit jedem Takt werden die
Werte eins weiter geschoben.

Wenn jetzt die Werte bei Reset gesetzt werden, dann werden ja mit jedem
weiteren Takt die Werte aus der Registerreihe raus geschoben und neue
Werte kommen über a_in rein.