Differences

This shows you the differences between two versions of the page.

--- de:doc:lua_start [2013/10/27 17:47] – created wsauer
+++ de:doc:lua_start [2014/03/29 04:13] – [Die Menu Kommando's] admin
@@ Line 1: / Line 1: @@
-====== Erstelle Deine eigenen OOBD Scripts ====== Manual
+====== Erstelle Deine eigenen OOBD Skripte ======
+Die "nachladbare Intelligenz" von OOBD ist als Lua Skript realisiert. Was das bedeutet und wie es arbeitet, wird hier beschrieben.
-The "reloadable intelligence" of OOBD is realized as Lua script. What this means and how this works, is described here.
+===== Was ist Lua? =====
-===== What is Lua? =====
+Einfach gesagt ist [[http://www.lua.org|Lua]] "etwas" (ein so genannter Skript Interpretierer) der entwickelt wurde, um es einem Programm zu ermoeglichen intern in einem Programmaufruf eines anderen Programms gestartet zu werden. Der Trick dabei ist, das das "interne" Programm, zu dem Zeitpunkt an dem das äußere Programm erstellt wird, noch nicht existieren muss. Es kann also später geladen werden wenn Du es brauchst.
-Simply said, [[http://www.lua.org|Lua]] is "something" (a so called script interpreter) which is made to allow a program to run another program internally. The trick in that is, that the internal program does not need to be there when the "outer" program is made, it can be loaded later, just when you need it.
+Das ermöglicht es ein Programm zu erstellen und das Verhalten so zu bestimmen wie es gebraucht wird. Dieses Konzept wurde in der OOBD "script engine" vielfach genutzt: Die "script engine" ist am Anfang aller Entwicklung, aber das was das Programm tun soll, wird mit dem geladenen Skripten zu Laufzeit des Programms festgelegt. Ein anderes Skript bedeutet eine andere Funktionalität...
+Glücklicherweise wurde Lua ziemlich populär in den letzten Jahren und so ist es heute für alle wichtigen Plattformen verfügbar wie z.B. Desktop PC's, Smartphones und normale Mobiltelefone.
-This allows to make a program now but change its behavior later as needed. This is widely used in the OOBD script engine: The script engine is there from the beginning, but what it does is defined by the script which is loaded at runtime. Another script, another functionality..
+Es gibt eine Menge an Dokumentation über Lua im Internet, so das wir das Rad nicht noch mal neu erfinden wollen. Wir werden uns darauf konzentrieren, wie Lua innerhalb von OOBD funktioniert.
-Luckely Lua became quite popular in the last years, so it's available for all major platforms, like Desktop PCs, Smartphone and Mobile Phones.
+===== Die Lua - OOBD Schnittstelle =====
+Wenn Lua innerhalb eines anderen Programms ohne weitere Hilfestellung gestartet wird, reagiert es wie eine Black Box: Es gibt keine Verbindung vom inneren zum äußeren Programm, keinerlei Eingabemöglichkeiten und keine Rückmeldungen an das aufrufende Programm. Das ist offensichtlich nicht besonders sinnvoll. Deshalb müssen, wenn Lua in ein Programm eingebaut wird, einige Schnittstellen erstellt werden, die Lua mit dem Host kommunizieren lassen.
-There are tons of documentation about Lua available in the internet, so we'll not explain the wheel here once more, we'll just focus on how Lua works inside OOBD.
+Aus der Sicht von Lua arbeiten diese Schnittstellen als normale Lua Funktionsaufrufe. Aber wenn eine solche Funktion aufgerufen wird, verzweigt die Ausführung des Programms in das äußere Programm, macht dort irgendwas und kehrt letztlich von dieser Funktion zurück zu Lua.
+Im Moment unterstützt OOBD zwei Arten von Schnittstellen für Lua: Einige die Menue's erstellen und andere die die Kommunikation über die serielle Schnittstelle ermöglichen.
-===== The Lua - OOBD Interface =====
+**Wichtig** Um während der Fehlersuche die festeingebauten erweiterten Lua Funktionen gegen selbsterstellten Kode austauschen zu können, werden normalerweise die festeingebauten Lua Funktionen zuerst einigen Lua Variablen zugewiesen. Diese werden dann später in dem Skript benutzt.
-If Lua runs inside another program, without further assistance it does it like in a black box: No connection from the inside to the outside, no inputs, no feedbacks. This is obviously not very senseful, so when Lua is implemented into another program, there are normally some interfaces made up to let Lua and its host communicate to each other.
-From the Lua perspective, these interfaces act as normal Lua function calls, but when such a function is called, the execution branches into the outer program, does something there and finally returns from that function back to Lua.
-In the moment the OOBD interface supports two kinds of interfaces for Lua: Some for creating the menus, and some to talk to the serial line (( this is certainly subject to change in the future, when OOBD becomes more generic and the data links become more abstract))
-**Important** To allow it during debugging to replace the hardcoded extended Lua functions against some own debugging code, normally the hardcoded functions are assigned to some Lua variables first, which then are used in the later script:
   local serFlush =serFlushCall
   serflush()
+Mit dieser Benamungskonvention enden die festeingebauten erweiterten Funktionen mit xxx"Call", während die Aufrufe Dieser nachher ohne "Call" getätigt werden.
-So by naming convention the hardcoded extended functions ends with xxx"Call", while the name used later is without "Call"
-Please keep this in mind while reading this document or writing own code.
+Bitte behalte das im Gedächtnis, wenn Du dieses Dokument liest oder Deinen eigenen Kode schreibst.
+Aber bevor wir einen Blick in den Programmablauf werfen, müssen wir verstehen wie der Lua Compiler (Luac) arbeitet und was das für die Programminitialisierung bedeutet:
-But before we look in detail in the program flow itself, we need to understand how the lua compiler (luac) works and what that means for the program initialization:
+==== Kompilierung und Aufstartkode ====
-==== Compiling and Startup code ====
+Um Speicherplatz zu sparen und die Aufstartzeit zu reduzieren, wird der Lua Interpretierer innerhalb OOBD nicht mit dem Quellcode ,der dann erst einmal kompiliert werden muss bevor er ausgeführt werden kann, versorgt. Stattdessen wird der fertig kompilierte Lua Programmkode eingebunden.
-To save memory and reduce the startup time, the Lua interpreter inside OOBD is not feed with the Lua programm source code text directly as this would need to be compiled first to be executed, which is time & memory consuming. Instead the compiling is done beforehand and just the compiled Lua program code is than used to be loaded into OOBD.
+Der Kompilierungsprozess funktioniert folgendermassen: Der Lua Kompilierer (Ein Komandozeilenprogrammaufruf genannt luac) übersetzt den oder die Quellkode(s), mit der Endung .lua, in eine einzelne Datei. Diese eine Datei hat nun die Endung .lbc und beinhaltet das übersetzte Programm.
-The compile process works like that, that the Lua compiler (a command line program called luac) translates the source code(s) (with the extension .lua) into a single file (with the extension .lbc) which contains the compiled program.
+Der Kommandozeileneintrag sieht dann folgendermaßen aus:
-The command would be like this:
+  luac -o Ausgabedateiname.lbc Quellkodename1.lua Quellkodename2.lua ...
-  luac -o outputfile.lbc inputsource1.lua inputsource2.lua ...
-In the OOBD source code repository there are some samples about how to do this.
+In dem OOBD Quellkode Sammelverzeichnis sind einige Beispiele abgelegt, die zeigen wie es gemacht wird.
+Wenn Du nun Deinen eigenen Übersetzungsprozess beginnen möchtest, gibt es zwei Dinge die Du wissen musst, da luac ein wenig anders arbeitet als ein gewöhnlicher Kompilierer.
-If you want to set up your own compile process, there are two things you need to know, as luac works partly different as normal compilers
+  - luac beurteilt **nicht** einige require() oder doFile() statements, sodaß diese Dateien nicht in der Ausgabedatei wiedergefunden werden können. Alle benötigten Dateien müssen stattdessen als Eingabedateien eingebunden werden, um in der Ausgabedatei enthalten zu sein.
+  - Auch die Reihenfolge der Eingabedateien ist wichtig: Luac bindet diese Dateien zusammen, in der Reihenfolge in der sie angefügt werden. In dieser Reihenfolge werden sie später auch ausgeführt. Hierbei musst Du darauf achten, das Variablen und Funktionen deklariert werden müssen **bevor** sie das erste Mal benutzt werden. Wenn das nicht passiert, bekommst Du eine Schutzverletzung.
-  - luac does **not** evaluate any require() or doFile() statements, so these files would be missed in the output file. All needed files must be listed instead as input files to be contained in the output
+Wegen des zweiten genannten Punktes, sollte die Lua Funktion die die kompletten Lua Strukturen initialisiert, das letzte und einzige Kommando sein, das in der letzen Datei steht die luac als Eingabedatei dient.
-  - also the sequence of the input files is important: Luac glues the files together in the same sequence as their are given; and in the same sequence the file is executed later. \\ Here you have to take care that variables and functions are been declared before they are used first time, otherways you'll get a "variable/function is null" error
-Because of item 2, the lua function, which sets up the whole lua structures, should be the last and only command in the lasr file given to luac.
+=== Das Start("","") Kommando ===
-=== The Start("","") Command ===
+Um der OOBD Anwendung die Möglichkeit zu geben, neu initialisiert zu werden (wie z.B nach einem Verbindungsabbruch),
+wird der Name einer solchen Initialisierungsfunktion mit **Start("","")** bestimmt. Jedes OOBD Programm muss diese Funktion enthalten. Stelle also sicher, das Dein Programm dies enthält und das Deine Start() Funktion allen notwendigen Initialisierungskode enthält.
-To give the OOBD application the possibility to reinitialize the system (like after an communication loss), the name of such a initialization function is defined: **Start("","")**. Each OOBD program has to contain this function; please make sure that also your program contain this and that your Start() function contains all necessary initialization code.
-==== The Menu commands ====
+==== Die Menu Kommando's ====
-OOBD uses just tree functions to set up the menu structures. Let's have a look into some sample code first:
+OOBD benutzt nur drei Funktionen um die Menue Strukturen zu realisieren. Deshalb lass uns zuerst einen Blick in einen Beispielkode werfen:
 <code lua>
 function Start(oldvalue,id)
 	identifyOOBDInterface()
-	setSendID("$7E8") -- set not UDS compatible sender (=answer) address for OOBD firmware
+	setSendID("$7E8") -- setzt nicht UDS kompatible Sender (=Antwort) Adresse für die OOBD firmware
 	openPage("OOBD-ME Main")
 	addElement("Sensor Data >", "createCMD01Menu",">>>",0x1, "")
@@ Line 89: / Line 80: @@
------------------ Do the initial settings --------------
+----------------- Setzen der Startbedingungen --------------
 Start("","")
@@ Line 96: / Line 87: @@
-(BTW: Here you also see the start() function in action)
+(Nebenbei gesagt: Hier siehst Du die start() Funktion in der Ausführung)
-So what do we found here? First we have the
+Also was finden wir hier? Zuerst haben wir den Aufruf der Funktion
 === openPage("Title") ===
-This function tells OOBD that a new menu should be made. The //title// is used, what a surprise, as title for that new menu.
+Diese Funktion teilt OOBD mit, das ein neues Menue erstellt werden soll. Der //Title// wird benutzt, welch Überraschung, für den Namen des Titels dieses neuen Menü's.
-Then the menu is filled with
+Dann wird das Menü aufgebaut mit
 === addElement(Description, function, initialValue, Flagset, id) ===
-This call adds a single element to the list. For now these function has the following parameters
+Dieser Funktionsaufruf fügt ein einzelnes Element zu der Liste hinzu. Diese Funktion hat die folgenden Parameter
-  * Description(String): This is what appears as description on this menu item
+  * Description(String): Dies erscheint als Beschreibung an diesem Menüeintrag.
-  * function: Each menu is assigned to a Lua function, where one function can be shared between several menu items. The name of this function is given here (please take care about correct upper/lower characters)
+  * function: Jedes Menü ist einer Lua Funktion zugewiesen, wobei eine Funktion auf die diversen Menüeinträge aufgeteilt wird. Der Name dieser Funktion wird hier festgelegt ( Bitte achte auf die korrekte Groß- und Kleinschreibweise der Buchstaben )
-  * initialValue(String): This is what is shown as initial value when the menu is displayed the first time.
+  * initialValue(String): Dies ist das, was angezeigt wird, wenn das Menü zum ersten Mal aufgeblendet wird.
-  * Flagset(Integer): This is an integer value, where each bit represents a flag. The meanings of these flags are explained in the [[:dev:clientdesignguide|Client design guide]] (look for System Flags)
+  * Flagset(Integer): Dies ist ein Integer Wert, wobei jedes Bit ein Flag darstellt. Die Bedeutung dieser Flags wird erklärt in der [[dev_clientdesignguide|Benutzerschnittstellen Entwicklungsanleitung]] (Suche nach den System Flags)
-  * id(String): The id is used to add an individual marker to a menu item. This is widely used when one single Lua function should support many menu items. This is descripted in detail in the [[#the_menu_function_call|Menu Function Calls]] below.
+  * id(String): Diese id wird benutzt, um einen individuellen Marker an einen Menüeintrag zu binden. Dies ist weit verbreitet, wenn eine einzige Lua Funktion viele Menüoptionen unterstützen sollte. Es wird im Detail beschrieben in den [[#die_menue_funktions_aufrufe|Menü Funktionsaufrufe]] weiter unten.
 === pageDone() ===
-The pageDone() function is easy, it just tells OOBD that the menu is defined now and ready to be shown.
+Die pageDone() Funktion ist einfach, denn es teilt OOBD mit, daß das Menü nun komplett definiert und bereit zur Anzeige ist.
-The final result looks than similar like this (you'll noticed that the script has slightly changed after the screenshot has been made)
+Das entgültige Ergebnis sieht dann ähnlich wie dieses aus. (Du wirst feststellen, das sich das Skript leicht verändert hat, nachdem der Screenshot gemacht wurde.)
 {{:pics:oobdme-window.png|}}
-==== The Menu Function Call ====
+==== Das Menü Funktionsaufruf ====
-As shown above, we've now set up the menu items - but now we want something happen when the user selects a menu item, won't we?
+Wie oben gezeigt, haben wir nun die Menü Einträge aufgesetzt - aber nun wollen wir das etwas passiert, wenn der Benutzer einen Menue Eintrag auswählt, nicht wahr?
-So let's assume the user selects an item. What happens now?
+Lasst uns also annehmen, das ein Benutzer einen Eintrag auswählt. Was passiert jetzt?
-  - OOBD looks, which Lua function is assigned to that menu item
+  - OOBD schaut nach, welche Lua Funktion mit diesem Menüeintrag verbunden ist
-  - than that Lua function is called, with two parameters:
+  - dann wird diese Lua Funktion mit diesen beiden Parametern aufgerufen:
-    * the actual displayed value of that item
+    * der aktuell dargestellte Wert dieses Eintrags
-    * and the id with we gave to that menu item during initialization
+    * und die id, welche wir dem Menüeintrag gaben, während der Initialisierung
-  - than the called Lua function does something, e.g. a calculation or it starts to generate another submenu
+  - dann macht die aufgerufene Lua Funktion etwas z.B. eine Berechnung oder sie startet die Erstellung eines weiteren Untermenüs
-  - when the function is finished, it returns a string value
+  - wenn die Funktion abgearbeitet ist, gibt sie eine Zeichenfolge zurück
-  - that string value is then displayed as new value of the menu item
+  - Diese Zeichenfolge wird dann als neuer Wert dieses Menüeintrags dargestellt
-That's already all, that does the job :-)
+Das ist erstmal alles, und es erfüllt den Zweck :-)
-==== The Communication  Commands ====
+==== Die Kommunikation Kommandos ====
-OOBD uses (actual) serial communication to talk to the diagnostic device. To allow Lua to send and receive data from the serial port, a few extended Lua functions exists:
+OOBD benutzt gegenwärtig eine serielle Kommunikation, um mit dem Diagnoseadapter zu kommunizieren. Um es Lua zu ermöglichen, Daten zum seriellen Port zu senden und von Ihm zu empfangen, existieren einige wenige erweiterte Lua Funktionen:
 === serFlush() ===
-It just clears the input buffer (from anything which was maybe received in the meantime and which is not needed anymore)
+Diese Funktion leert den Eingabespeicher (Von allem das, was möglicherweise in der Zwischenzeit empfangen wurde und nicht mehr benötigt wird)
 === serWrite(String) ===
-Sends //String// to the output (which is normally the serial port)
+Diese Funktion sendet einen //String// zum Ausgabespeicher (Das ist normalerweise der serielle Port)
 === serSleep(milliseconds) ===
-waits //milliseconds//
+Wartet //milliseconds// mit der Programmausführung
 === serReadLn(msTimeout) ===
-reads from input until a LF (dez. 10 hex 0x0A) appears and returns that input as String
+Liest von der Eingabe bis ein Zeilenvorschub (dez. 10 hex 0x0A) auftaucht und gibt Diese als Zeichenfolge zurück.
 === serWait(OptionString, msTimeout) ===
-In case you want to wait for some input strings, of which several could appear, you fill the //Optionstring// with string1|string2|..|stringN. If then one of this string appears at the input, the index of the found string is returned (first string=1). If the string does not appear within //msTimeout//, the function returns 0.
+Falls Du auf mehrere Zeichenfolgen wartest, von denen einige auftreten könnten, füllst Du den //Optionstring// mit string1|string2|..|stringN.  Wenn dann eine dieser Zeichenfolgen in der Eingabe auftaucht, wird der Zählindex zurückgegeben (erste Zeichenfolge=1). Wenn die Zeichenfolge nicht innerhalb einer vorgegebenen //msTimeout// Zeitspanne eintrifft, gibt die Funktion den Wert 0 zurück.
-====  Miscellaneous  Commands ====
+====  Sonstige Kommandos ====
 === serDisplayWrite(String) ===
-Writes //String// to the build in output console.
+Schreibt eine //String// Zeichenfolge zu dem was schon in der Ausgabe steht.
 === dbLookup(db-File , searchstring) ===
-Searches in the //db-file// for all entries with index //searchstring//. The //db-file// needs to be in the same directory as the Lua- script itself. The //db-file// itself is made by [[doc:oodbcreate|oodbCreate]].
+Sucht in der //db-file// Datenbank nach allen Einträgen mit dem Index //searchstring//. Die //db-file// Datenbank muss sich im gleichen Verzeichnis befinden, wie wie das Lua-Skript. Die //db-file// Datenbank selber wird erzeugt durch [[tools_oodbcreate|oodbCreate]].
-dbLookup() returns a Lua table
+dbLookup() gibt eine Lua Tabelle zurück
   myTable = dbLookup("dtc.oodb", "0815")
-//myTable.len// tells the success status:
+//myTable.len// gibt den Erfolgswert zurück:
-  * if //myTable.len// < 0 then an error has occured
+  * if //myTable.len// < 0 dann ist ein Fehler aufgetaucht
-  * if //myTable.len// = 0 then //searchstring// has not been found
+  * if //myTable.len// = 0 dann ist die //Suchzeichenfolge// nicht gefunden worden.
-  * if //myTable.len// > 0 then //myTable.len// tells the number of entries found
+  * if //myTable.len// > 0 dann zeigt //myTable.len// die Anzahl von Einträgen an, die gefunden wurden.
-When something has been found, than //myTable// contains two sections, //header// and //data//.
+Wenn etwas gefunden wurde, enthält //myTable// zwei Bereiche, //header// Kopfzeile und  //data// Daten.
-The header section is needed in case you don't know in which column your wanted result is stored; you can identify the column by its column header name instead:
+Der "header" Bereich wird benötigt, wenn Du nicht weißt in welcher Spalte Dein gewünschtes Ergebnis gespeichert ist. Du kannst dann die Spalte erkennen, in dem Du über den Kopfzeilennamen Dich annäherst:
    col= myTable.header["DTC-Text"]
@@ Line 196: / Line 185: @@
- //myTable.header.size// tells the number of colums in total **without** the first index column, which is always surpressed.
+ //myTable.header.size// gibt die Anzahl der Spalten insgesamt zurück **ohne** die erste Index Spalte, welche immer unterdrückt wird.
+Der //data// Daten Bereich enthält dann die gefundenen Daten, aufgebaut in einem zweidimensionalen Feld, sortiert nach Zeilen und Spalten.
+    result=myTable.data[row][column]
-The //data// section then contains the found data itself, arranged as a two dimensional array, sorted by rows and columns.
+**Achtung**: Obwohl die Zeilen- und Spaltenindexe durch Zahlen dargestellt werden (1,2,3,4..), werden sie intern als Zeichenfolgen ("1","2","3","4"...) geführt. Um also das Ergebnis korrekt zu lesen, müssen die Zeilen- und Spaltenzähler zu Zeichenfolgen konvertiert werden, um das zweidimensionale Feld korrekt zu adressieren.
-    result=myTable.data[row][column]
-**ATTENTION**: Although the row and column indexes are expressed as numbers (1,2,3,4..), they are internally represented as string values ("1","2","3","4"...), so to read the result correctly, numeric row and column counters need to be converted to strings first to address the array correctly
     column=3
@@ Line 209: / Line 196: @@
     result=myTable.data[tostring(row)][tostring(column)])
- Here after all a piece of sample code
+Nach all den theoretischen Informationen ein kleines Stück Beispielkode:
 <code lua>
@@ Line 234: / Line 221: @@
 </code>
-===== Some Programming Tricks =====
+===== Ein paar Programmiertricks =====
-Coming from old fashioned programming languages, you might be used to simple and static variable types like numbers and Strings. But Lua offers much more comfort here, especially with the support of nested (associative) Arrays. With that some things can be realized quite easy.
+Wenn Du Kenntnisse aus den althergebrachten Programmiersprachen mitbringst, wirst Du wahrscheinlich einfache und statische Variablentypen verwenden, wie Zahlen und Zeichenfolgen. Aber Lua offeriert hier mehr Komfort, besonders mit der Hilfestellung von geschachtelten (assoziativen) Feldern. Mit diesen können einige Dinge sehr viel einfacher realisiert werden.
-Let's assume a common scenario: You want to use a number of menu items, which basically do all the same (getting a value from a vehice) just with different parameters.
+Wir wollen uns ein häufiges Szenario vorstellen: Du möchtest eine Anzahl von Menüeinträgen verwenden, welche alle das Gleiche tun, Einen Wert von einem Fahrzeug erhalten, nur mit verschiedenen Parametern.
-In former days you had to write one function for each single value and a long list of menu items, but in Lua, you can store all parameters, their meanings and even the function reference to get them in a single array like
+In der Vergangenheit musstest Du eine Funktion für jeden einzelnen Wert und einen lange Liste von Menüeinträgen schreiben. Aber in Lua kannst Du alle Parameter, deren Bedeutungen und auch eine Funktionsreferenz, um Sie zu bekommen, in einem einzigen Feld speichern wie
 <code>
@@ Line 251: / Line 238: @@
 </code>
-then, during your menu initialisation, you can let Lua run though the array and building the menu out of it
+Dann, während Deiner Menü Initialisierung, kannst Du Lua das Feld durcharbeiten und das Menü daraus aufbauen lassen.
 <code lua>
@@ Line 263: / Line 250: @@
 </code>
-And again: That's it
+Und wieder einmal kann man sagen: Das war's.
+Wenn dann später eine Funktion aufgerufen wird, durch seinen Menü Eintrag, bekommt es einen Hash Key aus dem Menu2Data Feld als dessen id Parameter. Damit kann die Funktion, dann Ihre eigenen Parametersätze aus dem Menu2Data Feld auslesen um die korrekten Werte auszurechnen.
-When than later on a function is called by its menu item, it gets the hash key of the Menu2Data array as its "id" parameter, so the function can then read out its personal parameter set out of the Menu2Data Array to calculate the correct values.
+Bitte beachte den Gebrauch des _G array Feldes in dem obigen Beispiel: Lua speichert alle Funktionen in sein globales _G array Feld, wo sie dann referenziert über Ihren Namen, als normale Funktion benutzt werden können. So macht der ''res=_G[value.call]("-",key)'' Aufruf das folgende:
-Please also note the use of the _G array in the sample above: Lua stores also all functions into its global _G array, where they can be refenced by their name and used as a normal function. So the ''res=_G[value.call]("-",key)'' call does the following:
+  - es findet eine Funktion mit Hilfe seines Namens
-  - it finds a function by its name
+  - dann ruft es diese Funktion auf, wie auch der Nutzer es tun würde
-  - then it calls these function as if the user would do it
+  - es speichert den aktuellen Rückgabewert ( welcher die aktuellen Messdaten repräsentiert ) in res
-  - it saves the actual return value (which represents e.g. the actual measuring data) in res
+  - res wird dann wie der initial dargestellte Wert, als das Menü konfiguriert wurde, benutzt
-  - res is then be used as initial displayed value when setting up the menu
-By that it's possible without big efforts to fill a menu  with real data already during initialization, so the actual data is visible straight from the beginning.
+Durch diese Vorgehensweise ist es möglich, ohne großen Aufwand ein Menü mit den reellen Daten während der Initialisierung zu füllen. So sind die aktuellen Daten von Anfang an direkt sichtbar.