VHDL algorithmische Ebene

[Thomas S. (tschenk)]

Hallo,

und zwar folgendes. Ich muss für die FH ein Projekt in DD 
(DigitalDesign) mit VHDL machen. Die Aufgabe ist eine Stoppuhr mit 
32,768kHz Systemtakt, 1/10 Sekunde auflösung und messen von 
Zwischenzeiten zu erstellen...
Dazu soll ich natürlich ein Modell auf algorithmischer Ebene und eins 
auf RT-Ebene erstellen...
Beide sollen auch mittels ModelSim und einer jeweiligen Testbensch 
verifiziert werden.

Wenn ich es richtig verstanden habe, ist die algorithmische Ebene mehr 
so eine Sache wie C-Programmierung (vom Stil her).

Ich hab mal angefangen so ein wenig was zu machen und würde gerne einmal 
wissen, ob ich denn überhaupt richtig lieg mit dieser Beschreibung auf 
algorithmischer Ebene?

Als Anhang habe ich mal noch ein Bild mit ein wenig Beschreibung 
angehängt, wie überhaupt die Funktion der Stoppuhr aussehen soll. Das 
ganze dann auf RT-Ebene zu erstellen halt ich für nicht das Problem, 
bzw. habe ich ja sogar schon durch teilweise Versuche gemacht.

Danke schon mal...
Grüße Thomas

library IEEE;
use ieee.std_logic_1164.all;

package package_Uhr is
  function BCD_Decode(value: integer range 9 downto 0) return std_logic_vector;
  procedure Count(min:integer; sec1: integer; sec0: integer; milsec: integer);
end package_Uhr;

PACKAGE BODY package_Uhr is
  
  function BCD_Decode(value: integer range 9 downto 0) return std_logic_vector is
  variable result   : std_logic_vector(6 downto 0);
  begin
    case value is
      when 0 => result:="1000000";        
      when 1 => result:="1111001";
      
      when 2 => result:="0100100";
      when 3 => result:="0110000";
      
      when 4 => result:="0011001";
      when 5 => result:="0010010";
      
      when 6 => result:="0000010";
      when 7 => result:="1111000";
      
      when 8 => result:="0000000";
      when 9 => result:="0010000";
     end case;
     return result;
   end BCD_Decode;
   
   procedure Count(min:integer; sec1: integer; sec0: integer; milsec: integer) is
   begin
     --Hier Code zum zählen von 1/10Sekunden, Sekunden und Minuten
  end Count;
end package_Uhr;


library IEEE;
use ieee.std_logic_1164.all;
use work.package_Uhr.all;

entity stoppuhr is
port (
  sw_start          : in std_logic;
  sw_stop           : in std_logic;
  bcd_digit_min     : out std_logic_vector(6 downto 0);
  bcd_digit_sec1    : out std_logic_vector(6 downto 0);
  bcd_digit_sec0    : out std_logic_vector(6 downto 0);
  bcd_digit_milsec  : out std_logic_vector(6 downto 0)
  );
end stoppuhr;

architecture uhr of stoppuhr is
begin process
  variable v_milsec    : integer range 9 downto 0 := 0;
  variable v_sec0       : integer range 9 downto 0 := 0;
  variable v_sec1       : integer range 9 downto 0 := 0;
  variable v_min        : integer range 9 downto 0 := 0;
  variable v_run      : integer :=0;
  variable v_count      : integer :=0;
  variable v_show    : integer := 1;
  begin
    bcd_digit_min <= BCD_Decode(v_min);
    bcd_digit_sec1 <= BCD_Decode(v_sec1);
    bcd_digit_sec0 <= BCD_Decode(v_sec0);
    bcd_digit_milsec <= BCD_Decode(v_milsec);
    wait until sw_start='1';
    v_run:=1;
    v_count:=1;
    while v_run=1 loop
      if v_show=1 then
        bcd_digit_min <= BCD_Decode(v_min);
        bcd_digit_sec1 <= BCD_Decode(v_sec1);
        bcd_digit_sec0 <= BCD_Decode(v_sec0);
        bcd_digit_milsec <= BCD_Decode(v_milsec);
      end if;
      if sw_stop='1' then
        v_count:=0;
      end if;
      if v_count=1 then
        Count(v_min, v_sec1, v_sec0, v_milsec);
      end if;
    end loop;  
  end process;  
end uhr;

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

  process begin
    :
    wait until sw_start='1';
    :
    while v_run=1 loop
      :
    end loop;
  end process;

Soll das mal auf Hardware abgebildet werden?
Falls ja: das würde mich wundern, wenn das ginge  :-/

Sieh dir doch mal an, wie andere so eine VHDL-Beschreibung aufbauen.
Und insbesondere, wie dort Schleifen und Takte verwendet werden:
Schleifen erzeugen parallele (mehrfache) Hardware.
Ein wait until wird zum Takt für ein Flipflop.

BTW: ich würde von der exzessiven Verwendung von Variablen dringlichst 
abraten. Suche mal hier im Forum, das war schon mehrmals das Thema.

[Thomas S. (tschenk)]

Hallo,

na ich weiß was du meinst.
Ich bin mir ehrlich gesagt ein wenig unsicher, aber in der 
Aufgabenstellung steht halt, das ich 2 VHDL-Modelle entwickeln soll. 
Eins eben auf dieser algorithmischen Ebene und eins auf RT-Ebene.
Was ich oben geschrieben hab, wird nicht wirklich auf ner Hardware 
laufen, da stimm ich zu. Keinerlei beachtung von Takt und ähnlichem. 
Selbst die eigentliche Struktur soll ja auf dieser Algorithmischen Ebene 
nicht beachtet werden. Dieses sollte eigentlich mehr ein Modell für die 
Funktion sein.

Auf RT-Ebene hab ich das ganz natürlich ein wenig unterteil nooch alles, 
in kleinere Komponenten (Zähler, BCD-Dekoder, Impulsdetetor usw.) und 
diese ganzen Komponenten über eine Strukturbeschreibung verknüpft. Die 
einzelnen Subsysteme sind natürlich auf RT-Ebene in einer 
Verhaltensbeschreibung mit Taktbeachtung und ähnlichem.
Als Anhang hab ich auch mal nen Screenshot von einem Submodule in der 
Verhaltensbeschreibung auf RT-Ebene noch dran, aber wie gesagt, die 
RT-Ebene ist nicht das eigentliche Problem, mir gehts eben mehr um diese 
algorithmische Ebene und wie des aussehen könnte.

Ich hoff ich hatte das so alles richtig verstanden bei den zig hunderten 
von Skripten die ich bereits teilweise durchforstet hab. Wenn ich 
irgendwie total daneben liegen sollte, wärs super, wenn mich jemand 
darauf hinweisen könnte...

Grüße Thomas

[Fpgakuechle K. (Gast)]

> ... aber wie gesagt, die
> RT-Ebene ist nicht das eigentliche Problem, mir gehts eben mehr um diese
> algorithmische Ebene und wie des aussehen könnte.
>
> Ich hoff ich hatte das so alles richtig verstanden bei den zig hunderten
> von Skripten die ich bereits teilweise durchforstet hab. Wenn ich
> irgendwie total daneben liegen sollte, wärs super, wenn mich jemand
> darauf hinweisen könnte...
>
> Grüße Thomas

Hallo Thomas,

meines Wissens ist algorithmische Eben nirgens standardisiert, da wird 
dein Prof allein wissen, wass er meint. In der Regel meint A-Ebene eins 
drüber über jede Implementierung. Also ohne bit-signale oder std_logic. 
Auch die zahlen representation (BCD) sollte hier kein Thema sein. 
Vielleicht ist auch der Taktteiler unnötig, einfach ein sekundentakt und 
verschiedenen Zwischenspeicher plus "Knopfnachbildung" für 
Start|Stop|Lap etc..

Vielleicht hat der Fachschaftsrat was vom letzte Jahr als Anregung. oder 
nutzt die Sprechstunde des Assistenten.

MfG

[Markus S. (markus_s28)]

Das selbe Problem wie das des Threaderstellers quält mich auch, da die 
Professoren offenbar Ihren Themen nur bedingt variieren. Hat jemand neue 
Erkenntnisse dazu? Danke im Voraus.

[Graka (Gast)]

Die AE ist all das, was man logisch beschreiben kann und sich auf 
Proceduren bezieht und keine Rücksicht auf Hardware nimmt.