Hallo. Ja, in Ergänzung zu der VDL-Einführung habe ich jetzt hier nochmal
als quasi optionalen Teil so ein bisschen zusammengefasst, was jetzt noch an Wissen,
Hintergrundwissen vielleicht jetzt zur anderen Hardware-Beschreibungssprache beziehungsweise zu VDR AMS interessant ist.
Wie gesagt, bei uns ist der Schwerpunkt eigentlich, VHDL,
aber um das jetzt nochmal so ein bisschen einzuordnen beziehungsweise um Hintergrundwissen zu haben,
jetzt hier nochmal ein bisschen was zu in anderen Hardware-Beschreibungssprachen,
die man so typischerweise hat,
wobei ich da jetzt eigentlich nicht die Sindwachs im Einzelnen vorstellen werde.
Ganz am Ende gibt es noch ein kleines Beispiel,
sondern eher noch ein bisschen was für in generellen Konzepten sage,
vielleicht so Vor- und Nachteilen einzelner Sprachen und so weiter.
Ja, als erstes nochmal etwas zu VRLAMS. Das Akronym
steht dann eben hinten noch für Anna Lock and Mixed Single.
Da geht es eben letztendlich darum, eine analoge VDL-Erweiterung zu haben,
womit man eben quasi sprachlich gesehen mit einer Obermenge.
Zum einen digitale Systeme, wie ganz normal in VADL beschreiben kann.
Daneben aber mit diesem Sprach- oder so taktischen Erweiterungen dann eben zum einen dafür sorgen kann,
dass man eben gemischt analog digitale Systeme auch mitbeschreiben kann.
Also alles, was dann mixt, Single ist. Und darüber hinausgehend dann eben auch etwas,
was dann in diesem Bereich Multidemainfeld,
nämlich das im Prinzip mit der Analogsimulation dann eben nicht nur elektrische Systeme geschrieben werden,
sondern eben auch beliebige, andere physikalische Phänomene mitbeschrieben werden,
wäre dort eigentlich die Beschreibungsmöglichkeiten, Edanges sind zu dem,
was man also in der Regel bei analogen Schaltungsbeschreibungen hat,
nämlich den Aufbau von Differenzalgleichungssystemen,
die dann letztendlich zu lösen sind.
Ja, wie macht man dort jetzt die analoge Modellierung? Da sieht das dann eben so aus,
dass man jetzt also zumindest erstmal bezogen ist auf elektrische Systeme in Analogschaltung im Prinzip nichts anderes hat,
als differenziert Leistungssysteme, also sprich beispielsweise,
wenn wir es also irgendein elektrisches Netz nehmen, nicht,
dann gelten da halt einfach die Kirche auf schon Regeln.
Das heißt, Maschenleichung, Knotenleichung kann aufgestellt werden,
man hat dann also im Prinzip ein gesamtes Gleichungssystem,
was gelten muss und für die dort vorhandenen einzelnen Bauelemente seien das Strom- oder Spannungsquellen,
seien das passive Elemente wie Widerstände oder sah das eben irgendwelche nicht linearen Elemente,
wie jetzt eben irgendwie Idioten, Transistoren und so weiter,
habe ich dann eben entsprechend meine Modelle,
die dann eben in Bezug auf Strom und Spannung letztendlich beschrieben werden können.
So, damit kann man eben gesamteste Franzar-Leichungssystemen aufgestellt werden,
in diesen Differenzialleistungssystemen gibt es dann eben freie Variablen,
beispielsweise die Spannung über zwischen zwei Punkten in meinem Netz oder der Strom durch Anleitung beziehungsweise ein Bauelement und so ein differenz Zahngleichungssystem oder diese Differenzialleistungssysteme,
können dann eben entsprechend so gelöst werden,
dass eben da eine einheitliche Lösung durch einen sogenannten Analox Solver dann erstellt werden kann,
dass man eben sagen kann, dieses Gleichungssystem gilt,
wenn ich jetzt eben für die und die Variablen die und die Werte habe.
So dadurch, dass sich das Ganze dann eben auch noch zeitlich ändert,
also beispielsweise, wenn wir jetzt an irgendwelche Wechselspannungen,
Wechselströme denken, wird dieses Lösungsverhalten dann eben auch nicht statisch beschrieben,
sondern entwickle sich zeitlich, weil wie gesagt, beispielsweise,
wenn man jetzt an einfache Bauelemente, Kondensatoren oder Spuren denken,
nicht das dann letztendlich eben die Spannung über in einem Kondensator sich eben darüber ergibt,
wie ich sich dann also zeitlich quasi der Strome entwickelt,
weshalb wie viel Ladung dann wegen Gott gespeichert werden und so weiter und so fort.
Gut, das ist dann eigentlich all das,
was auch elektrische Simulatoren letztendlich machen,
nämlich sowas aufstellen und entsprechend lösen und das wird dann eben
zu der Zeit des Kretensimulation von VHDL mit hinzugenommen und damit
habe ich dann im Prinzip dann so ein Mixed-Single-Simulator.
Was dabei dann aber eben die Schwierigkeit ist,
ist eben letztendlich diese analoge Erweiterung des Simulationssemantik,
weil ich sowohl zeitlich als auch in Bezug auf die
vorhandenen Werte bei VHDL eigentlich immer mit diskreten Werten arbeite.
Das heißt, bei der Zeit oder bei dem Zeitmodell in VHDL
arbeite ich halt eben mit Emulationszyklen beziehungsweise arbeite ich mit Einheiten,
die sich dann eben als Vielfache einer kleinsten Zeiteinheit definieren.
In diesem Fall wird dann eben als Kurs die kleinste Zeiteinheit in VADL dann,
also sowas wie die Fanpose-Sekunde genommen und damit dann also letztendlich simuliert.
Und alles, was ansonsten an Zeiten, Verzögerungszeiten hat,
sind dann einfach ganztagige Vielfache davon.
Genauso gilt das dann eben natürlich auch für Werte oder Wertmodelle,
dass man dort dann Und zwar bei Verhaltensbeschreibungen im Prinzip sowas
wie Realtypen haben kann oder mit entsprechenden Spracherweiterungen dann auch komplexe Zahlen.
In der Regel arbeitet man aber natürlich, was gerade im digitalen Schaltungsentwurf,
eigentlich immer mit selbst definierten Aufzählungstypen, mit ganz normalen Andiger-Typen,
mit Arrays davon, beziehungsweise dann eben mit beziehungsweise Bit-Vektoren.
So, das, was dann die Schwierigkeit ist,
wenn ich jetzt eben einmal den Digital-Simulator als Ereignis gesteuerten Simulator habe und auf der anderen Seite das Lösen von Differenzalleichungssystemen zu bestimmten Zeitpunkten.
Und das soll jetzt eben entsprechend in einem gemeinsamen Simulationslauf irgendwie gekorpelt werden,
dass letztendlich entschieden werden muss, wann soll also aus dem Digitalmodell dieser analog,
dieser analoge Lösungsmechanismus aufgerufen werden, wann soll er Werte berechnen, wie ist das notwendig. So,
das ist etwas,
was dann letztendlich hinter der Simulation von VDL, AMS-Steck,
wobei die meisten Hersteller von entsprechenden Simulatoren dann quasi ihren jeweiligen VDL-Simulator mit entsprechenden Produkten,
die also quasi jetzt eine analoge Simulation,
also beispielsweise was wie ein Spice-Simulator oder Spector von Cadence,
koppeln und da dann entsprechende Schnittstellen haben,
um die sich dann also auch stependent,
also von Freude der Armes nicht kümmern muss,
wo dann aber grundsätzlich sowas wie zwei unterschiedliche Simulations-Engines dann auch zum einen Satz kommen,
je nachdem,
ob ich mich einer analogen oder digitalen
Welt bewege
Ja, wo ist sowas letztendlich sinnvoll natürlich, wenn ich jetzt also elektrische Systeme entwerfe,
dass ich dann eben auch analoge Komponenten mitsimulieren kann.
Ich und sah das nur irgendwo an den Schnittstellen analog digital wandler.
Ich kann aber eben auch wirklich bis zur gesamten Bordsystem dann mitarbeiten, wo ich dann eben auch irgendwelche Analogschaltungen mit drin habe. Nicht,
wenn ich im Prinzip sowas wie System on a Ship entwerfe,
wo ich jetzt also quasi meinen Mikrocontroller habe, dann aber jetzt,
wenn das mitgerät oder dieses System dann eben beispielsweise in einem Smartphone eingesetzt werden soll,
eben auch noch die gesamten Funkschnittstellen mitrennen habe, die dann eben quasi als analoge Bauelemente oder Bauteilern,
aber eben auch in dem Schiff, in dem Selitionland letztendlich mit drin verbarrot sind.
Eine andere interessante Anwendung sind dann eigentlich mechanische Komponenten,
das ist ändert ihm das,
was ich gerade eben mit solchen Mixed-Domain-Anwendungen hatte,
dass man da eben auch entsprechend die Schnittstellen mit modellieren kann,
sodass ich eben sagen kann, ich habe eine digitale Ansteuerung,
die geht dann quasi über digitale Analogconverter,
dann auf irgendwelche Treiberstufen und ich kann damit jetzt also zum Beispiel in irgendeiner Umgebung einen Motor ansteuern und kann da letztendlich eine Simulation machen von dem Treiber,
von dem elektromagnetischen Fallen des Motors,
wo dann eben Elemente mit reinkommen, wie,
was soll der antreiben, was denn da so irgendwie die Massenträgheiten,
die dann beim Anlaufen überwunden werden müssen.
Welche Last hängt da dran? Das heißt also,
welchen mechanischen Widerstand musste dann eben entsprechend antreiben und sowas.
Und das lässt sich dann eben in eine einzige gesamte Simulation
mit übertragen. Das ist eigentlich die Motivation,
wofür es dann eben sinnvoll sein kann,
VDLAMS einzusetzen
Nur ganz kurz motiviert, jetzt gleich für zwei Beispiele,
wie sie das Ganze anreihen, praktisch aus,
neben dem Standard VDL hat man dann also in Bezug auf die Datentypen eine Erweiterung,
die dann Nature heißt,
mit einer Nature wird im Prinzip sowas für eine Domäne geschrieben,
also sprich physikalisch Ortentfernung oder physikalisch elektrische Nature,
was also hier in dem Beispiel drin ist,
wo ich dann eben sagen kann,
ich habe Spannung und Strom die jetzt jeweils jeder für sich Regelwerte sind,
dann gibt es noch die Möglichkeit,
sowas wie Toleranzbereiche mit einzugrenzen,
wo dann also quasi dann eben auch innerhalb der Metik dann eben auch noch irgendwie so top warst wie Toleranzen mit berücksichtigt werden können.
Und so eine Nature Electrical wird dann eben definiert, dadurch,
dass ich sagen kann, ich habe einmal einen Referenzpunkt,
was also typischerweise in elektrischen Schaltungen dann quasi mein Groundpotenzial ist.
Ich habe dann von irgendeinem Punkt eine Spannung, die quasi gemessen wird als Differenz relativ für Ground.
Und ich habe dann eben noch sowas wie einen Strom,
wo zwischen der zwischen zwei Punkten fließt,
in diesem Fall dann eben dem und dem Punkt,
der dann eben damit dann entsprechend definiert werden kann.
Nicht, das wäre also dann das, was man also jetzt zum Beispiel jetzt für so eine Electrical Nature hätte. So,
und von diesen Datentypen oder dieser Nature kann man dann eben auch wieder Objekte bilden,
beziehungsweise sowas wie einer Entity,
das wäre dann im Prinzip, also einmal ein Terminal,
also ein Referenzpunkt, nicht also quasi,
dass sich da also ein Knoten eines elektrischen Netzes habe,
wo ich dann eben quasi die Spannung bzw. Strom dann eben zu Brown habe oder ich habe eben einen Ort in einem mechanischen System,
wenn ich also jetzt in dem Beispiel eines mechanischen Systems bleibe.
Und dann gibt es sowas wie freie Variablen, Quantities,
das sind eben die Werte, die Zeit kontinuierlich berechnet werden,
die dann eben in dem Gleichungssystem,
was dahinter steht,
dann eben die zur bestimmenden Frauenbarherbgang sind
Ja, an Anweisung gibt es dann eben natürlich auch noch
zusätzliche Anweisungen. Zum einen beschreibt man überhaupt erst mal
die gleiche und das Ganze nennt sich dann Simultane Anweisung.
Dadurch lassen sich dann eben überhaupt erst mal diese Gleichungssysteme aufstellen.
Daneben hat man dabei dann die Möglichkeit,
die Gleichungssysteme partiell definiert zu machen. Das heißt also,
ich kann mit IF oder Case-artigen Verzweigungen dafür sorgen,
dass eben eine Gleichung für Variablen größer gleich null gilt und
eine andere Variante reale Gleichung für Variablen kleiner, null.
Nicht das, was man also typischerweise auch in irgendwelchen Modellierungen hat,
wo ich dann eben solche Fallunterscheidungen habe, wann welche Gleichung letztendlich gelten soll.
Das sind also einmal diese Gleichung selber. Dann gibt es eine Break-Anweisung,
das ist dafür verantwortlich, dass diese Gleichungssysteme quasi neu berechnet,
neu zusammengesetzt werden, was also gerade bei Diskontinuitäten,
also sprich bei abrupten Wechseln in den Zuständen notwendig ist
Und es gibt dann eben ein analoges Äquivalent zu dem,
was also sonst ein Prozess ist, als Umgebung eines Sequenzhellenverhaltens, was dann VDLRMS eben procedural heißt.
Gut, hier erstmal aus dem Bereich der Elektrotechnik,
keine Angst, wir werden jetzt, also hier nicht dahingehend einsteigen, zu beschreiben, was damit genau gemeint ist. Hier ein Beispiel einer Diode. In der Elektrotechnik ist es eigentlich üblich,
dass wenn ich jetzt also irgendwie meine mein System habe, meine Bauelemente,
dass es für die dann eben je nach passendem Anwendungsfall dann eben quasi solche Ersatzschaltbilder gibt,
die letztendlich unter den bestimmten Anwendungsfällen, also je nachdem,
wie jetzt also hier die Betriebsberame da sind,
dafür dann eben sonst so eine Zusammensetzung in diesem Fall aus einer Sprungquelle,
einem seriellen Widerstand und einer inneren Kapazität haben und eben eine Diode wird eben letztendlich modelliert in ihrem Verhalten durch diese drei Bauelemente,
würde dann eben in VDL AMS dann so aussehen,
dass ich hier dann auch wieder letztendlich so eine Entity-Beschreibung habe,
dort dann eben quasi in Generic Form die ganzen Parameter,
die man dann eben typischerweise bei den Bauelementen mit hat,
die eben letztendlich in dem,
was jetzt also hier in diesen zugehörigen elektrischen Gleichungen sind,
dann eben Bauteil spezifisch festzulegen sind,
beziehungsweise sich dann eben aus der Fertigung oder einer Herstellungsherbauelemente ergibt.
Wir haben, wie gesagt, eine Idiode wird bei diesem Modell dann also quasi jedoch zwei Gleichungen geschrieben,
nämlich einmal ein Strom durch die Diode und oder also eben Idee und sprich die Stromquelle und einmal irgendwie,
wie groß, also hier diese Kapazität ist nicht und da gilt dann eben entsprechend,
dass das dann also in diesem Fall dann hier jeweils diesen Leistungen entsprecht,
nicht wo ich dann also hier quasi exponentiell dann also hier über die entsprechenden Ausdrücke das ausrechne,
wie groß dann also letztendlich jeder Strom Home exponentiell anwächst oder nicht,
Unwächst und auf der anderen Seite habe ich dann eben sowas wie die Körperzität dazwischen,
die sich dann also quasi als Differenzartleistung über die Zeit ergibt,
wo ich dann eben gucke, wie jetzt also mit dem Strom hier entsprechend sich die Werte, wie in so einem Kondensatan, beim Aufladen bzw. beim Endladen ändern.
Dieses Modell nennt sich elektrisch gesehen also ein Level-0-Modell bei der Didiode nicht,
da gibt es dann eben noch unterschiedliche andere,
dass es eben bei den Bauelementen einfach dadurch gegeben,
dass man sagen kann, gut, sowas wie ein Widerstand,
der würde jetzt einfach ganz normal durch die Widerstandsformel beschrieben,
wo ich also sage, er ist gleich Udrich I. Nicht,
aber wenn ich jetzt eben solche nicht linearen Elemente habe,
dann hat man eben irgendwelche differenziellen Abhängigkeiten in der Regel mit drin und da hat man dann eben auch zum Beispiel,
wenn man dann nachher in Transistoren reingeht, unterschiedliche Betriebsmodi,
je nachdem, ob ich den brauche, in bestimmten Schaltungsvarianten,
wie ich den betreibe, also sprich soll da betrieben werden,
um jetzt also irgendwie zum Beispiel sowas wie Ströme oder Spannungen zu verstärken oder soll da betrieben werden,
jetzt rein digital gesehen, wie so ein Schalter,
was wir also immer bislang so bei Feld-Effekt-Transistoren kennengelernt haben,
soweit ich das heißt, dass ich immer so kurz vorgestellt habe,
wo ich gesagt habe, dran, das ist doch,
kann man erst mal als Schalter abstrahieren,
nicht dahinter verbergen sich dann eben auch solche Differenzalleitungssysteme und je nachdem,
in welchem Betriebsmodus ich den Transessor betreibe, habe ich dann eben auch teilweise noch unterschiedliche von diesen Leistungssystemen, was entspricht dann so wie diesen unterschiedlichen Levels in so einer elektrischen Simulation.
Gut, in diesem Fall gibt es jetzt also hier als freie Variablen letztendlich,
also einmal die Ladung,
die ist also hier auf dem Kondensator drauf ist und dann eben eine Spannung,
die zwischen Anode und Kathode ist,
die sich also quasi dann durch den Strom,
hier durch die Stromquelle hindurch ergibt, beziehungsweise durch IC und die Spannung,
die dann eben letztendlich darüber anliegt.
Ja, und das, was die Online folgt, ist eben letztendlich nichts anderes,
als dass die Gleichung beziehungsweise diese Gleichungssysteme dann eben hier jetzt über durch drei solcher limutane Anweisungen beschrieben werden.
Nicht, das heißt, ich kodiere hier einmal direkt die Idee in entsprechender Form sinntags,
nicht dann die Ladung, die sich also auf dem Kondensator befindet,
nicht und die Ableitung von der Ladung ist dann nicht mehr Strom hierüber,
was dann also hier über dieses dort als Ableitung, über die Zeit dann letztendlich so geschrieben wird.
Das heißt, damit lassen sich eigentlich eins zu eins solche Gleichungssysteme dann eben direkt modellieren. Gut,
wie gesagt, wenn man das jetzt für größere Scheidungen macht,
sieht man dann eben auch schon,
führt das Ganze dann eben dazu,
wenn ich jetzt also hier für eine einfache Idiode letztendlich schon Vier freie Variablen habe,
die dann also letztendlich durch den Analog-Server zu lösen sind,
dass wenn ich da jetzt also wirklich eine komplexere Schaltung habe von mehreren hunderten,
tausenden oder eben aktuell Milliarden Transistoren,
dass also die Simulation auf elektrischer Ebene für Schaltung mit deutlich mehr als tausend Bauelementen dann also irgendwie dann auch nicht mehr so richtig viel Spaß macht,
weil dann einfach die Laufzeiten zum Lösen dieser Gleichungssysteme so groß sind,
dass man dann eben auch nicht mehr richtig arbeiten kann
Gut, aber wie gesagt, das ist ein Problem der Analogsimulation,
was sich dahinter stellt, weil, also für den Simulator
geht es eben darum, das Ganze irgendwie zu lösen.
Und ab einer gewissen Komplexität wird das dann halt eben so anspruchsvoll,
dass dort selbst hohe optimierte Algorithmänner eben irgendwie zu Rechenzeiten kommen,
wo man dann also irgendwie in den Tage- und Wochenbereich dann reinläuft.
Ein anderes Beispiel, wo man jetzt also mal keine Elektrotechnik hat,
sondern dann eben wirklich sieht,
damit lassen sie jetzt eben mechanische Systeme beschreiben, Folgendes,
ich stelle mir vor, ich habe einen Ball,
den lasse ich einfach jetzt aus einer bestimmten Höhe auf den Boden fallen.
Der fällt runter, wird durch die Ertranszierungskraft beschleunigt.
Irgendwann landet er auf dem Boden, dort wird er quasi elastisch wieder in die Luft zurückgeworfen. Dadurch,
dass er hier irgendwo auf dem Weg nach unten bzw. nach oben Luftreibung hat,
verliert er natürlich ein bisschen seiner Energie,
kommt also jetzt nicht mehr ganz so hoch wie früher,
nicht die Geschwindigkeit, nimmt dann immer weiter ab,
weil er hier dann durch die Bewertbeschleunigung abgebremst wird Irgendwann kehrt sich das Ganze wieder um und er hüpft dann eben mit immer kleiner werdende Amplitude hin und her.
Das ist hier unten an ihm versucht,
in dieser Grafik quasi jetzt zeitlich gesehen nochmal aufzulösen,
wo ich dann eben sage, ich staatliche von einer Höhe,
das gar nicht verbal wird eben entsprechend schneller sprengen auf den Boden,
wird hier reflektiert und hüpft dann so entsprechend durch.
In V der Elbe RMS beschrieben, sieht das Ganze so aus,
dass ich hier quasi in dem System nur zwei Generics habe,
nämlich einmal von welcher Höhe starte ich das Ganze und mit
welcher Initialgeschwindigkeit fällt der Ball nach unten.
Das heißt, habe ich den hier schon irgendwie beschleunigt oder lasse ich
den hier einfach mit einer Initialgeschwindigkeit von null aus der Hand fallen,
die ich dann irgendwann öffne. So an freien Variablen habe ich,
in dem Fall dann die jeweilige Geschwindigkeit und die Höhe,
also das, was dann hier als Displacement bezeichnet ist.
Also das heißt, die Referenz zu einer Höhe Null,
was in diesem Fall dann also der Fußboden ist, das wird entsprechend initialisiert.
Ich habe dann auch die Erdbeschleunigung als 9,8 Meter pro Sekunde
Quadrat und ich habe dann eben noch irgendwo einen Luftwiderstand,
der das Ganze abbremst, der dann also hier mit einem ähm, golffizient von 0,1 mit angegeben ist.
So in dem Gleichungssystem wird dann eben letztendlich gesagt,
einmal hier mit dieser Break-Anweisung, V wird zur Minus-V,
wenn nicht, es erbars 0,0. Das heißt, damit wird einem genau beschrieben,
dass sich der Wert von V hier spontan umkehrt,
wenn der Ball quasi jetzt mit der Höhe null,
also hier auf dem Boden ist, und das,
was also hier an negativen Wert ist, wird dann eben hier zum Positiven wert.
Nicht dann gilt für die Zurückgelegte Strecke,
das ist eben die Ableitung der Strecke,
ist die Geschwindigkeit und die Ableitung der Geschwindigkeit ist die Beschleunigung,
wenn man es nochmal so ein bisschen an die Schulphysik erinnern oder auch die zweite Ableitung der Strecke wäre,
die Beschleunigung nicht und das ist das,
was dann also in diesem hier beschrieben ist,
dass man eben sagt, wenn die Geschwindigkeit einmal in positiver Richtung ist,
gilt entsprechend, diese Formel werden die Geschwindigkeiten negativ ist,
beziehungsweise sage ich nur, gilt dann ebenentsprechend diese Formel nicht,
dass sie einem quasi hier einfach nur entsprechende diese Umkehrung da noch mit reinrechne und habe dann eben hier noch die entsprechenden Formeln.
So, und damit ist das in diesem Fall jetzt also
dieses physikalische System so genau beschrieben. Ja,
also wie gesagt, das nur als ein kurzes Beispiel,
wenn wir jetzt wirklich zu entsprechend größeren Systemen kommen,
also sprich, wenn ich jetzt sowas angesprochen habe,
wie digitale Ansteuerung analog digital wandlung,
Motortreiber,
irgendwelche Verstärkerkomponenten und dann soll also noch irgendwie
ein Motor
mitmodelliert werden
Kann man sich vorstellen, wird das Ganze doch
relativ kompliziert und erfordert dann eben auch sehr viel an.
Fachwissen und Know-how, also wohl als Frau,
aus der Elektrotechnik, als auch aus der Mechanik.
Wie gesagt, hier nur probt die Möglichkeiten vorgestellt. Gut,
dann kommen wir jetzt zu den anderen Hardware-Beschreibungssprachen,
die ich jetzt also auch nur ganz kurz jeweils auf ein oder zwei Folien mal erwähnen möchte.
Also das eine ist Verylock bzw. System Verylock.
Ich habe das jetzt hier jeweils gleich zusammengefasst. Die Hardware-Beschreibungssprache
Verylock ist im Prinzip auch auf Gatta oder Registertransferebene eine Verhaltensbeschreibung auf höheren Ebenen,
nimmt man dann also im Prinzip sowas wie System Varylock,
was da noch mehr Verhaltensbeschreibung, Modellierung von Kanälen mit beinhaltet.
Letztendlich sind dahinter aber die gleichen Konzepte,
wie sie eigentlich in VDL mit drin sind. Das heißt,
ich habe also wohl Verhaltensbeschreibung, also eben Strukturbeschreibung und Hierarchien,
wo ich dann eben mein Gesamtsystem aufbauen kann.
Ursprünglich war Vereloc eine prokretäre Sprache, die auch zu einem
gleichnamigen Simulator gehörte
Das war auch noch, bevor,
also im Prinzip anfangen oder Mitte der 80er Jahre,
bevor also VADL aufkam, beziehungsweise dann 1987,
also quasi als Hardtrapelie-Standort dann das erste Mal entsprechend festgelegt wurde.
Wie gesagt, Very Lock ist so rum gesehen,
die ältere Sprache,
war aber eben vorher noch nicht spezifiziert,
ist erst seit 1995 A-Treperi bzw. internationaler Standard und seit 2005
gibt es dann eben noch diese Systemerweiterung,
das Rassist in Very Lock ist
Beides ist dann auch jeweils hier als Standard,
hinten nochmal in den Anhängen, entsprechend mit verlinkt.
Ja, wofür wird Verilog genommen oder nicht genommen?
Ist letztendlich immer eine Frage,
womit man als Entwerfer von Hardware sozialisiert worden ist.
In Europa ist es meistens eher, dass man in Richtung VDL geht.
Und ich habe bislang auch immer nur alles mit VDL beschrieben und gemacht.
Gerade in Amerika war eben diese Firma bzw. der Simulator
dort eigentlich herkommen,
ist es
eher verilog noch weiter
Verbreitet. Letztendlich muss man aber sagen, ob ich jetzt
VRDL bzw. Verellob oder Assistant Verellob nehme, das nimmt sich eigentlich nichts.
Wofür man Verellob immer noch ganz gerne benutzt,
ist als Netzlisten-Format, weil es einfach von der Kodierung her,
vom Code, wie ich jetzt Netzlisten beschreibe,
doch etwas kompakter ist und ein bisschen weniger Diklaration und Schlüsselworte mit auftauchen,
als es bei VDL der Fall ist.
Wie gesagt, das ist aber einfach nur ein syntaktischer Unterschied,
dass ich da nicht jedes Mal noch irgendwie größer eine Entity-Beschreiber.
Es gibt zwar auch eine Äquivalence und eine Entity-Beschreibung
ist aber einfach vom Code her noch ein bisschen kompakter.
Das nimmt sich da eigentlich nichts. Wie gesagt, das,
was man da dann immer hört als Kritik an VDL,
ist eben so ein bisschen dieser deklarative Overhead,
der dann auch immer je nach Benutzung,
wie man das einsetzt, mehr oder minder groß ist.
Also beispielsweise, um jetzt Hierarchien aufzubauen,
hatte ich ja so einen Mechanismus beschrieben,
wo Komponenten als Zwischenstufe genommen werden,
weil man damit also sehr flexibel unterschiedliche Ersetzung in der späteren Implementation machen kann,
führt aber dazu, dass ich eben jetzt nicht nur Entity und Architecture,
sondern auch noch Komponenten irgendwo mit beschreiben kann und so weiter.
Das ist eben doch deutlich mehr Code,
als wenn ich das so ein bisschen anders mache.
Aber wie gesagt, das ist eigentlich dann also nur,
je nachdem, wie man das entsprechend empfindet.
Früher war es so,
dass die Simulation von Very Lock deutlich schneller war als eine VADL-Simulation,
was also daran liegt,
dass also quasi Very Lock eben ursprünglich wirklich direkt
ein Digitalsimulator war
Und daher die Algorithmen eben noch deutlich besser implementiert worden sind und auch ausgenutzt worden sind.
Von der Simulationssemantik sind beide Sprachen eigentlich auch äquivalent. Das heißt,
ich habe eben sowas wie diese Ereignisse als treibendes Element einer Ereignis gesteuerten Simulation dahinter stehen. Inzwischen muss man sagen,
nimmt es sich eigentlich überhaupt nichts, also ob ich mein System in Very Lock,
System Very Lock, VDL oder System C beschreibe, das,
was man inzwischen eigentlich hart ist, also eine Trennung,
zwischen der eigentlichen Simulations-Engine, also dieser Ereignis gesteuerten Simulation,
die das System quasi dann also irgendwie im zeitlichen Ablauf am Laufen hält und dem Frontend,
womit ich dann also eine Sprache XY einlese, Paser und in irgendwelche internen Datenstrukturen für den Simulator dann umsetze.
Nicht deswegen ist es inzwischen also auch problemlos möglich,
verschiedene Hardware-Beschreibungssprachen in einer Simulation gemeinsam zu benutzen und zu mischen,
also was man zum Beispiel ganz gerne macht,
was ich eigentlich auch so mache und was dann also auch teilweise einige Sachen immer mal ganz gerne vorgestellt wird,
dass man sagt, okay,
ich arbeite primär mit VADL, entwickelt an meiner Algorithmen,
simuliere das Ganze, wenn ich mit dieser Simulation fertig bin,
mein System synthetisiert habe, dann halte ich eben eine Netzliste,
die ich dann eben nochmal auch wieder simulieren möchte und um das Ganze ein bisschen kleiner und schmaler zu halten,
schreibe ich diese Netzliste dann eben als Pferdelockdatei raus, beziehungsweise das,
was ich dann an Simulationsmodellen für die einzelnen Gatter nehme,
sind dann häufig eben auch Very Lock Simulationsmodelle, die man dann eben zusammen mit Dieser Netzliste und seiner VR der Simulationsumgebung oder irgendwelchen anderen VRDL-Codes zusammen gemeinsam läufst.
Ja, hatte ja schon gesagt, bei den Modellierungsmöglichkeiten gibt es eben eigentlich keine Unterschiede.
Komponenten werden in der Regel gemeinsam genutzt und in Synthese,
On-In-Simulation arbeitet man inzwischen eigentlich so,
dass es also völlig egal ist, mit welcher Hardware-Beschreibungssprache ich ankomme.
Anfangen das Parsen der Sprache sieht dann eben unterschiedlich aus.
Intern habe ich dann aber eben ein internes Datenformat,
was dann, ich meine, wie auf die Simulations Engine abzieht.
Ja, hier habe ich auch nur noch mal gesammelt,
diverse Links zur Very Lock bzw. zur System Very Lock, wenn man sich da noch ein bisschen weiter vertiefen möchte, könnte man da dann auch noch fündig werden. Ja,
als andere Hardware-Beschreibungssprache,
neben VHDL habe ich dann eben noch hier auch nur ganz kurz angedeutet,
System C mit drauf,
System C ist im Prinzip eigentlich nur eine Erweiterung von C Plus Plus,
das heißt, ich habe eigentlich Standard Plus Plus,
ich habe dann eben irgendwelche Klassenbibliotheken,
die mir aufbauen auf dem C-Standard dann eben bestimmte Datentypen beschreiben,
die ich jetzt also für meinen Hardwareentwurf brauche,
also sprich logische Typen und Vektoren, die dann eben auch mehrwertig sind,
nicht also ähnlich wie ich ein VRL ja dann Standard Logic 1164 benutze,
statt Bit, dass man da dann eben auch entsprechenden Mehrwert je Logik da noch mit hat,
mit unterschiedlichen Treiberstärken und so weiter,
was man da noch alles braucht.
Ich habe dann eben entsprechende Vektoren,
habe dann eben hier Unterschiedliche Datenformate für Invidger, also Scient oder Unsigned,
beziehungsweise kann daran eben auch noch so was wie Fixpunktformate mit beschreiben, so weiter.
Nicht dann gibt es neben diesen Datentypen einen ganzen Satz von vorgefertigten Utilities,
die man benutzen kann, vordefinierte Elemente in der Sprache.
Auch hier gibt es dann eben wieder Kanäle, um,
was dann also quasi das Kommunikationshilfsmittel ist, um jetzt einzelne Code-Elemente,
die jetzt quasi hier in VADL das Signal dann eben auch Konkurrenz zueinander arbeiten,
im Sinne so eine Ereignissteuerung, zeitlich gegeneinander abzustimmen nicht,
dann hat man eben auch,
was jetzt also schon ein bisschen mehr in die Software-Programmierung geht,
dann eben Mutexelseemaforen, FIFO und, und, und.
Ja, und dann gibt es eben die eigentliche,
dem sprach Kern, wo dann eben beschrieben ist,
letztendlich, wie C plus plus Code auszusehen hat,
dass er Assistant C-Code durchgeht, das heißt,
ich muss ja dann bestimmte Sprachkonventionen einhalten, um diese Elemente benutzen zu können,
aber eben um damit dann eben auch entsprechend simulierbar beziehungsweise senthetisierbar zu sein.
So für die Simulation, das ist dann eigentlich,
also das Schöne dabei, kann man dann eben sagen,
ich habe jetzt mein System C-Code,
was also in diesem Fall dann nichts anderes ist,
als ein C-Plus-Plus-Code,
der also letztendlich diesen Konventionen entspricht und ich habe dann eben vorgefertigte Co-Teile beziehungsweise entsprechende Bibliotheken,
baue mir das Ganze mit meiner Standard C-Plus-Plus-Toolchain zusammen,
halte ein Executable und das ist dann eben letztendlich
also auch der Simulator selber da
Wie gesagt, in System C habe ich dann,
hatte ich eben schon gesagt, diese Erweiterung für den Hardwareentwurf,
also sprich, wie beschreibe ich Konkurrentemodelle,
war es ja dann also Standard,
C plus plus überhaupt nichts mit drin ist,
wie ist die Semantik von Zeit definiert, das heißt,
was sind Clocks, wie ist die Reaktivität mit drin,
also sprich das, was in VHDL dann eben toaiternweise mit Ereignissen mit drin habe und eben entsprechende Kommunikationsmechanismen.
Auch System C ist inzwischen lange standardisiert wurde,
quasi selbst Open System C Initiative 2000 letztendlich so ein bisschen überhaupt erst mal international propagiert,
ist seit 2005 eben auch ein Standard,
der sich dann also auch mit den inzwischen mehreren Iterationen schrittweise entwickelt hat,
auch hierzu wieder entsprechende Links,
wo man das findet und wo man eben auch den Kernstandard,
also hier auf acceler.org auch finden und selber auch runterladen kann
und damit im Prinzip sich dann noch seine eigene System C-Programme
selber schreiben könnte
Ja, das, was ursprünglich mal bei der Entwicklung von System C durch diese USCE im Vordergrund stand,
ist die Idee, dass man sagen kann, ich habe halt nur vergleichsweise wenig Hardware-Entwerfer zur Verfügung.
Ich habe aber relativ viele Programmierer, die sich da also irgendwie ganz gut mit auskennen. Und man hat eben den großen Vorteil,
dass ich mit System C in meinem Gesamtsystem sowohl hart als auch Software-Komponenten gemeinsam beschreiben kann und damit dann eben doch die deutlich mehr Möglichkeiten habe,
eben so ein Co-Design zu machen,
als es jetzt mit reinen Hardware-Beschreibungssprachen der Fall ist,
weil ich natürlich sagen kann, ich habe in meinem System,
wenn ich das mit VDL entwerfe, noch irgendwo als Komponente mit drin,
einen Prozessor und einen Prozessorkern und friesen Prozessorkern,
habe ich dann also mein Instruction-Set-Simulator und könnte damit dann also vielleicht noch simulieren, nicht,
aber es ist dann eben nicht so einfach möglich zu sagen,
okay, wenn ich jetzt also direkt noch irgendeinen Algorithmus habe,
wie bringe ich den da noch mit rein,
nicht das wäre dann
So ein Hardware-Software-Co-Design, VAD, ein bisschen schwierig, weil ich die Nase quasi erst übersetzen würde,
dann eben irgendwie in Form von Assembler-Code jetzt quasi als ausführbaren Code,
die Instruction-Set-Simulator mitgeben kann, in Systemsy kann ich da direkt, also in meinem Software-Code arbeiten.
Nun, das, was man sich dann eben vorgestellt hat,
ist, dass man im Prinzip also ein durchgängigen,
von einem einzigen Werkzeug unterstützt, der Entwurfsablauf hat,
dass ich eben sagen kann,
gerade am Anfang des Entwurfs hat man eben oft reine Verhaltensmodelle,
was ich ja in dem letzten Teil in dieser Folie am Ende zum Entwurfsablauf mit VHDL,
mit drin habe, als oberster Ebene,
wo ich dann eben wirklich nur reines Verhaltensmodell habe,
was ich in diesem Fall dann eben nativ in der Programmiersprache beschreiben kann.
Nicht da jetzt entsprechende Iterationen mache und wenn ich damit mit dem Ergebnis zufrieden bin,
gehe ich dann eben entsprechend weiter. Und wenn ich jetzt das Ganze nicht mit System 10 mache,
nicht dann habe ich eben an dieser Stelle irgendwann mal die manuelle Umsetzung von dem Entwurf in eine Hardwarebeschreibungssprache,
mit der dann weitergearbeitet wird,
während Mann bei einer Arbeit mit System C,
ihm quasi jetzt das,
was hier unter Analysis beschrieben ist,
eben in allerersten Simulationen macht und den Entwurfsschritt oder den Übergang von Verhaltensmodellen zu synthetisierbarem Registertransfermodell dann eben hin und durch eine Verfeinerung in diesen Imiterationsschritten machen würde und dadurch dann aber immer in einer Sprache bleiben würde.
Ja, also wie gesagt, Idee,
man kann damit dann eben auch sehr schön und sah einfach auch noch höhere Abstraktionsebenen,
also in diesem Fall ist also dann rein Verhaltenscode einer Programmiersprache nutzen hat dann eben auch die direkte Infrastruktur,
also der Comparlo und Debugger,
der Sprache zur Verfügung und kann eben auch das Know-how aller Softwareentwerfer nutzen.
In der Praxis hat er sich eigentlich bewährt,
dass man also sowas wie High-Level-Simulation sehr gut und wunderbar mit ersetzen kann,
dadurch, dass ich dann ja also wirklich meinen C-Plus-Plus-Code beschreiben kann,
damit also mein Verhalten beschreiben kann,
einen Nachteil bei dem Ganzen ist,
wo sich dann also letztendlich diese Ideen wie sie jetzt in der vorigen Folge skizziert worden sind,
dass man eben sehr einfach hier im Software-Entwerfer damit also auch einen komplexen Hardware-Entwurf zumuten kann.
Das hat sich also eben nicht bewährt,
weil quasi hinter dem Hardware-Entwurf mit der Nebenläufigkeit,
mit diesem Konzept von Ereignissteuerung in der digitalen Simulation eben doch andere Denkweisen zugrunde liegen,
als das, was dann normalerweise aus der Programmierung kennt.
Das heißt, damit ist automatisch jetzt nicht jeder Programmierer
auch ein guter Hardware-Designer
Was ich persönlich jetzt finde, wenn ich,
also das sehen wir da in dem Beispiel nochmal,
wenn ich mir jetzt also irgendwie ansehe,
wie der Code bei Assystem C aussieht,
finde ich den also auch nicht so sonderlich gut lesbar und
teilweise also eher noch ein bisschen umständlicher als bei VADL,
Unterstützung durch ein Wurstwerkzeuge.
Gut, da kann man sich jetzt ein bisschen drüber streiten.
Also vor zehn Jahren war das also wirklich noch sehr rudimentär.
Inzwischen können, also zumindest im Bereich der Simulation,
auch alle Simulatoren letztendlich,
Ähnlich wie vom Fahrradel und Very Lock dann eben auch noch mit System C direkt umgehen.
Bei der Synthese, System C als Allgabe für Synthese-Werkzeuge,
sieht das vielleicht noch ein bisschen anders aus,
aber auch da ist inzwischen, also der Support deutlich größer.
Ich habe aber das Grundproblem, was eigentlich für alle Hardware-Beschreibungssprachen gilt,
ist, dass man wirklich sagen muss,
die Schwierigkeit beim Entwurf von Hardware ist,
wirklich guten synthesefähigen Code zu erstellen,
wozu eben doch gewisses Maß einfach an Erfahrung gehört.
Und gerade, weil man in höhere Abstraktionsebenen geht oder eben sehr hohe Anforderungen an den Entwurf hat,
dass es da dann eben wirklich zunehmend schwierig wird,
guten Code zu schreiben, der dann auch effizient von den Werkzeugen umgesetzt wird.
Ich war also ähnlich, wie ich also im Prinzip in der Programmiersprache,
das Verhalten eines Algorithmus mal so oder mal so beschreiben kann.
Ich dann aber in Bezug mal beispielsweise jetzt auf Speicherplatzbedarf
oder auf Laufzeit dann eben riesen Unterschiede haben kann
Sich das eben auch bei der Hardware-Beschreibungssprache so aus,
dass man sagen kann, ich habe eben meine Beschreibung,
egal mit welcher Hardware-Beschreibungssprache ich sie erstellt habe,
die eben ein sehr klein,
sehr schnellen Entwurf realisiert und ich kann eben quasi genau das Gleiche verhalten aus der Simulation,
eben auch so deklarieren,
dass die Werkzeuge daraus dann also irgendwas machen,
was also nicht mehr so effizient läuft oder eben nicht mehr so gut geht oder eben vielleicht auch gar nicht synthesefähig ist.
Nicht, dass es also letztendlich das und das ist eben etwas,
was also für alle Hardware-Beschreibungssprachen HDKST da immer für Hardware Description Languages,
was eben für alle Hardware-Beschreibungssprachen gilt.
Gut, dann folgen wir hier jetzt nochmal zwei Beispiele.
Einfach mal so grob zum Codevergleich, also hier einmal ein vorderflankengesteuertes Slipshop in VADL.
Ich mit dem Datentyp Standard Logical 64. In diesem Fall,
Standard Logic dann, ich habe hier eben NDT DFF,
habe hier mein Apportmap, Clock, Reset, Dateneingang,
Datenausgang, hier dann immer die jeweilige Richtung des Ports und
dann eben den Basistyp hier so relativ lang ausgeschrieben.
Ich kann das, also ich könnte das hier auch als teilweise
aus Aufzählungsläss jeweils machen und dann eben die zugehörige Architecture in
diesem Fall ein einziger Prozess, sensitiv zu Reset und Blog.
Wobei ich eben mit Reset gleich eins, also in diesem Fall hi aktiv,
den Wert des Flipflops deout auf null zurücksetze und wenn das Reset nicht aktiv ist,
ich dann eben in einer Tagforderflanke den Dateneingang übernehme.
Das heißt, dieses Ganze wäre jetzt ein Vorderflanken gesteuertes D-Flip-Flop mit Asynchronem,
Reset, Asynchron heißt, das Reset ist unabhängig vom Clock,
wenn ich hier diese Schachtelung dieser Ausdrücke andersrum hätte,
hätte ich sowas wie ein Synchrones Reset, das heißt,
das Reset wird erst nach einer Taktflanke aktiv.
Meistens hat man aber sowas,
weil so geschadet man also gerne auch ein bisschen einfach zu
initialisieren und zur Handhabende sind durch Externe Reset-Signale und technisch gesehen
ist sowas erstaunlicherweise nämlich auch eher noch ein bisschen einfacher.
Gut, also das wäre ja das Ganze in VHDL,
wie sieht das in Varyloch aus
Mordiol DFF, dann habe ich ihm hier eine Aufzählung der Ein- und Ausgänge. Das heißt,
hier habe ich dann sowas wie NTT-Beschreibung,
die Ports und eben die Richtung, nicht klar,
Creset und die Inseln Eingänge, die Auto ist ein Ausgang,
dann wird hier über diese Anweisung,
The Out ist ein Redissert wert, eben noch gesagt,
dass also das Verhalten gespeichert werden kann,
beziehungsweise soll zwischen mehreren Aufrufen von in dieser Beschreibung und die Aufrufe selber,
also quasi das Äquivalent zu dem Prozess,
ist dann also hier diese Anweisung in Very Lock gibt es quasi immer zwei Arten von Anweisungen,
einmal so ein Allways fast, also dementspricht,
was sich in VADL immer hatte als Prozess mit so einer Endlosschleife,
wo ich also quasi entweder bei einer Sensitivity-Liste den Prozess,
wenn sich ein oder eingänge ändert,
Anträger durchrechne bis zu einem Endprocess oder wenn ich keine Sensitivity-Liste habe,
wo der Prozess dann eben bis zu einem Void läuft,
dann eben entsprechend anhält und wenn Diese Bedingung bei dem Wade war geworden ist,
dann eben der Zyklusspieler durchläuft,
bis er auf das nächste Weg kommt.
Das wäre eben diese ständig aktive, was dann also hier durch dieses Allways beschrieben ist,
daneben gibt es dann noch sowas wie Initial, dass er quasi einmalige Durchläufe, die man dann gerade für Initialisierung ganz gut mitbenutzen kann. So,
das, was hierhinter kommt, ist quasi jetzt das Äquivalent zur Sensitivity-Liste,
dass man nämlich dem Simulator sagt,
wenn ich den Takt vor der Flanke habe, soll,
oder sollen diese Anweisungen hier ausgeführt werden oder wenn ich ein Reset habe,
sollen diese Anweisungen ausgeführt werden und in dem Anweisungsteil,
also zwischen dem Beginn und End, steht dann eben hier,
wenn ich ein Event auf dem Reset habe,
also sprich das Ganze hier durchaus gelöst wurde,
dann soll der Datenausgang quasi im wohlschen Wert null erhalten,
ein Bett breit, wenn das nicht der Fall ist,
dadurch, dass ich diese Ohrenweisung habe,
wo das Ganze dann ausgelöst durch die Fahrerflanke von der Clock und Entsprechend würde der Dateneingang übernommen und gespeichert.
Nicht, dass wir ja jetzt also quasi Säqualent zu dem anderen Freunden VDL,
in System C sieht das Ganze so aus,
dass ich hier also quasi beschreibe, die FF dann als ein SC Mordjule.
Ich habe hier mal eine Eingänge und Ausgehe,
die hier also quasi von vordefinierten polsischen Typen dann entsprechend definiert sind,
habe dann hier eine Aktion, du FF,
die dann letztendlich eben sagt, dass wenn sie angeworfen wird,
Marie said, the out of null gesetzt.
Ich hatte beziehungsweise hier arbeite ich jetzt mit Bullshen-Werten.
Deswegen Falls. Im anderen Fall bei Trop-Event. In jedem
Fall wird dann also jeder noch an dieser Stelle beschrieben,
dass hieß Event durch eine Vorderflanke hervorgerufen wird.
Wird der Dateneingang übernommen und gespeichert.
Und ihr nehmt Konstruktor von DFF, sage ich dann eh.
Ich habe quasi einmal diese Methode, du FF.
Und das Ganze ist eben sensitiv entweder auf Reset oder die Vorderflanke von Clock. Nicht,
dass wir das Ganze jetzt, also System C,
dann jetzt noch als zweites Beispiel, ein Zähler in VHDL,
Valeloch and System C., der beispielsweise jetzt,
also hier irgendwie eine 8 mit Unsign-Zahl am Eingang hat, am Ausgang ausgibt.
Und mit einem Takt entweder mit jeder Tagflanke raufzählt,
gelöscht werden kann, bei Lord kann ich diesen Zähler dann
mit diesem Datennaheeingang entsprechend vorher vorsetzen, mit irgendwelchen Wehren.
So, das zugehörige Architecture sieht dann eben so aus,
dass ich hier also ein Signal habe, wo dann der eigentliche Zähler wird gespeichert wurde.
Ich habe einen Prozess sensitiv zur Clock, mit der Taktvorderflanke wird dann eben abgefragt,
in diesem Fall hier sowas wie so ein synchrones Reset,
wenn Tier gleich eins ist, wird der Zähler zurückgesetzt.
Dieses hier ist ein Vektor aus lauter Nullen,
der in diesem Fall dann so weit ist, wie er hier eine Definition entspricht.
Das ist dieses Overs. Sonst wird Wenn Lord gleich eins ist,
der Zähler stand von den Dateneingang übernommen,
in allen anderen Fällen rechne ich dann ihm hier Zielerstamm plus eins, dadurch,
dass ich als Ziel variabel jetzt hier keinen Energer habe oder ein Untertyp,
sondern mit ihrem Achtbett Unsigned arbeite,
habe ich dann eben auch automatisch den Umlauf,
wenn ich entsprechend den größten Zähler werde,
also in diesem Fall 255 erreicht habe,
das dann nach dem nächsten Tag Flanke,
dann hat sie je wieder 0 oder drin steht.
Das wäre das Ganze in VGL und für den Hausgang habe ich
dann eben hier noch Umbenennung dieses Signals countbell in der Haut.
In Very Lock, auch hier die entsprechende Modulbeschreibung,
Takteingang, Laden, Löschen, Dateneingang, Karten,
Ausgang, die Beschreibung, was Input und Output sind,
Vektoren werden dann eben hier durch diese Schreibtweise letztendlich markiert,
was sich dann eben hier jeweils acht Pilfektoren habe.
Und hiermit wird dann beschrieben,
dass Countbell also einmal eine speichernde Wert ist,
während der Haut das, was dann hier rausgeht,
als extra zum Signal dann quasi einfach nichts anderes ist,
was das Signalwasser in diesem Fall dann diese Umbenennung von dem Wert hier ist.
Das wäre also genau das Äquivalent zu dieser entsprechenden Zuweisung aus dem VDL-Code
und auch hier dann eben wieder nur das mit der Taktvorderflanke der Reihe nach,
jetzt also quasi diese drei ineinander geschachtelten If-Up-Fragen stattfinden, nämlich löschen, laden und imkrementieren.
In System C muss man so ein Beispiel dann in zwei Dateien aufteilen,
nämlich also einmal und das finde ich dann immer so ein bisschen Abstrus,
dass das dann also jetzt quasi nicht als Seedatei,
sondern also irgendwie da erst mal so eine Header-Datei mit drinsteht,
wo ich dann also quasi hier das Äquivalent zu der Entity-Deklaration in VHL im VDL-Sprech quasi habe,
dass ich dann eben sage,
ich habe also meinen Motor-Accounter mit Eingängen und Ausgängen.
Ich habe hier dann eben diese interne Zählvariable und eben eine Methode,
wo dann gezählt wird, die dann also quasi hier als One-to-Three bezeichnet wird.
Ich habe den Konstrukter, der dann eben sagt,
es gibt eben einmal diese Methode und dann eben die Mit der Taktforderflanke sensitiv,
da ist das Ganze und in der eigentlichen C-Plus-Plus-Datei habe ich dann eben letztendlich hier das Verhalten noch mal beschrieben,
wo ich dann eben sage, dass der Zähler Russ Wanter 3 von Inder,
von der Klasse zähler, dann ich mir letztens,
da kriege ich dieses Verhalten,
das Wasser in diesem Fall ist ganz normal,
der Code ist.
Ja, soviel jetzt eigentlich an der Stelle hier erst mal
zu den anderen Hardware-Beschreibungssprachen, beziehungsweise zu Frau der AMS-Beschreibung.
Das, was sich jetzt hier in den Foliensatz noch anschließt,
sind noch mal einige Bücher zu dem Thema vor HDL,
VDL, Arme, System C und so weiter.
Hier, fahr erstmal nur hin. Alphabetischer Reihenfolge. Wie gesagt,
da Philipp Mann, auch wenn man jetzt aktuell,
guckt doch relativ viele unterschiedliche Bücher, die dann mehr oder minder gut sind.
Deswegen will ich da jetzt also nicht einzeln irgendwo drauf eingehen
oder eins besonders empfehlen. In dem zweiten Teil,
was jetzt also hier noch ein paar mehr Folien sind,
sind dann nochmal jeweils die jeweiligen Standards offiziell als bibliografische Referenz beschrieben zu VHDL,
VDL AMS.
Die Erweiterung für mathematischen Paketen und so weiter und so fort.
In den Folien wurde dann immer jeweils entsprechend hier auf diese Standards damit eingegangen.
Nicht daneben finden sich dann die Monosystem-Varilorg, System C und so weiter.
Ja, damit bin ich jetzt auch mit diesem dritten optionalen
Teil zur Hardware-Beschreibungssprache und eigentlich am Ende. Ich hoffe,
man hat zumindest erstmal so einen groben Überblick über VHDL
und jetzt eben vielleicht über andere Hardware-Beschreibungssprachen bekommen und ja,
so viel von mir dann erstmal dazu.
Dann tschüss