Logisch High/Low/RTL_EQ/Latch

[Sin S. (sinbrauchthilfeblyat)]

Hallo meine Freunde und Forenmitglieder,

Ich bin etwas am verzweifeln.

Ich habe 2 Fragen bzw. Probleme, die mir selbst ein Master Student nicht 
beantworten konnte.

Vielleicht könnt ihr nem Hobbymäßigen VHDLer ein bisschen helfen.

Ich finde entweder keine passende Erklärung auf Deutsch oder Englisch, 
oder ich verstehe die Erklärung einfach nicht. Wenn ich diese 2 
Schaltungen endlich verstehe, dann bin ich ein großen Schritt weiter, 
danke meine Freunde!!!

Ich beschäftige mich derzeit mit einfachen Gatter-Schaltungen und den 
ganzen VHDL Grundlagen. Das es 3 verschiedene Möglichkeiten zur 
Beschreibung gibt, habe ich verstanden!!!

Nun weiß ich wie die Verhaltensbeschreibung sprich das RTL-Design mit 
Xilinx auszusehen hat für die Verhaltensbeschreibung. Die Data Flow oder 
auch Structur Beschreibungsform verstehe ich vollkommen!!!

Aber die Verhaltensbeschreibung Behaviour Description...damit habe ich 
ein paar Probleme:

Folgendes RTL_Design ist richtig und passt zum XOR-Gatter in der 
Beschreibungsform!!!

Bild 1:

Ich habe früher mal in C oder Assembler Mikrocontroller programmiert ein 
wenig. Aber da ist abhängig davon, wie der PIN intern geschaltet ist, ob 
Masse mein Signal auf How oder Low zieht.

Normalerweise habe ich gelernt Masse bedeutet Low. Zumindest früher und 
in meiner Jugend. Auch Arduinos habe ich so immer programmiert. Also 
über die Masse Leitungen auf 0 gezogen. Generell habe ich noch Probleme 
mir RTL Design und Umsetzung im FPGA vorzustellen. Es ist eben kein Code 
in C oder eben ein 74er Modell mit Käfern oder echten Gattern drauf, 
sondern eben über meine SRAM Zellen Speicher ich mir logisch eine eins 
oder null und mach dann da Zeugs mit. Ich habe noch mit ROMs oder PROMs 
den Teilen bei denen man mit UV Licht den Speicher löscht gearbeitet.

1.) Hierzu gerne ein paar Tipps oder Anregungen. Danke ^^

Jetzt zu Bild 1:

IN0 IN1 Y-Ausgang
0    0   0
1    0   1
0    1   1
1    1   1

Das ist die normale Logiktabelle für das XOR-Gatter also die Logik in 
diesem Sinne gespeichert in LUTs auf englisch in meinen FPGA durch 
setzen von 1sen und 0len.

Wenn ich nun die Annahme treffe, dass Ground eine logische 0 ist, und 
zwar immer!!! dann ist mein Ground logisch 0.
Nun lege ich meine Masse auch auf logisch 0!!! Masse ist also Low!!!

Dann reicht es ja erstmal, dass ich den Fall INO=1 und IN1=0 untersuche.

IN0=1 geht mit einer 1 in den RTL_EQ. Dieser hat nun eine 1 und eine 0 
durch den Ground an seinen beiden Eingängen. Somit gleich der RTL_EQ 
block ab, da beide ungleich sind, gibt es den Boolschen Wert (ich bin 
leider eher der Informatiker C++ oder Java) mit false also einer 0 auf 
den RTL_EQ Ausgang. Einen EQ kenne ich sonst nur aus Cubase oder 
ProTools.

Naja Equation also abgleichen. Der VHDL Code passt. Der zweite RTL_EQ 
bekommt eine 0 und eine 0. Somit gibt er auf den Ausgang eine 1 weil es 
true ist. Okay keine zwei == sondern nur ein =. In der Schule war ich in 
Informatik echt gut. Immer so eine 2+ oder 1-.

Naja. VHDL ist einfach schwer.

Jetzt geht also eine 0 in den I0 des oberen AND-Gatters und eine 0 in 
den I1 des oberen AND-Gatters. Somit kommt am Output eine 0 raus. Unten 
kommt eine 1 und eine 1 in das AND-Gatter. Somit kommt eine 1. Die 1 
geht an den Select Eingang des Multiplexers.

2.) Ich habe gelernt (habe nicht soviel Ahnung von elektrischen Dingen), 
dass für select = 0 ich den Eingang I0 schalte und für select = 1 den 
Eingang I1 schalte. Ist das soweit generell richtig?

Aber bei dem Multiplexer des RTL Designs steht bei I0 S=1 und bei I1 
S=default.

Also es kommt nun eine 0 auf den I0 Eingang wegen der Masse und eine 0 
aus dem oberen Gatter in den I1 Eingang dann.

Der Select Eingang schaltet eine 1 also auf den I1. Somit geht eine 0 
auf den Ausgang!!!

3.) Für 1 0 und 0 1 muss mein XOR-Gatter doch eine 1 rausgeben.

Der Code ist definitiv richtig.

if IN0 = '0' and IN1 = '1' then
OUTPUT_XOR <= '1';
elsif IN0 = '1' and IN1 = '0' then
OUTPUT_XOR <= '1';
else
OUTPUT_XOR <= '0';
end if;

Auch alles Sensitiv auf die Eingangssignale. Erstmal totale Grundlagen 
ohne Takt und alles. Ich sitze da seit 5 Stunden dran und verstehe 
nicht, wie ich den Pfad des RTL_Designs entlang gehen soll.

4.) Ist das vielleicht nicht wirklich implementierbar sondern wird 
abstarkt dargestellt?


Dann eine weitere Frage die mich sehr beschäftigt um komplexere Aufgaben 
verstehen zu können.

Was ist das genau nur diese Bestandteile?

Und wie könnte ich dazu eine Datenflussbeschreibung machen? Und wieder 
das Problem mit Masse und Ground und was ist eben logisch 0 was ist 
logisch 1 und was wählt der Multiplexer für seinen dementsprechenden 
Select Eingang aus.

In C++ kann ich alle möglichen Dinge schnell und einfach bauen, kleine 
Computerspiele über das CMD Fenster oder auch komplexe Dinge mit 
drehenden Grafiken. Also ich konnte das mal sehr gut. In Java mussten 
wir mal in der Schule einen MP3 Player bauen. Allerdings war die mp3 
Wiedergabe Bibliothek (ich glaube selbst erstellt) schon vorhanden. Wir 
mussten also nur noch über Queue oder Stack oder einen Baum mit Pointer 
ich weiß es schon gar nicht mehr das ganze auswählen. Vielleicht hätte 
ich beruflich was mit Technik oder Informatik machen sollen. Da denke 
ich viel drüber nach. Zurück zum eigentlichen Thema.


Mein Ansatz wäre für die Komponente, erstmal die Entity und die Port 
Beschreibung zu machen. Also die Deklaration richtig? Ich benutze zu 
gerne Informatik Wörter.

Ich hatte mir beides aufgemalt, so kann ich das besser nachvollziehen 
und die Linien entlang gehen mit der Hand und schauen wohin mich der Weg 
dann führt. Ich habe tendenziell Probleme logische Dinge auf einem 
Bildschirm nachzuvollziehen. Auch Logiktabellen oder andere logische 
Dinge muss ich auf einem Blatt aufmalen.

Als Input Signale in Form von bit hab ich meine Signale S_1 S_2 und S_3 
definiert.

Als Output Signal würde ich jetzt mein S_Out als out bit definieren.

Also in Port rein

port(
S_1, S_2, S_3 : in bit;
S_Out : out bit);

Dann ganz normal Architektur of Name der Entity mein is

und dann geht es rund

Meine Idee:

Select 0 = auswählen von I0=0 am Multiplexer.
Select 1 = auswählen von I1=0 am Multiplexer.

Dann wäre das Bauelement aber ohne Nutzen. Also schein hier vielleicht 
die Masse doch 1 zu sein?

Dann würde ich für S_1=0 die Masse auswählen und die 1 auf den Ausgang 
geben sofern Masse 1 bedeutet am Multiplexer und für Select = S_1 
entspricht es hier für den Wert 1 würde ich den Wert von Ground also 0 
auf den Ausgang geben.

S_1 Y_Mux
0     1
1     0

5.) Dann würde der Multiplexer wie ein Inverter arbeiten?

6.) Was ist den nun richtig für a) den Select Eingang, b) für den Ground 
(0 oder eine 1), c) für die Masse (0 oder eine 1).


architecture Probe of <Name_Entity> is
begin

S_Out <= S_2 AND S_3   x    NOT S_1

end Probe;

7.) Wo ist mein gedanklicher Fehler?
8.) Ist es egal ob ich entity, port, end, if oder AND groß oder klein 
schreibe? Bei manchen Dingen macht es keinen Unterschied bei anderen 
bekomme ich Fehler dabei heraus.

Meine Idee: Ich habe mein AND Gatter und meinen Mutliplexer der je 
nachdem wie jetzt genau Masse, Ground und Select definiert sind, als 
Invertierer oder als Nichtsnutz der einfach nur Ressourcen und 
Gatterlaufzeit verschwendet meinen Eingang S_1 wie er ist auf den 
FlipFlop gibt.

Im Internet habe ich viel zu FlipFlops gefunden. Ein Latch ist wohl 
sowas wie ein Zustandsgesteuerter Speicher, der quasi je nachdem was am 
Eingang anliegt, den vorherigen Zustand speichert oder den neuen Zustand 
speichert.

Kein Clocksignal in Ordnung.

9.) Aber wie soll ich einen Latch also einen FlipFlop explizit 
implementieren. Dafür habe ich keinen Code gefunden. VHDL macht doch 
gewisse Bereiche wo es automatisch FlipFlops gibt ohne das ich die 
explizit programmiert also beschrieben habe.

10.) Laut Logiktabelle gibt es aber auch je nachdem ob es ein DD, JK FF 
FlipFlop ist, verschiedene Zustände, die nicht erreicht werden dürfen 
oder eben nicht genau definiert sind.

11.) Ebenso gibt es FlipFlops die Zustandsgesteuert, Zustands und 
Taktgesteuert und nur Taktgesteuert sind? Oder wird das nur überall 
anders genannt? Weil auch wenn der taktgesteuert ist, der Folgezustand 
ist von dem vorherigen Zustand abhängig.

12.) Ebenso fand ich jede Menge FlipFlop Zeichnungen wo es noch einen 
invertierten Ausgang oder Zustand gab oder der Ausgang eines 
Multiplexers zurückgeführt wurde. Fehlt bei dem RTL einfach der 
Multiplexer und die Rückführung. Ist die direkt im Block enthalten? Ich 
bin etwas überfragt.

13.) In der Mitte der beiden Logikfunktionen habe ich ein X stehen 
gelassen. Vielleicht kann mir einer erklären wie ich die beiden 
miteinander verknüpfen kann damit eben das Verhalten erfüllt wird. Ich 
will nah an Schaltungen arbeiten und damit etwas rumprobieren.

Ich hab auch Leute gesehen die haben lustige Dinge gemacht so richtig 
Nerd mäßigen Spaß mit VHDL. Aber dafür muss man erstmal die Grundlagen 
verstehen.

14.) Was mir noch einfällt: Ich habe einen Prozess mit 
Sensitivitätsliste. Danach kommt die Verhaltungsbeschreibung mit if, 
ifelse, else und then dieser ganze Kladeradatsch. Dann kommt ja am Ende 
end if und end process.

Kann ich zwischen end if und end process noch etwas paralellläufiges 
implementieren oder erst nach end if und nach end process? Ebenso ist es 
möglich, da es eben ja keine Programmiersprache ist, nach end if und end 
process ein signal zu definieren. Ziel ist quasi ich habe meinen MUX 
oder mein XOR Gatter in der Verhaltensbeschreibung. Nun Definiere ich 
mit if then else elseif die ganzen Verhalten, die meine Komponente 
erfüllen soll. Ich ordne meinen Ausgang aber keine Werte wie 1 oder 0 
zu, sondern benutze ein internes Signal, welches nicht zuvor zwischen 
der Architektur und dem begin definiert wurde. Also benutze ich mein 
internes signal und ordne dem meine Werte 1 oder 0 für das XOR Gatter 
oder den Mutliplexer zu. Nun definiere ich erst am Ende mein Signal. Und 
ordne dann das Signal dem wahren Output der Entity zu.

15.) Muss das Signal vor end process definiert werden? Ist es möglich da 
es ja eine Hardwarebeschreibungssprache ist, dass so zu machen? Habe ich 
dadurch Laufzeit Vorteile oder mehr Stabilität? Wäre das dann 
Paralellläufig oder Nebenläufig? Darf eine Datenflussbeschreibung 
niemals einen Prozess enthalten?

Ich hoffe ihr versteht meine Anliegen als Anfänger. Exsplizit auf meine 
Situation konnte ich leider keinen Thread finden der auf solche RTL 
Designs Grundlegend eingeht und das ganze gut erklärt. Ebenso werden auf 
diversen Webseiten viele Codes und Beschreibungsformen besprochen. 
Manchmal wird dann auch das jeweilige RTL Design gezeigt. Aber wirklich 
ins Detail die einzelnen Pfade entlang gehangelt mit Erklärung wird 
nirgendwo leider.

Vielleicht könnt ihr mir helfen in den nächsten Tagen damit ich weiter 
komme ich bedanke mich.

Cooles Forum hier aufjedenfall

Mit freundlichen Grüßen und Gesundheit wünschend

Sin

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

Sin S. schrieb:
> Naja. VHDL ist einfach schwer.
Nein. VHDL ist einfach nur eine Sprache. Das, woran es bei dir klemmt, 
ist grundlegendes Verständnis für Digitaltechnik. Und deshalb hängst du 
dich an irgendwelchen Begrifflichkeiten und Pseudodefinitionen auf.

> Wenn ich nun die Annahme treffe, dass Ground eine logische 0 ist, und
> zwar immer!!!
Diese Annahme gilt dann so lange, bis einer was Anderes annimmt und das 
kundtut.

> dann ist mein Ground logisch 0.
Ja klar, du hast das ja gerade eben angenommen und so für dein System 
definiert.

> Nun lege ich meine Masse auch auf logisch 0!!! Masse ist also Low!!!
Korrekt. Das sind 2 weitere Definitionen.
In anderen Systemen könnte Masse auch logisch 1 sein (das wäre dann 
"negative Logik") und es kann auch sein, das Masse "High" ist, wenn die 
Schaltung kurioserweise z.B. mit -3,3V versorgt werden würde.

Aber im Allgemeinen gilt:
Ground ist einfach das englische Wort für Masse. Dorthin wird in den 
meisten Fällen 0V als Bezugspotential gelegt. Und wenn nichts anderes 
vereinbart ist, dann darf man positive Logik annehmen und 0V als "Low" 
ansetzen und stattdessen auch '0' schreiben.
Dann gilt also
Masse = GND = 0V = Low = 0
und
Versorgungsspanung = Vcc = 3V3 = High = 1
Darüber muss man aber eigentlich kein Wort verlieren, es ist schlicht 
egal.

> Okay keine zwei == sondern nur ein =
So wie in den allermeisten anderen Programmiersprachen auch. Hier 
solltest du eigentlich sagen "C ist schwierig".

> 1.) ...
> Der VHDL Code passt.
Ja. Wenn auch nach unnötig vielen mentalen Umwegen.

> 2.) Ich habe gelernt (habe nicht soviel Ahnung von elektrischen Dingen)
Man lernt ja immer weiter. Was man mal gelernt hat kann schon veraltet 
und überholt sein.
> dass für select = 0 ich den Eingang I0 schalte und für select = 1 den
> Eingang I1 schalte. Ist das soweit generell richtig?
Generell ist hier nichts richtig oder falsch. Diese Namen werden nur 
verwendet, dass man die Signale auseinander halten kann. Was wie 
geschaltet wird, steht im konkreten Datenblatt.
Und natürlich wäre es sinnvoll. Wenn I0 mit 0 bzw I1 mit 1 am select 
geschaltet würde.

Übrigens: warum hampelst du da auf einmal mit Multiplexern herum, wenn 
du vorher alles mit Gattern gemacht hast? Denn das sind schon wieder 2 
Abstraktionsebenen: der Multiplexer ist letztlich nur eine reale 
Ausführung einer logischen Funktion. Alles, was ein Multiplexer macht, 
könnte auch mit Logikgattern beschrieben werden.
Oder andersrum: im "echten Leben" schreibe ich eine 
Verhaltensbeschreibung und der Synhtesizer macht daraus dann logische 
Funktionen und Multiplexer.

> 7.) Wo ist mein gedanklicher Fehler?
Du vermischt unterschiedliche Abstraktionsebenen kunterbunt und 
verkantest dich gnadenlos in der Thematik: grade schreibst du was von 
"Masse" und dann sofort etwas von einem "Zustand". Das erste ist 
härteste Hardware, das zweite eine logische Definition für einen 
Automaten. Du reibst dich an Kleinigkeiten und Begriffen auf. Und zudem 
verwendest du Begriffe selbst völlig beliebig und führst beliebige neue 
Begriffe ein. Das sorgt zusätzlich für Verwirrung.

> 14.) Was mir noch einfällt: Ich habe einen Prozess mit
> Sensitivitätsliste. Danach kommt die Verhaltungsbeschreibung mit if,
> ifelse, else und then dieser ganze Kladeradatsch. Dann kommt ja am Ende
> end if und end process.
Halte dich nicht an Begrifflichkeiten auf.

> Kann ich zwischen end if und end process noch etwas paralellläufiges
> implementieren oder erst nach end if und nach end process?
Nebenläufiger Code verwendet andere Syntaxelemente und kann natürlich 
nicht in einem sequentiellen Block verwendet werden.

> 9.) Aber wie soll ich einen Latch also einen FlipFlop explizit
> implementieren. Dafür habe ich keinen Code gefunden. VHDL macht doch
> gewisse Bereiche wo es automatisch FlipFlops gibt ohne das ich die
> explizit programmiert also beschrieben habe.
Immer wenn ein 'event im Code auftaucht (so eines ist auch im 
rising_egde() und falling_edge()), wird letztlich (mindestens) ein 
Flipflop instantiitert werden.

> 10.) Laut Logiktabelle gibt es aber auch je nachdem ob es ein DD, JK FF
> FlipFlop ist, verschiedene Zustände, die nicht erreicht werden dürfen
> oder eben nicht genau definiert sind.
Im FPGA gibt es nur simple taktgesteuerte D-Flipflops.

> 11.) Ebenso gibt es FlipFlops die Zustandsgesteuert, Zustands und
> Taktgesteuert und nur Taktgesteuert sind? Oder wird das nur überall
> anders genannt? Weil auch wenn der taktgesteuert ist, der Folgezustand
> ist von dem vorherigen Zustand abhängig.
Natürlich ist der Ausgangspegel des Flipflops vom Eingangspegel 
abhängig. Ob das letztlich ein "Zustand" ist, hängt davon ab, wie dieses 
Flipflop eingesetzt wird.

> wie ich den Pfad des RTL_Designs entlang gehen soll.
Häng dich doch nicht am Wort "RTL-Design" auf.

> Wenn ich diese 2 Schaltungen endlich verstehe, dann bin ich ein großen
> Schritt weiter,
Fangen wir mal mit der linken Schaltung an. Was ist gegeben? Und was 
wird gefordert?  Was soll die Schaltung tun? Was soll denn da letztlich 
zwischen Input0, Input1 und OUTPUT_XOR passieren?
Beschreibe die eigentliche, ursprüngliche Aufgabe mit wenigen Worten und 
ohne eigene Erklärungs- bzw. Lösungsversuche.

[Christoph Z. (christophz)]

Ich versuche es mal mit einer Buchempfehlung:
Vom Gatter zu VHDL: Eine Einführung in die Digitaltechnik
ISBN 978-3728131256

[Sin S. (sinbrauchthilfeblyat)]

Vielen Lieben Dank ihr zwei,

Gerade Lothar hat mir hier und da nochmal die Augen geöffnet. Und auch 
Danke an Christoph, für die Buchempfehlung.

Ich werde mal schauen das ich das Buch über Medimops oder so als 
gebrauchtes Exemplar für nen guten Kurs ersteigern kann!!!
Hat bei anderen Sachen wie Mikrocontrollern auch geklappt!!!

Es ging mir nur darum: Ich habe den Code implementiert und Vivado 
spuckte mir eben genau diese Schaltung (RTL-Schema) raus. Und egal wie 
ich die Pfade entlang gehe und meine zwei Eingänge setze, ich komme 
nicht auf meine XOR-Logik am Ausgang des MUX!!! Das ein Mux aus 
einzelnen Gattern besteht, weiß ich. Ich habe mit PROMs, 
Mikrocontrollern und ich meine ich hab sogar mal vor Jahren mit nem Chip 
der nur aus &-Gattern bestand (74er? Oder teilweise festverdrahtete 
Logik...wo ich die Ein und Ausgänge verbunden habe, i dont know) und 
einer großen Logiktabelle per KV Diagramm, die Logik selbstständig per 
Verdrahtung umsetzen können. Hab derzeit allerdings nur nen Arduino 
rumliegen. Ich war früher mal echt gut in ET und so ein Zeug. In 
Schulzeiten war ich Mitglied der freiwilligen ET AG. Hat mir immer Spaß 
gemacht in der 8/9 Klasse. Vielleicht fehlt mir das Talent. Und ich habe 
starke Gedächtnislücken. Ich vergesse extrem schnell Syntax und 
Grundlegende Dinge. Habt ihr da Tipps?

1.) Das Problem ist, es geht einfach nicht auf. Wenn Erde logisch 0 ist 
und Masse auch logisch 0 und meine RTL-Schaltung so herauskommt und ich 
richtig verstanden habe, wie die Funktionsblöcke funktionieren (RTL_EQ 
gibt quasi Boolean raus), dann kommt für Select 0 entspricht I0...eben 
für IN0 = 1 und IN1 = 0 keine 1 am Ausgang der Gesamtschaltung raus, wie 
es für XOR gefordert wäre...mit IN0 meine ich den vorderen Input...I0 
den Input des Mux.

Lothar M. schrieb:
> In anderen Systemen könnte Masse auch logisch 1 sein (das wäre dann
> "negative Logik") und es kann auch sein, das Masse "High" ist, wenn die
> Schaltung kurioserweise z.B. mit -3,3V versorgt werden würde.

2.) Ja, aber in meinem RTL Design steht ja ganz klar das Vivado mir 
ausspuckt:

I0 S=1 b
und I1 S=Default

Was hat der Schmarn zu bedeuten? Das Masse hier also doch 1 also High 
ist? Wie soll das ohne Pullup gehen? Ebenso S=Default für I1...

Ich will eben Gatterlogik und Digitaltechnik verstehen. Ich will aus 
VHDL Code eine Schaltung mir denken können und aus der Schaltung mir die 
Logik und den Code erschließen können. Heißt wie komme ich nur mit dem 
Schaltplan auf meine Logik XOR, ohne das mehr gegeben ist ich quasi 
reverse das ganze anpacke.

Lothar M. schrieb:
> Übrigens: warum hampelst du da auf einmal mit Multiplexern herum, wenn
> du vorher alles mit Gattern gemacht hast?

3.) Weil Vivado mir da nen Multiplexer hinsetzt...und ich will versuchen 
genau die Schaltung zu verstehen und warum ich nicht auf meine passenden 
Ausgänge der XOR Logik komme. Ich habe mir auf Blättern und in Paint 
sämtliche Wege und 1/0 aufgemalt. 5 Stunden lang. Ich habe sogar Masse 
als 1 definiert oder die Erde als 1 die in den RTl_EQ reingehen (was ja 
falsch ist, beide sind hier 0?!), es kommt nicht das richtige heraus.

Lothar M. schrieb:
> rising_egde() und falling_edge()), wird letztlich (mindestens) ein
> Flipflop instantiitert werden.

4.) Also weil es sich um sequentielle Logik handelt und ich quasi über 
FlipFlops Werte halten und ein synchronisieren kann, richtig?

5.) Ich beschäftige mich seit Weihnachten (hatte nichts zu tun wegen 
Corona) immer wieder intensiv jeden Tag 3 bis 5 Stunden abends nach 
Arbeit mit FPGAs und allem. Nach über einem Monat bin ich gefühlt, immer 
noch nicht groß weiter gekommen. Sofern ich die XOR-Schaltung verstehe 
wie ich sie schalten muss, was das S=default bedeutet und wie das 
richtige Verhalten rauskommt, und eben ob RTL_EQ quasi so funktioniert, 
dass er den Eingang mit dem zweiten Eingang also der Erde=logisch 0 
abgleicht und einen Boolean für True oder False rausgibt, bin ich schon 
mal viel weiter!!!

Lothar M. schrieb:
> Du vermischt unterschiedliche Abstraktionsebenen kunterbunt und
> verkantest dich gnadenlos in der Thematik: grade schreibst du was von
> "Masse" und dann sofort etwas von einem "Zustand". Das erste ist
> härteste Hardware, das zweite eine logische Definition für einen
> Automaten. Du reibst dich an Kleinigkeiten und Begriffen auf. Und zudem
> verwendest du Begriffe selbst völlig beliebig und führst beliebige neue
> Begriffe ein. Das sorgt zusätzlich für Verwirrung.

Danke! Da muss ich besser differenzieren! Eben. Und du sagst ich halte 
mich an Begrifflichkeiten fest. Ich bin leider jemand, der sehr strikte 
Regeln braucht um Dinge zu verstehen. Und es gibt gefühlt immer mal 
wieder Ausnahmen in allen möglichen Bereichen. Eigentlich ist VHDL sehr 
logisch und stringent aufgebaut.

Lothar M. schrieb:
>> Wenn ich diese 2 Schaltungen endlich verstehe, dann bin ich ein großen
>> Schritt weiter,
> Fangen wir mal mit der linken Schaltung an. Was ist gegeben? Und was
> wird gefordert?  Was soll die Schaltung tun? Was soll denn da letztlich
> zwischen Input0, Input1 und OUTPUT_XOR passieren?
> Beschreibe die eigentliche, ursprüngliche Aufgabe mit wenigen Worten und
> ohne eigene Erklärungs- bzw. Lösungsversuche.

Ich möchte ein exklusives Oder erreichen. So wie es beispielsweise beim 
Halbaddierer der Fall ist. Also die reine Summe als Ausgang erzeugen. 
Für 00 ist es 0. Nur wenn einer der beiden 1 ist, wird es 1, wenn beide 
1 sind, wird es 0 und ich bekomme einen Übertrag...den C Ausgang (hier 
entfernt von der Aufgabe) könnte man mit einem einfachen AND-Gatter 
umsetzen, nur wenn beide 1 sind, Carry=1.

6.) Logik verstehe ich. Ich möchte aber eben reproduzieren können.

Schaltung gegeben...ich weiß nicht das es ein XOR-Gatter ist, wie sieht 
die Tabelle aus.

7.) Okay Logik bei sequentiellen Dingen wird von FlipFlops eingefasst. 
Wie sehe den mein VHDL Code zu so einer Schaltung aus? Ich setze 
keinerlei Clock Events, nichts.

Schaltung 2 eben mit dem Mux, dem AND und dem RTL_Latch.
Wenn Masse obwohl da dran S=1 steht im RTL Design, eine 0 bedeutet und 
Erde wo S=Default dran steht für meinen Eingang I1, für select = 1 
ausgewählt wird, obwohl da Default steht, dann gibt der Multiplexer ja 
egal was ich eigentlich mache, eine 0 auf den Ausgang meines 
Multiplexers.

Meine Frage ist eigentlich simple. Es macht doch keinen Sinn, der 
Multiplexer würde dann ja immer, egal was S_1 als Select Signal macht, 
eine 0 auf seinen Ausgang geben!!! Und eben was bedeutet S=Default und 
S=1. Wenn Erde und Masse beide logisch eine 0 sind!!! In der Regel.

Wenn ich eben keine Datenblätter habe sondern nur meine Schaltung. Und 
wie sehe als Data Flow Description als Einzeiler meine Digitalschaltung 
aus. Ich will genau diese 2 Schaltungen verstehen, dann kann ich dieses 
Grundlegende Verständnis auf andere übertragen. Bitte helft mir. Ich 
recherchiere so viel...wenn ich da drauf eine Lösung finde, finde ich 
sie auch auf komplexere Schaltungen.

8.) Außerdem rede ich hier von Zuständen, weil der RTL_Latch im Design 
keinen CLK Eingang aufweist, sondern eben nur einen Data und einen G 
Eingang. Somit ist er für sequentielle Logik nicht zu gebrauchen, da er 
ein Zustandsgesteuerter FlipFlip ist.

9.) Demzufolge hätte VHDL dieses RTL Design ja nie ausspucken dürfen, 
wenn nur der einfache Taktgesteuerte vorhanden ist und alles andere wie 
RAM oder Register oder LUTs aus einer Kaskadierung bzw Zusammenschaltung 
mit weiteren Komponenten beruhen.

10.) Wie sehe für so eine Schaltung ein guter Ansatz aus, sofern nur die 
Schaltung gegeben ist, um daraus OUTPUT <= S_2 and S_3  x   ´0´;
zu machen. X ist das dazwischen. Ich kann ja dazwischen keine 
sequentielle Logik verwenden in meiner Zuweisung, nur darüber über if 
rising edge clock event und clock = 1...

Und der Mux würde ja immer 0 ausspucken. Wie geht das. Ohne If darüber, 
ohne Clock Eingang am FlipFlop? Bitte helft mir.

11.) ror und rll gehen ja leider nicht mit Standard_Logic...warum? Weil 
Standard_Logic mehr Zustände als nur High und Low annehmen kann?

12.) Noch eine letzte Frage:
Zur initialisierung eines Vectors mit 0llen...der eine variable Breite 
über Generic Naturals aufweist...aber die Instanziierung der 0llen wird 
erst bei einem process per Sensitivitätsliste ausgeführt...also keine 
wirkliche Instanziierung am Anfang bei der Deklaration...sondern einfach 
nur 0llen zuweisen an alle Stellen, da er Variable Breite Aufweist...

Ich würde einfach


Def Generic etc.

signal probe_vec : bit_vector (GENERIC_VAR-1 downto 0);

...

probe_vec <= probe_vec and (not probe_vec);

Achja was für zusätzliche Parameter kann ich bei der Instanziierung noch 
angeben?

signal probe_vec : bit_vector [optional????](GENERIC_VAR-1 downto 0);

Kann ich die Instanziierung mit Others auch nach der Definition des 
Datentypus vornehmen und dann die Breite des Vectors festlegen? Ich habe 
ziemlich viele Schreibweisen mir angeguckt, es muss zwischen Datentyp 
und der Breiten (downto oder to) Definition laut Literatur noch optinale 
Dinge geben, ein zweites Signal müsste ich per Komma vor dem : 
<Datentyp> schreiben. Aber was kann ich dahinter vor dem ( downto ) 
schreiben? Dort gibt es Optionen, ich finde nur nicht was dort hin kann.

Ist das auch hier abhängig davon, mit welchem Chip ich arbeite? Welche 
VHDL Syntax mir zur Verfügung stehen, trotz desselben Herstellers? Ich 
meine ror und rll sind seit 1993 Bestandteil der Syntax.


Ich habe zu allem möglichen gesucht in Literaturen und allem aber finde 
es nicht so, dass ich es verstehe oder auf mein Problem angepasst. 
Deshalb muss ich fragen. Wenn mir jemand das erklären kann, macht es 
klick und ich bin einen riesen Schritt weiter. Ich bin nur an der Grenze 
meiner eigenen Erklärungs und Recherche Fähigkeiten angelangt. Wenn 
einmal einer mit das in Ruhe erklären könnte, ich würde es verstehen und 
dadurch auch neue Sachen viel schneller lernen.


Mit freundlichen Grüßen

Sin

[Christoph Z. (christophz)]

Sin S. schrieb:
> Ich vergesse extrem schnell Syntax und
> Grundlegende Dinge. Habt ihr da Tipps?

Ich habe zu jeder Programmiersprache die ich aktiv gebrauche (VHDL, 
Python, TCL, Matlab) und zu jedem Tool (Emacs, VIM, Git) ein Cheat-sheet 
oder "in a nutshell" Buch auf meinem Tisch liegen.
Das Zeug ist alles zu ähnlich und doch verschieden, dass ich mir das 
merken könnte. :-)

Sin S. schrieb:
> Es ging mir nur darum: Ich habe den Code implementiert und Vivado
> spuckte mir eben genau diese Schaltung (RTL-Schema) raus. Und egal wie
> ich die Pfade entlang gehe und meine zwei Eingänge setze, ich komme
> nicht auf meine XOR-Logik am Ausgang des MUX!!!

Das war die wichtigste Information, die in deinem Eröffnungspost gefehlt 
hat.
Dann ist uns auch klar, wieso solche Schaltungselemente vorkommen 
können.

Was aber fehlt, damit wir dich unterstützen können ist der VHDL Code, 
den du in Vivado hineingesteckt hast und, falls vorhanden, deine 
Testbench die zeigt, dass dein Code auch im Simulator das macht, was du 
von einem EXOR erwartest.

Also das ganze VHDL File, nicht nur den Ausschnitt den du gepostet hast 
(der soweit auch zu passen scheint).

Sin S. schrieb:
> 11.) ror und rll gehen ja leider nicht mit Standard_Logic...warum? Weil
> Standard_Logic mehr Zustände als nur High und Low annehmen kann?

Nein, weil bei std_logic unbekannt ist, ob es als signed oder unsigned 
interpretiert wird. ror und rll sind erst für die Typen signed oder 
unsigned aus der Library numeric_std definiert.
Hier meine Quelle: 
https://stackoverflow.com/questions/53389379/vhdl-ror-and-rol-operations

Sin S. schrieb:
> Achja was für zusätzliche Parameter kann ich bei der Instanziierung noch
> angeben?
>
> signal probe_vec : bit_vector [optional????](GENERIC_VAR-1 downto 0);
> [...] Dort gibt es Optionen, ich finde nur nicht was dort hin kann.

Gemäss dem Buch das ich hier habe, würde es theoretisch noch die 
Schlüsselwörter "register" und "bus" geben für den optionalen Teil (sog. 
Guarded Signals). Das Buch sagt aber auch gleich:
"Guarded signals (register and bus) are obscure and are generally to be 
avoided"

Also nicht aufhalten lassen davon. Einfach ignorieren, dass es da noch 
was geben würde :-)
(Ja, genau solche Dinge machen eine Sprache nicht einfach zu lernen...)

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

Sin S. schrieb:
> Ich habe den Code implementiert und Vivado spuckte mir eben genau diese
> Schaltung (RTL-Schema) raus.
Zeig doch mal genau den Code und einen Screenshot vom fraglichen Plan. 
Dann könenn wir mal drüber diskutieren, warum der Synthesizer das so 
gemacht hat.

Und natürlich gibt es da auch urige Effekte. Hier fühlt sich der 
Synthesizer bemüßigt, alline durch das Umformatieren des Codes zwei 
zusätzliche Inverter einzubauen:
http://www.lothar-miller.de/s9y/archives/52-Kompakte-Flankenerkennung.html
Das macht in der Praxis aber nichts aus, weil diese "zusätzlichen" 
Bauteile sowieso im FPGA sind und ohne zusätzlichen Aufwand verwendet 
werden können.

[Sin S. (sinbrauchthilfeblyat)]

Mittlerweile habe ich da irgendwie durch stundenlange Simulationen 
durchgeblickt und bin um einiges weiter in der VHDL Thematik 
reingekommen.

Eine wirklich wichtige Sache beschäftigt mich aber immer noch ein wenig 
sehr...

Wenn ich ein Schieberegister implementiere ganz normal dann habe ich ja 
quasi mehrere Möglichkeiten

a) Ich könnte mit einem Signal arbeiten

architecture Behavior of shift_reg is
signal QINT: STD_LOGIC_VECTOR (7 downto 0) := (others => '0');
begin

shift_reg: process (CLK, Reset)
  begin

  if Reset = '1' then
    Q <= (others => '0');
  elsif CLK = '1' and CLK'event then
    QINT <= D & QINT(7 downto 1 ) ;
    Q <= QINT;
  end if;

end process shift_reg;

end Behavior;

Dann wäre das ganze um einen Takt Verzögert


b) ich könnte mit einer Prozessinternen Variablen arbeiten für eine 
direkt Ausgabe wenn ich das richtig verstanden habe. Somit wäre das die 
Variante, für keinerlei Verzögerung bei der Ausgabe des 
Schieberegisters, thats right? Oder habe ich da einen Fehler.

begin

shift_reg: process (CLK, Reset)
variable QINT: STD_LOGIC_VECTOR (7 downto 0) := (others => '0') ;
  begin

  if Reset = '1' then
    Q <= (others => '0');
  elsif CLK = '1' and CLK'event then
    QINT := D & QINT(7 downto 1 );
    Q <= QINT;
  end if;

end process shift_reg;

end Behavioral;


c) Ich könnte die Signalzuweisung auf Q <= meines Signals paralellläufig 
machen, also außerhalb des Prozesses. Für meine Variable geht das ja 
nicht, die ist nur dort bekannt, wo sie deklariert wurde und ist 
Prozessintern.

shift_reg: process (CLK, Reset)
  begin

  if Reset = '1' then
    Q <= (others => '0');
  elsif CLK = '1' and CLK'event then
    QINT <= D & QINT(7 downto 1 ) ;
    -- Q <= QINT;
  end if;
end process shift_reg;

Q <= QINT; -- Paralell/Nebenläufig

end Behavior;

Was würde das für einen Zeitlichen Unterschied, im Vergleich zum ersten 
machen?

Achja und wie erzeuge ich reine Verzögerungsglieder mit VHDL?

Ihr habt mir viel weitergeholfen ich verstehe inzwischen ein wenig mehr.

Mit freundlichen Grüßen

[Vancouver (Gast)]

Sin S. schrieb:
> Was würde das für einen Zeitlichen Unterschied, im Vergleich zum ersten
> machen?

In der ersten Variante wird Q nur bei einer aktiven Flanke zugewiesen, 
in der dritten Variante immer. Folglich bekommst zu bei V3 das Ergebnis 
einen Takt früher an  als bei V1. V3 wird übrigens nicht funktionieren, 
weil du Q innerhalb und außerhalb des Prozesses zuweist. In V1 musst du 
QINT resetten, nicht nur Q, in V3 nur QINT.

Zu V2: Keine Ahnung ob das funktioniert, aber wie schon oft gesagt in 
diesem Forum: Lass die Finger von Variablen, gerade als Anfänger. Es 
gibt nur wenige Situationen, in denen Variablen wirklich von Nutzen 
sind, z.B. wenn du komplexe Ausdrücke in einfachere Teilausdrücke 
zerlegen willst. Aber man kommt fast immer ohne Variablen aus.
In reinen Simulationsmodellen und Testbenches ist das etwas anderes, da 
kannst du mit Variablen fast das gleiche machen was man aus der Software 
kennt. Aber im Design stiften sie hauptsächlich Verwirrung.

Sin S. schrieb:
> Achja und wie erzeuge ich reine Verzögerungsglieder mit VHDL?

Was meinst du mit rein? Dein Schieberegister ist ein 
Verzögerungsglied. Es verzögert das Eingangssignal um 8 Takte, wenn du 
das letzte Bit als Ausgang betrachtest.

[Simon (Gast)]

Sin S. schrieb:
> IN0 IN1 Y-Ausgang
> 0    0   0
> 1    0   1
> 0    1   1
> 1    1   1
>
> Das ist die normale Logiktabelle für das XOR-Gatter also die Logik in
> diesem Sinne gespeichert in LUTs auf englisch in meinen FPGA durch
> setzen von 1sen und 0len.

Ist das nicht eine OR Verknüpfung?

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

Sin S. schrieb:
> ich könnte mit einer Prozessinternen Variablen arbeiten für eine direkt
> Ausgabe wenn ich das richtig verstanden habe

Nein, du hast den Sinn und Zweck von Signalen und Variabeln noch nicht 
richtig verstanden.

> Was würde das für einen Zeitlichen Unterschied, im Vergleich zum ersten
> machen?

In einem VHDL-Prozess gibt es keinen "Zeitunterschied". So ein Prozess 
passiert per Definition "sofort" mit einer Änderung in der 
Sensitivliste.

> Achja und wie erzeuge ich reine Verzögerungsglieder mit VHDL?

Gar nicht.
Lies das hier: 
http://www.lothar-miller.de/s9y/archives/80-Hello-World!.html und 
exerziere es selber durch.

Und dann mach das Lauflicht und arbeite dich langsam Schritt für Schritt 
weiter durch. Ich empfehle dafür dringenst ein Buch, das sich mit 
"VHDL-Synthese" beschäftigt.

Wenn du das durch hast, dann weißt du, dass Zeiten ab vom ns-Bereich 
aufwärts in VHDL über Zustandsautomaten (aka. Zähler) erzeugt werden. 
Und Zeiten unter einer ns werden nicht in VHDL sondern per manuellem 
Gefrickel im Layouteditor "so in etwa" hingebastelt.

Sin S. schrieb:
> weiter in der VHDL Thematik reingekommen.

Bitte verwende die [vhdl] Tags. Die Anleitung ist bei "Wichtige Regeln - 
erst lesen, dann posten!" unter "Formatierung" zu finden.

[Sin S. (sinbrauchthilfeblyat)]

Ich hatte mir jetzt schon 3 Bücher zugelegt.

Aber eine Sache ist mir immer noch etwas rätselhaft.

Wenn es heißt die Daten sollen in ein Schieberegister von links 
hineingeschoben werden oder das Schieberegister soll mit jedem Takt nach 
Rechts schieben.

Für mich bedeutet von links hineingeschoben

a) reg <= DATAIN & reg(7 downto 1);

Und wenn dann der am weitesten rechts stehende Wert ausgegeben werden 
soll, wäre das für mich reg(0);

Nun fand ich aber mitunter das links hineinschieben sowas bedeutet was 
auch 2 Kollegen von mir so verwendet haben für "Daten von links je 
Taktflanke in ein Register schiebt". Die haben aber auch wenig Ahnung 
und sind sich nicht sicher. Was ist jetzt was? Ich kann nicht mehr. 
Stundenlang, etliche Forenbeiträge, 3 dicke Bücher a 500 Seiten...ich 
finde da nichts passend zu.

b) reg <= reg(6 downto 0) & DATAIN;


Und der am weitesten rechts stehende Wert reg(7) ist...

bei

signal reg : std_logic_vector(7 downto 0):="00000000";

Macht das für mich wenig Sinn. Ich gucke doch immer von links nach 
rechts. Nur bei to ist eben mein MSB reg(7) bei downto und mein LSB 
reg(0) bei downto vertauscht.

Je nach Literatur und Quelle ist das anders formuliert.

Das ist extrem wichtig für mich was es jetzt bedeutet. Wenn Daten von 
Links in ein Schieberegister geschoben werden. Oder eben Wortlaut 2 das 
Schieberegister mit jeder Flanke die Werte nach Rechts schiebt. Ich 
brauche dazu explizit die Erklärung.

Ich weiß ich kann alles drehen und wenden wie ich will aber ich möchte 
wissen was genau für diese Formulierung gefordert wird. Oder was diese 
Formulierung aussagt. Ich sitze da jetzt 4 Stunden dran und finde 
eigentlich nur, dass von links reingeschoben bedeutet das es eben von 
links nach rechts reingeht also für mich in meinem Verständnis Code a).

Ein Kollege hat es aber genau andersrum. Ich brauche genau darauf die 
Definition, damit ich das nicht verwechsle.

Zum Thema VHDL Tags. Wenn ich da auf das VHDL oben drücke öffnet sich 
eine weiße Seite wo Schrift steht.

Deine Webseite ist echt gut.

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

Sin S. schrieb:
> Das ist extrem wichtig für mich was es jetzt bedeutet. Wenn Daten von
> Links in ein Schieberegister geschoben werden. Oder eben Wortlaut 2 das
> Schieberegister mit jeder Flanke die Werte nach Rechts schiebt. Ich
> brauche dazu explizit die Erklärung.

Das ist, wie wenn nach einem Münzwurf der eine sagt: "Kopf ist oben" und 
ein anderer sagt: "Zahl ist unten". Beide meinen *exakt das selbe.*

Es ist egal, ob ich sowas schreibe:

-- 1
--                         links  ..  rechts
signal reg : std_logic_vector(7 downto 0):= (others=>'0');
:
reg <= DATAIN & reg(7 downto 1) when rising_edge(clk);

Oder so was:

-- 2
--                        links .. rechts
signal reg : std_logic_vector(0 to 7):= (others=>'0');
:
reg <= DATAIN & reg(0 to 6) when rising_edge(clk);

In beiden Fällen kommt das selbe heraus.
Z.B. bei einer Dauer-'1' am DATAIN das hier:

clk   ____________---------_________---------_________---------_________--------_________
reg   00000000    10000000          11000000          11100000          11110000

Und natürlich ist beim 1. Fall (mit downto) nach der ersten Taktflanke 
das Bit reg(7) bereits '1', beim 2. Fall (mit to) ist das reg(0) = '1', 
weil beide jeweils das "linkste" Bit im Vektor sind.

Mein Tipp: nimm solche einfachen und grundlegenden Konstrukte und 
probiere sie am Simulator aus.

> Zum Thema VHDL Tags

Soooo arg schwierig ist das nun auch nicht: tippe genau die Zeichenfolge 
dort ab und ersetze die Buchstaben "VHDL-Code" durch deinen VHDL-Code

Du kannst das ja einfach mal selber probieren und dann zum Test erst 
mal auf den "Vorschau"-Knopf drücken statt auf "Beitrag 
veröffentlichen".