@ Tuan (Gast)

>if s'event and s="00" then
>   t1<='0';
>   if s'last_value="11" then -- hier ist s=-1 gleich s="11"
>   t2<='1' after 2 ns;
>   t3<='1';
>   else
>   t3<='1' after 2 ns;
>   t2<='1';
>   end if;
>   t4<='0';
>end if;

Solche Sachen mit "after 2ns" und s'last_value sind nicht
synthetisierbar, die kann man nur zum simulieren verwenden.

>Wie kann ich diese Probleme aufheben?

Was soll denn überhaupt rauskommen? Eine Verzögerung von 2ns haben die
meisten Logikbaustein sowieso.

MFG
Falk

@ Tuan (Gast)

>also ich benutze ISE Webpack von Xilinx und möchte von VHDL-Code ein RTL
>Schematik zu erzeugen,

Schon klar, aber was soll dein Code machen? SDRAM Ansteuerung?

MfG
Falk

@ Tuan (Gast)

>Nein, ich möchte einen 3 Punkt Wechselrichter ansteuern.

Gut. Du willst dann sicherlich sowas wie Dead Time einstellen, damit die
Transistoren einer Halbbrücke nicht gleichzeitg leiten und die
Versorgungsspannung kurzschliessen. Das macht man anders. Du brauchst
einen schnellen Takt (einige MHz) und einen Zähler. Mittels Zähler
kodierst du dann, Transistor auschalten, ein paar Takte warten,
Transistor einschalten.

>Ich weiß nicht ob es noch irgendeine Methode gibt, um ein RTL Schematik
>zu erstellen, natürlich aus VHDL code.

Wozu? Aber in ISE gibt es einen Schematics Viewer, der die aktuelle
Schaltung als Blockdiagramm anzeigen kann.

MFG
Falk

@ Tuan (Gast)

> kann ich auch mit VHDL gehen? Schneller Takt ist
>hier clock, meinst du?

???

Merkwürdige Formulierung, ich schätze mal Deutsch ist nicht deine
Muttersprache.

Ja, das macht man so in VHDL und clock ist das englische Wort für Takt.

MFG
Falk

@ Tuan (Gast)

>ich lerne VHDL seit 1 Woche, kannst du mal zeigen, wie ich " warten ein
>paar Takte" in VHDL schreiben kann ( also auch synthetisierbar)

Die Frage ist vor allem. Welche Kenntnisse hast du von Digitaltechnik?
VHDL ist "nur" ein modernes Werkzeug. Ohne diese Kenntnisse wirst du mit
VHDL nicht viel Erfolg haben.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity cnt is
    Port ( clk : in std_logic;
           p1 : out std_logic;
           p2 : out std_logic;
           p3 : out std_logic);
end cnt;

architecture Behavioral of cnt is

signal cnt: std_logic_vector(3 downto 0);

begin

process(clk)
begin
  if rising_edge(clk) then
    cnt <= cnt +1;

    if cnt=2 then p1 <= '1'; else p1<='0'; end if;
    if cnt=7 then p2 <= '1'; else p2<='0'; end if;
    if cnt=12 then p3 <= '1'; else p3<='0'; end if;

  end if;
end process;

end Behavioral;

MFG
Falk

@  Tuan (Gast)

if (s(0)'event and s(0)='0') und (s(1)'event und s(1)='0') then

So was macht man schon mal gar nicht. Das mit 'event ist nur für echte
Takte gut.



>für die Verzögerung beim Einschalten des t2 habe ich after-Anweisung
>verwendet, aber wie ich gewusst habe,dass after-Anweisung bei der
>Synthese ignoriert wird.

Warum hast du sie dann verwendet???

>ich habe auch mal mit einen Zähler versucht, um diese Verzögerung zu
>lösen aber es geht nicht

Doch.

>die obere VHDL-code liefert natürlich kein erwartetes Ergebnis weil der
>innere if-Befehl nur einmal ausgeführt wird.

Dein Code ist totaler Murks. Tut mir leid.

>hast du irgendeine Idee um diese Verzögerung in VHDL zu lösen?

Ja, lies mein Posting nochmal und denk drüber nach. Und beschäftige dich
mit den Grundlagen von Digitaldesign und VHDL. Das kann man nicht in
drei Sätzen vermitteln.

VHDL FAQ

MFG
Falk

@ Tuan (Gast)

>Aber mit diesem Verfahren kommt es zu einer Unflexibilität weil 3 Punkt WR
>immer in einem festen Programm funktionieren muss.

???
Das war ein Beispiel! Man kann eine Steuerung durchaus mit Eingängen
versehen, woduch der Ablauf beeinflusst werden kann. Auch in VHDL.

MFG
Falk

@ Tuan (Gast)

>meinst du reset und enable und count_direction?

Zum Beispiel. Doch dazu musst du erstmal KLAR formulieren, was die
Schaltung machen soll. Am besten mit Zeitdiagrammen. DANN kann man das
in VHDL umsetzen.

> Ich kann mir nicht vorstellen.

MFG
Falk

@ Tuan (Gast)

>Dateianhang: IMG_0670.JPG (1,8 MB, 4 Downloads)

HALLO!!!

Bitte vor dem posten solcher Bilder ETWAS nachdenken und sich über
Bildformate informieren!!!

>hier ist die Schaltung und der Zeitdiagramm.

Schon mal ein Ansatz.

>3 Punkt WR soll die Blockspannung am Ausgang liefern, deren

Fehlen da nicht T5 und T6 im Zeitdiagramm.

>Grundschwingung mit einer Sollschwingung entspricht.
>Mit diesem Diagramm habe ich versucht, das VHDL code zu erzeugen aber
>bis jetzt keinen Erfolg.

Klar, dir fehlen (noch) einige wichtige Grundlagen.
Aber du sagtest etwas von "Unflexibilität". Was soll denn flexibel
gesteuert werden?

MfG
Falk

@ Tuan (Gast)

>die Schaltung stellt eigentlich nur einen Brückenzweig dar. Es gibt hier
>überhaupt keine T5 und T6.

Warum 4 Transistoren pro Zweig? Hat mit dem Problem erstmal nix zu tun,
interessiert mich aber.

>> Klar, dir fehlen (noch) einige wichtige Grundlagen.

>was für die wichtige Grundlagen?

Digitaltechnik, State machines, VHDL Grundkenntnisse etc.

>ich meine dass ohne ansteuerbare Eingänge wie dein obiges Code es
>unflexibel ist weil es nur von clk und counter abhängt. Ich wollte hier
>mit einem außeren Steuersignal ( vom Mikrocontroller zB) ansteuern.

Schon klar, aber wie ich bereits sagte, dass war nur ein Beispiel, wie
man Signale in so einem Fall verzögert. Keine fertige Lösung!

Was soll die Steuerung denn bewirken? Soll die Frequenz gesteuert werden
(Frequenzumrichter)? Notaus? Richtungsumkehr?

MfG
Falk

@ Tuan (Gast)

>Bei dem Synthesenvorgang mit XST-Synthezer von Xilinx tretten es jedoch
>noch einige Warnings auf.

>Kannst du mir sagen,ob solche Meldungen auf dem Process im Hardware
>beeinflussen können und wie ich diese weglassen kann.

Die Warnungen sind unkritisch.

ABER!

Lass den Unsinn mit den Variablen! Nimm Signale! Variablen is VHDL sind
NICHT so wie Variablen in normalen Programmiersprachen.

MFG
Falk

@ Tuan (Gast)

>>Lass den Unsinn mit den Variablen
>wieso?

Weil die meisten Leute den Unterschied zwischen Signalen und Variablen
in VHDL nicht WIRKLICH verstanden haben. So auch du.

> wenn ich die Signale nehme, dann wird t nicht sofort auf 0 bei
>der Signalwechselung von s gesetzt, sondern nach einem Takt. Das will
>ich aber nicht.

Dann musst du es anders programmieren. Mit deinem jetzigen Vorgehen
schiesst du dir früher oder später ins Knie.

>Aber wieso an der Stelle, wo ich mit Blau markiert habe, findet keine
>Signalwechselerkenung von s statt. Eigentlich muss es passieren ( s von
>00 auf 01) und t3<='0'; t2<='1'; t4<='0'; t1<='1' nach 3 Takte werden
>gesetzt.
>Habe ich was falsch in Code?

Siehe oben. Variablen und Signale.

> Kannst du mal korrigieren?

Nutze Signale und staune.

MFG
Falk

@ Tuan (Gast)

>Dateianhang: wave_signal.JPG (55,3 KB, 1 Downloads)

Bildformate

>>Weil die meisten Leute den Unterschied zwischen Signalen und Variablen
>>in VHDL nicht WIRKLICH verstanden haben. So auch du.

>was meinst du damit? Das wäre gut wenn du ausführlicher mit Beispiele
>erklärst.

Tja, das ist nicht so einfach.

Signale in VHDL sind in einem getakteten Prozess immer das, was man so
landläufig in der Digitaltechnik unter einem Signal versteht. Es wird
durch ein FlipFlop gespeichert und über eine entsprechende Logik vor dem
FlipFlop generiert. In einem Prozess kann man Signale beliegig oft
zuweisen, allerdings wird am Ende nur die Anweisung ausgeführt und in
Hardware compiliert, welche entweder logisch erfüllt ist (in IF
Abfragen) oder zum Schluss steht.

signal a: std_logic;

process(clk)
begin
  if rising_edge(clk)
    a <= not b;
    a <= b or c;
  end if;
end

Die erste Zuweisung fliegt bei der Compilierung raus und es bleibt
übrig.

process(clk)
begin
  if rising_edge(clk)
    a <= b or c;
  end if;
end

Ganz anders Variablen. Diese sind im wesentlichen Hilfsmittel, um
logische Strukturen zu generieren, aber NICHT dazu bestimmt, Signale zu
speichern. Leider kann man sie teilweise auch wie Signale verwenden,
hier entsteht das Problem. Eine Variable wird sofort in einem Prozess
zugewiesen, alte Zuweisungen werden quasi "mitgeschleppt". Ausserdem ist
eine Variable nur in dem jeweiligen Prozess sichtbar und kann ausserhalb
nicht gelesen werden.

process(clk)
variable a: std_logic;
begin
  if rising_edge(clk)
    a <= not b;
    a <= b or c;
  end if;
end

Das Ergebniss der Compilierung sieht dann so aus

process(clk)
variable a: std_logic;
begin
  if rising_edge(clk)
    a <= (not b) or c;
  end if;
end

>Zeig mir mal was du hast mit Signale um dieses Problem zu lösen.

Dazu muss ich erstmal wissen, wie deine Signale generiert werden sollen.
Zeichne mal ein Timingdiagramm, beschreibe wie die Eigangssignale die
Ausgangssignale beinflussen sollen. Das kann man dann in VHDL umsetzen.

MFG
Falk

>In einem Prozess kann man Signale beliegig oft
>zuweisen, allerdings wird am Ende nur die Anweisung ausgeführt und in
>Hardware compiliert, welche entweder logisch erfüllt ist (in IF
>Abfragen) oder zum Schluss steht.
 Das bin ich einverstanden.

process(clk)
variable a: std_logic;
begin
  if rising_edge(clk)
    a <= not b;
    a <= b or c;
  end if;
end

bin nicht einverstaden weil es mit Variablen nicht "<=" zuweisen darf.

>Dazu muss ich erstmal wissen, wie deine Signale generiert werden sollen.

Das habe ich schon mal bei der alten Postings erwärnt. Aber kein
Problem, ich erkläre noch einmal.

Die Ausgangsignale t1,t2,t3,t4 sollen durch das Eingangssignal s
generiert. s
hat 3 Werte : 1,0, -1 und wird durch 2Bit-Kombination kodiert.

Hier stehen 2 Schwerpunkte:
 1. Die Wechselerkennung von s (zB s von 1 auf 0...,es gibt 6
Möglichkeiten zu erkennen)
 2. Für jede Umschaltung von s werden die Ausgangssignale entsprechend
generiert. zB
  Wenn s von 1 auf 0 springt, dann:
           t1<='0';
           t2<='1';
           t3<='1' nach eine Verzögerung ( lösen mit zähler);
           t4<='0';
>Zeichne mal ein Timingdiagramm, beschreibe wie die Eigangssignale die
>Ausgangssignale beinflussen sollen
 Ich glaube ,das Timmingdiagramm schon im Dateianhang bei dem obigen
Posting (das von Kamera aufgenommen, 1,8Mb) gegeben wurde, kannst du mal
checken?
Hoffe dass du in VHDL umsetzen kannst.

MFG
Tuan.

@ Tuan

>Das habe ich schon mal bei der alten Postings erwärnt. Aber kein
>Problem, ich erkläre noch einmal.

Ok, hatte ich vergessen.

>Hoffe dass du in VHDL umsetzen kannst.

Sicher ;-)

Z.B. So.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity three_phase is
   Generic (trs_delay: integer:=5);
    Port ( clk : in std_logic;
           s : in std_logic_vector(1 downto 0);
           t : out std_logic_vector(4 downto 1));
end three_phase;

architecture Behavioral of three_phase is

type state_type is (high, zero, low, high_zero, zero_low, low_zero, zero_high);

signal state : state_type;
signal cnt : std_logic_vector(7 downto 0);

begin

-- Kodierung von s
--
-- s ="01"     = 1  = HIGH
-- s ="00"     = 0  = Zero
-- s ="11"     = -1 = LOW

process(clk)
begin
  if rising_edge(clk) then
    case state is
      when high =>
        t <= "0011";
        cnt <= conv_std_logic_vector(trs_delay,8);
        if s="00" or s="11" then
          state <= high_zero;
        end if;

      when zero =>
        t <= "0110";
        cnt <= conv_std_logic_vector(trs_delay,8);
        case s is
          when "11" => state <= zero_low;
          when "01" => state <= zero_high;
          when others => null;
        end case;

      when low =>
        t <= "1100";
        cnt <= conv_std_logic_vector(trs_delay,8);
        if s="00" or s="11" then
          state <= low_zero;
        end if;

      when high_zero =>
        t <= "0000";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= zero;
        end if;

      when zero_low  =>
        t <= "0000";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= low;
        end if;

      when low_zero =>
        t <= "0000";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= zero;
        end if;

      when zero_high  =>
        t <= "0000";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= high;
        end if;

      when others => null;
    end case;
  end if;
end process;

end Behavioral;

Du musst noch die Kodierung von T1..4 für die Übergangszustände
eintragen. Ansonsten sollte es so gehen.
Die Übergangszustände werden für "trs_delay" Takte ausgegeben.

MfG
Falk

Uuups, ich sehe gerade, dass der direkte Übergang von LOW nach HIGH und
umgekehrt anders läuft. Naja, aber das kann man ja leicht anpassen, das
Prinzip der State Machine wird mit dem Beispiel hoffentlich klar.

MfG
Falk

nochmal danke Falk, deine Idee sieht gut aus aber ich habe noch einige
Sache, die ich nicht so ganz verstanden habe

>cnt <= conv_std_logic_vector(trs_delay,8);


diese Zuweisung ist mir unbekannt, das kann nicht compilieren.
Ich kenne nur zB:  cnt<= conv_std_logic_vector(arg,size:integer);  arg
kann std_logic, signed, unsigned, integer sein.

>Uuups, ich sehe gerade, dass der direkte Übergang von LOW nach HIGH und
>umgekehrt anders läuft

habe ich angepasst.

>das Prinzip der State Machine wird mit dem Beispiel hoffentlich klar.

ja bin ich klar.

>Du musst noch die Kodierung von T1..4 für die Übergangszustände eintragen

meinst du Übergangszustand = Transienter Zustand im Timingdiagramm, zB
von s="01" auf s="00" soll dieser Übertragungszustand t="0100" ???

>-- Kodierung von s
>--
>-- s ="01"     = 1  = HIGH
>-- s ="00"     = 0  = Zero
>-- s ="11"     = -1 = LOW

sind hier deine Kommentare oder muss ich selbt kodieren?

MFG
Tuan.

>>cnt <= conv_std_logic_vector(trs_delay,8);


>diese Zuweisung ist mir unbekannt, das kann nicht compilieren.
>Ich kenne nur zB:  cnt<= conv_std_logic_vector(arg,size:integer);  arg
>kann std_logic, signed, unsigned, integer sein.

Sorry, ich habe Generic(tsr_delay:integer:=5) im Code vergessen.
Deswegen konnte es nicht compilieren, jetzt aber schon. Was ist das
jedoch zum Bedeuten diese Zuweisung cnt <=
conv_std_logic_vector(trs_delay,8);

MFG
Tuan

@ Radis Wayne (adler82)

>>cnt <= conv_std_logic_vector(trs_delay,8);

>diese Zuweisung ist mir unbekannt, das kann nicht compilieren.

???
ISE von Xilinx macht das ohne Probleme.

>>Uuups, ich sehe gerade, dass der direkte Übergang von LOW nach HIGH und
>>umgekehrt anders läuft

>habe ich angepasst.

Zeig mal den neuen Quelltext.

>meinst du Übergangszustand = Transienter Zustand im Timingdiagramm, zB
>von s="01" auf s="00" soll dieser Übertragungszustand t="0100" ???

Ja.

>>-- Kodierung von s
>>--
>>-- s ="01"     = 1  = HIGH
>>-- s ="00"     = 0  = Zero
>>-- s ="11"     = -1 = LOW

>sind hier deine Kommentare oder muss ich selbt kodieren?

Kommentare. SO iunterpretiert die State Machine den Vektor s.

MFG
Falk

@ Radis Wayne (adler82)

>Deswegen konnte es nicht compilieren, jetzt aber schon. Was ist das
>jedoch zum Bedeuten diese Zuweisung
>cnt <= conv_std_logic_vector(trs_delay,8);

Ganz einfach. Das Generic trs_delay wird von Integer in std_logic_vector
mit der Länge 8 umgewandelt und cnt zugewiesen.

MFG
Falk

@Falk

kannst du mal deinen Testbench Wave Form anschicken. Danke!

MFG
Tuan

>Zeig mal den neuen Quelltext.

process(clk)
begin
  if rising_edge(clk) then
    case state is
      when high =>
        t <= "1100";
        cnt <= conv_std_logic_vector(trs_delay,8);
        if s="00" or s="11" then
          state <= high_zero;
        end if;

      when zero =>
        t <= "0110";
        cnt <= conv_std_logic_vector(trs_delay,8);
        case s is
          when "11" => state <= zero_low;
          when "01" => state <= zero_high;
          when others => null;
        end case;

      when low =>
        t <= "0011";
        cnt <= conv_std_logic_vector(trs_delay,8);
        if s="00" or s="11" then
          state <= low_zero;
        end if;

      when high_zero =>
        t <= "0100";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= zero;
        end if;

      when zero_low  =>
        t <= "0010";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= low;
        end if;

      when low_zero =>
        t <= "0010";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= zero;
        end if;

      when zero_high  =>
        t <= "0100";                -- Muster fur Uebergangszustand eintragen
        cnt <= cnt -1;
        if cnt=0 then
          state <= high;
        end if;

      when others => null;
    end case;
  end if;
end process;

>Ganz einfach. Das Generic trs_delay wird von Integer in std_logic_vector
>mit der Länge 8 umgewandelt und cnt zugewiesen.
Wieso musst du das machen wenn du da oben  schon
Generic (trs_delay: integer:=5); und
signal cnt : std_logic_vector(7 downto 0); hast

Mein Testbench Wave Form zeigt immer noch das unerwartet Ergebnis

MFG
Tuan.

@ Falk
dein Code ist korrekt,
ich habe den Testbesch nur in 1 ns ansehen, in diesem Zeitinterval
stimmt es nicht mit dem Code  (initialisierung vielleicht!!!) . Aber
wenn ich zB in 10 ns schauen, dann sieht es besser aus.
Danke schön.

@ Tuan (Gast)

>>Zeig mal den neuen Quelltext.

Bitte nicht solche Fragmente posten, das ist in den meisten Fällen
sinnlos.

>Ist mein Code richtig???

Nein.

Was soll das?

>                cnt2<=conv_std_logic_vector(trs_delay,24);

Hier das Ganze nochmal vollständig.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity three_phase is
   Generic (trs_delay: integer:=5);
    Port ( clk : in std_logic;
           s : in std_logic_vector(1 downto 0);
           t : out std_logic_vector(4 downto 1));
end three_phase;

architecture Behavioral of three_phase is

type state_type is (high, zero, low, high_zero, zero_low, low_zero, zero_high, zero_trans);

signal state : state_type;
signal cnt : std_logic_vector(7 downto 0);

begin

-- Kodierung von s
--
-- s ="01"     = 1  = HIGH
-- s ="00"     = 0  = Zero
-- s ="11"     = -1 = LOW

process(clk)
begin
  if rising_edge(clk) then
    case state is
      when high =>
        t <= "0011";
        cnt <= conv_std_logic_vector(trs_delay,8);
        if s="00" or s="11" then
          state <= high_zero;
        end if;

      when zero =>
        t <= "0110";
        cnt <= conv_std_logic_vector(trs_delay,8);
        case s is
          when "11" => state <= zero_low;
          when "01" => state <= zero_high;
          when others => null;
        end case;

      when low =>
        t <= "1100";
        cnt <= conv_std_logic_vector(trs_delay,8);
        if s="00" or s="01" then
          state <= low_zero;
        end if;

      when high_zero =>
        t <= "0100";                
        cnt <= cnt -1;
        if cnt=0 then
          cnt <= conv_std_logic_vector(trs_delay,8);
          case s is
            when "00" => state <= zero;
            when others => state <= zero_trans;
          end case;
        end if;

      when zero_low  =>
        t <= "0010";                
        cnt <= cnt -1;
        if cnt=0 then
          state <= low;
        end if;

      when low_zero =>
        t <= "0010";                
        cnt <= cnt -1;
        if cnt=0 then
          cnt <= conv_std_logic_vector(trs_delay,8);
          case s is
            when "00" => state <= zero;
            when others => state <= zero_trans;
          end case;
        end if;

      when zero_high  =>
        t <= "0100";                
        cnt <= cnt -1;
        if cnt=0 then
          state <= high;
        end if;

      when zero_trans =>
        t <= "0110";                
        cnt <= cnt -1;
        if cnt=0 then
          cnt <= conv_std_logic_vector(trs_delay,8);
          case s is
            when "01" => state <= zero_high;
            when "11" => state <= zero_low;
            when others => null;
          end case;
        end if;

      when others => null;
    end case;
  end if;
end process;

end Behavioral;

>ich habe den Testbesch nur in 1 ns ansehen, in diesem Zeitinterval
>stimmt es nicht mit dem Code  (initialisierung vielleicht!!!) . Aber
>wenn ich zB in 10 ns schauen, dann sieht es besser aus.

???
Kann nicht sein. Siehe Anhng.

MFG
Falk

@Falk

Dein Code ist fast richtig weil du falsch zugewiesen hast (zB bei
high_zero muss t<="0010" statt "0100" zugewiesen wird). Das war aber
eine Kleinigkeit.

Ich weiß wirklich nicht warum wenn ich den Testbench mit Anfangwert
s="00" oder s="11" gebe, zeigt die Simulation ganz komisch (siehe bitte
Anhang bei meinem alten Posting,datum 30.10, 23:41 Uhr),(bei dir ist
Anfangwert s="01",zeigt es hervorragend!)

Danke für deine Mühe.

MFG
Tuan.

@ Falk
Hallo Falk,

kann man solchen Block: [ Generic (trs_delay: integer:=5);
                            ...
                            ...
                            signal cnt : std_logic_vector(7 downto 0);
                            ...
                            ...
                            cnt<=conv_std_logic_vector(trs_delay,8);]
mit nur eine Zeile wie:   signal cnt:integer:=8;
ersetzen?

MFG
Tuan.

@ Radis Wayne (adler82)

>mit nur eine Zeile wie:   signal cnt:integer:=8;
>ersetzen?

Ja. Aber man sollte den Integer mit einem Range definieren, sonst kann
es schnell passieren, dass dort ein 32 Bit Zähler reinkommt.

MfG
Falk

@Falk
Hallo Falk,

kannst du mal erklären, wieso du den Block [ Generic (trs_delay:
integer:=5);
                            ...
                            ...
                            signal cnt : std_logic_vector(7 downto 0);
                            ...
                            ...
                            cnt<=conv_std_logic_vector(trs_delay,8);]
benutzt hast? Und welche Vorteile hat der gegen den direkt Deklaration
von cnt in integer mit range wie oben erwähnt wurde.

Vielen Dank
schönen Grüß
Tuan.

@ Radis Wayne (adler82)

>kannst du mal erklären, wieso du den Block [ Generic (trs_delay:
>benutzt hast?

Reine Gewohnheit, ich arbeite halt so gut wie immer mit
std_logic_vector, da weiss man direkt wie gross ein Signal ist und man
kann direkt auf die Bits zugreifen. my_signal(4) geht bei Integer nicht.

> Und welche Vorteile hat der gegen den direkt Deklaration
>von cnt in integer mit range wie oben erwähnt wurde.

In diesem Fall. KEINE!

MFG
Falk