Counter VHDL

[teciu (Gast)]

Hallo Zusammen.
Ich habe ein bisschen Mühe mit dem Design eines modulo-n Counters. 
Dieser soll von n-1 rückwärts bis 0 zählen und danach wieder auf n-1 
springen. Der Reset value ist ebenfalls n-1.

Hier ist mein Code:

use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.math_real.all;


entity mod_n_counter is

generic(
    n : integer := 255;
);
port(
    clk       : in  std_ulogic;
    reset      : in  std_ulogic;
    count_out : out std_ulogic_vector(integer(ceil(log2(real(n+1))))-1 down to 0);
);
end mod_n_counter;


architecture behavioral of mod_n_counter is

constant bit_width: integer:= integer(ceil(log2(real(n+1))));
signal present_counter, next_counter : unsigned(bit_width-1 down to 0);

begin

Output_logic : count_out <= present_counter;

Next_state_logic : process(present_counter)
begin
    if present_counter = 0 then
        next_counter <= n-1;
    else
        next_counter <= present_counter - 1;
    end if;
end process;

Registers : process(reset, clk)
begin
    if reset = '1' then
        present_counter <= n-1;
    elsif rising_edge(clk) then
            present_counter <= next_counter;
    end if;
end process;

end behavioral;

Mein Problem nun: Bei meiner next_state_logic will ich ja sagen, dass 
falls der aktuelle Wert 0 ist, er auf n-1 springen soll. Aber kann ich 
das einfach mit n-1 zuweisen? Es scheint mir ein bisschen komisch, weil 
n ja ein Integer ist und mein next_counter ein unsigned ist.

Wie gehe ich hier am besten vor?

[Duke Scarring (Gast)]

teciu schrieb:
> Aber kann ich
> das einfach mit n-1 zuweisen?
Mit to_unsigned sollte die Zuweisung klappen:

    next_counter <= to_unsigned( n-1, bit_width);

Wie lautet denn die Fehlermeldung des Simulators?

Hier sind die Umwandlungsfunktionen vorbildlich erläutert:
http://www.lothar-miller.de/s9y/categories/16-Numeric_Std

Duke

[Markus F. (mfro)]

Warum machst Du das "n"-Generic nicht auch gleich unsigned?

Wenn Du tatsächlich einen unsigned Zähler haben willst, sollte der 
Startwert doch auch unsigned (oder wenigstens natural) sein. Damit 
würdest Du dir eine Typumwandlung sparen (und gleich noch die - 
zumindest theoretische - Fehlerquelle, dass einer deine Entity mit einem 
negativen Startwert instantiiert).

[Vancouver (Gast)]

Waumr Zähler nicht einfach als Integer oder Natural?

[Mulen (Gast)]

Der Aufbau ist generell komplizierter als notwendig. Das könnte man 
übersichtlicher in einem Prozess machen:

process(clk,reset)
begin
    if reset='1' then
        count <= to_unsigned(n-1, bit_width);
    elsif(rising_edge(clk))then
        if count = to_unsigned(0, bit_width)then
            count <= to_unsigned(n-1, bit_width);
        else
            count <= count - '1';
        end if;
    end if;
end;

Wenn du diese "next logic" magst, dann würde ich die 2-Prozess-Methode 
mal ansehen.

[teciu (Gast)]

Liebe alle, vielen Dank für eure Inputs!
Nun zur Erklärung: Ich schreibe demnächst eine Prüfung in VHDL und ich 
möchte mich gut darauf vorbereiten. Wir haben einen ganzen Katalog mit 
Aufgabenstellungen erhalten - ohne Lösungen - und ich versuche jetzt ein 
paar von diesen zu lösen. Ich habe leider auch keine Simulator. Ich 
mache es einfach schriftlich für mich um zu sehen, ob ich die Thematik 
verstanden habe. :) Und ich bin sehr froh um eure Unterstützung.

Jetzt zurück zum Beispiel.
Die Schnittstellen wurden vorgegeben. Sprich clk und rst als std_ulogic 
und count_out als std_ulogic_vector. Beim Rest bin ich frei. Ich soll 
einzig einen parametrisierbaren modulo-n down-counter machen.

@Mulen deine Lösung gefällt mir gut! Ich dachte es wäre übersichtlicher 
mit der next_state_logic. Aber ich habe mich wohl geirrt.
Nun das heisst ich würde meine Code wie folgt anpassen:

entity mod_n_counter is

generic(
    n : integer := 255;
);
port(
    clk       : in  std_ulogic;
    reset      : in  std_ulogic;
    count_out : out std_ulogic_vector(integer(ceil(log2(real(n+1))))-1 
down to 0);
);
end mod_n_counter;


architecture behavioral of mod_n_counter is

constant bit_width: integer:= integer(ceil(log2(real(n+1))));
signal count : unsigned(bit_width-1 down to 0);


process(clk,reset)
begin
    if reset='1' then
        count <= to_unsigned(n-1, bit_width);
    elsif(rising_edge(clk))then
        if count = to_unsigned(0, bit_width)then
            count <= to_unsigned(n-1, bit_width);
        else
            count <= count - '1';
        end if;
    end if;

count_out = std_ulogic_vector(count);

end behavioral;

Wäre das so richtig?


Wenn ich jetzt aber meinen Code nehmen würde und einfach das n als 
unsigned deklarieren würde, wir müsste ich da vorgehen? Weil ich ja 
nicht weiss, was mein n ist. Also ich würde etwas wie generic (n:= 
unsigned(???))

Entschuldigt, ich bin wirklich fleissig am lernen und möchte es gerne 
verstehen. Sorry wenn immer noch ein bisschen Mühe habe.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

teciu schrieb:
> Ich habe leider auch keine Simulator.
Heutzutage kein Problem, solange man einen Browser hat:
https://www.edaplayground.com

> Wir haben einen ganzen Katalog mit Aufgabenstellungen erhalten...
> Die Schnittstellen wurden vorgegeben. Sprich
> clk und rst als std_ulogic und count_out als std_ulogic_vector.
Als unconstrained vector ohne definierte Breite?
Mein Vorschlag: lass doch einfach mal die Aufgabe sehen.
Wenn man nur die Lösungsansätze sieht, muss man sich die Aufgabe 
irgendwie erraten. Das ist umständlich...

[teciu (Gast)]

Ok :) Hier habe ich die Aufgabe angehängt!

[Duke Scarring (Gast)]

teciu schrieb:
> Ich habe leider auch keine Simulator.
Aber Internetzugang, oder?

Da dürfte das hier weiterhelfen:
https://www.edaplayground.com/

Duke

[Duke Scarring (Gast)]

Hmm. Zu knapp gelesen, Lothar war schneller (wie so oft :-)

[berndl (Gast)]

teciu schrieb:
> Ok :) Hier habe ich die Aufgabe angehängt!

dann frag' mal denjenigen, der dir die Aufgabe gestellt hat, ob der 
Reset auch asynchron deaktiviert wird. Und ueberleg' dir mal, was dann 
passieren kann...

[teciu (Gast)]

Das steht jetzt gar nicht und ich denke, das wäre zu umfangreich. 
Einizige Bedingungen sind eben, dass er bei n-1 beginnt, bis 0 runter 
zählt und dann wieder bei n-1 beginnt. Oder eben, nei rst auch wieder 
zurück zu n-1.

[teciu (Gast)]

Mag vielleicht jemand meinen Vorschlag anschauen? (Post bisschen höher 
oben)

:-) Danke!!

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

teciu schrieb:
> Mag vielleicht jemand meinen Vorschlag anschauen?
Passt konzeptionell soweit.
Nach dem Entfernen einiger Syntaxfehler wie z.b. "down to" und -1 statt 
-'1' sowie dem Einfügen des eines "begin" für die Architecture und eines 
"end process" geht die Beschreibung durch den Compiler und ergibt das 
gewünschte Verhalten.

Aber einfacher und übersichtlicher wäre es (wie schon erwähnt) mit einem 
integer als Zähler:

library IEEE;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.math_real.all;

entity mod_n_counter is
   generic(
      n : integer := 255
   );
   port(
      clk       : in  std_ulogic;
      reset      : in  std_ulogic;
      count_out : out std_ulogic_vector(integer(ceil(log2(real(n+1))))-1 downto 0)
   );
end mod_n_counter;

architecture behavioral of mod_n_counter is
   constant bit_width: integer:= integer(ceil(log2(real(n+1))));
   signal count : integer range 0 to n-1;
begin

   process (clk,reset)
   begin
      if reset='1' then
         count <= n-1;
      elsif(rising_edge(clk))then
         if count = 0 then  count <= n-1;
         else               count <= count-1;
         end if;
      end if;
   end process;
   
   count_out <= std_ulogic_vector(to_unsigned(count,bit_width));
  
end behavioral;

BTW: bitte VHDL-Code mit den [vhdl] Tags formatieren. Wie das geht ist 
in der Anleitung über jeder Eingabebox zu finden...