Die Aufgabe für heute, Mausgurt zu erzeugen, als Wiederholung für Stracks oder über das Merlin Stracks reinzukommen. Das gab es letztes Jahr schon mal als etwas ausführlicher. Da gab es wirklich eine Sound-Ausgabe. Das sah insgesamt dann zum Schluss etwas anders aus.

Heute will ich das machen einfach mit der LED auf dem Typ drauf, dessen habe ich es heute mitgebracht. Etwas einfacher. Und zwar Mausgurt. Ich möchte sowas veranstalten. Das ist der Buchstabe A. Sowas wird wie eine Zeiteinheit das Licht anschalten.

Und dann merke ich mir vielleicht ein Minuszeichen. Für eine Zeiteinheit das Licht ausgeschaltet lassen. Für drei Zeiteinheiten das Licht angeschaltet lassen. Für drei Zeiteinheiten das Licht ausgeschaltet lassen. Da haben wir schon so ein bisschen antike C-Programmierung schon wieder. Wie kann ich mir etwas effizient merken von dieser Art?

Eine Zeiteinheit anlassen, eine Zeiteinheit ausmachen. Zum Beispiel mit dem Vorzeichen. Ich prüfe nachher einfach auf das Vorzeichen, um festzustellen, soll ich es anmachen oder soll ich es ausmachen. Noch ein paar andere von der Sorte. Buchstabe E wäre eine Zeiteinheit an,

drei aus und H wäre eine an, eine aus, eine an, eine aus, eine an, eine aus, eine an und drei aus. Und so weiter. Noch ein paar andere Buchstaben.

Nur mal die Buchstaben gleich. Ich schreibe noch den Rest irgendwann dazu. Nur die Buchstaben für Hallo Welt, dass man Hallo Welt morsen kann. Und zum Schluss gibt es noch ein Leerzeichen. Gucken wir uns auch mal an. Erste Frage, erster Job. Wie kann ich mir das speichern? Ich möchte mir merken für den Buchstaben A,

diese Folge an Zahlen, für den Buchstaben E, diese Folge an Zahlen, für den Buchstaben H, diese Folge an Zahlen. Strakt, das hatte ich schon gesagt, denke ich jetzt mal darüber nach, wie Sie das mit Hilfe eines Strakts speichern können. Dass man nachher darauf zugreifen kann, wenn der Nutzer sagt,

ich möchte bitte folgende Buchstabenfolge ausgeben, dass man dann einfach nachgucken kann, da kommt ein A vor, dann geben wir das aus, da kommt ein E vor, dann geben wir das aus. Wie stelle ich das in C da? So kann ich es ja nicht schreiben. Irgendwie mit Strakt müsste es gehen. In das Strakt packe ich so etwas rein,

wie Name und Adresse, mehrere Daten, die zusammengehören. Was sind hier Daten, die zusammengehören? Also wenn Sie an Name, Adresse, Geburtsdatum denken, ähnliche Geschichte hier. Buchstabe und jetzt diese Codefolge,

eine Zeiteinheit an, eine Zeiteinheit aus und so weiter, die gehören zusammen. Das sollte jeweils ein Strakt werden. Fangen Sie damit mal an. Wie definiere ich so ein Strakt? Da steht ein Buchstabe drin und eine Folge von Zahlen. Ja, der hier ist zu viel.

So, jede Zeile wird ein Objekt von diesem neuen Datentyp, von diesem Verband verbunden. Von der Strakt. Eine Strakt. Auch da kann man hinschreiben, was da schematisch sowieso hingehört.

Strakt, der Name der Struktur, nennen wir vielleicht noch mal Mauscode. In Schweifklammern schreibe ich was denn wirklich drin steht in der Struktur. Und dann kommt am Ende in C und C++ ja absoluterweise in Semikodern.

Und damit ich ohne Strakt verwenden kann, würde ich sofort zuschreiben, type def Strakt, Mauscode, Mauscode. Wie gesagt, C++ macht das dann von selbst. Sie brauchen auch diese Zeile, dass sie nicht immer Strakt, Mauscode schreiben muss,

sondern einfach Mauscode schreiben kann. Was gehört rein? Das denke ich hat dann jetzt wohl funktioniert. Das erste wird ein Buchstabe sein. Ich merke mir für den ersten Eintrag hier das große A, für den nächsten Eintrag das große E und so weiter in einem einfachen Buchstaben, wie sie den auch immer benennen.

Ich bin jetzt hier auf Englisch, dann machen wir es mal Character. Für den einen Buchstaben. Es lohnt sich nicht dafür ein Array anzulegen. Das wäre ja sowieso gleich bedeutend, ein Array mit einem einzigen Eintrag, ob sie nun einen Array mit einem einzigen Eintrag haben oder den einzigen Buchstaben da. Das wäre nur mehr Schreibarbeit,

wenn sie das Array rausmachen. Sie könnten auch eine Zeichenkette draus machen. Da müssten natürlich in der Zeichenkette auch noch die Null am Ende speichern. Dann hätten einen beiden vergeudet, weil überall immer noch die Null hinterstünde, wo wir schon wissen, dass die zweite immer eine Null sein muss. Wäre nicht so prickelnd. So, das wäre der Buchstabe. Dann brauche ich jetzt eine Folge von

Zahlen. Standardmäßig wäre das jetzt ein Array von Int. Andererseits werden diese Zahlen nicht groß werden. Ich werde nicht bei dem einen Buchstaben eine Zeiteinheit warten und bei dem nächsten Buchstaben tausend Zeiteinheiten warten. Das sind alles sehr handliche Zahlen. Das heißt, statt Int kann ich auch

Char nehmen, einfach nur ein Byte, um Platz zu sparen. Dann muss ich C aber sagen, ein Byte mit Vorzeichen, weil das nicht einheitlich definiert ist in C, ein bisschen unsinnlich. Also hier auf jeden Fall ein Byte mit Vorzeichen. Wenn Sie nur sagen, Char, darf sich C entscheiden, ob es mit

oder ohne Vorzeichen macht. Was bei Buchstaben egal ist, aber hier ist es mir jetzt nicht egal. Ich will 8-Bit-Zahlen mit Vorzeichen. Nennen wir das einfach Code. Das dümmste wäre jetzt zu sagen, ich mache eine Array von 9. Dann sind das längste hier,

wenn ich mir nicht verzählt habe. Das längste ist 8 lang. Das längste ist 8 lang. Aus welchem Grund mache ich das hier? Eine Array mit 9 Einträgen. Derselbe Trick für mir mit den Zeichenketten. Ich verwende eine Null am Ende, um zu sagen,

jetzt ist Schluss. Hier steht dann nachher automatisch am Ende eine Null. Hier wird gleich automatisch dahinter eine Null stehen. Dann weiß man, an der Stelle ist Schluss. Ich achte dann einfach nur auf die Null am Ende. Deshalb 9 und nicht 8. So. So sähe die Struktur aus.

Das ist ganz viel historischer Krempel mit dem Type-Def und den Schweifklammern und Schweifklammern-Semikolon. Aber das ist immer derselbe historische Krempel. Das ist das Schöne. Das ändert sich nicht stündlich. Das Spannende ist, ich speichere mir in diesem Instruct an erster Stelle einen Buchstaben, den ich in der Folgung dann Character nenne,

und an der zweiten Stelle speichere ich mir ein Array von 9, naja, Buchstaben steht da, aber gemeint ist Bytes mit Vorzeichen. Jetzt legen Sie mal eine Variable an und füllen die irgendwie mit dem hier. Was muss jetzt noch passieren, damit ich wirklich eine Variable

mit diesem Inhalt hier füllen kann? Sicherheitshalber nochmal, was der Job sein soll. Also, ich möchte diese Tabelle hier benutzen, um nachher Hallo Welt zu morsen. Aus dieser Tabelle soll das Programm auslesen, was es denn nun machen soll. Wenn es das Haar findet, soll es

kurz eine Leuchtdiode anschalten, genauso kurz sie ausgeschaltet lassen, sie dann wieder für die selbe Zeit anschalten, wieder ausgeschalten und so weiter und so weiter. Am Ende von dem Haar soll sie dreimal so lange ausgeschaltet lassen. Dann soll sie zum A gehen und so weiter. Diese Tabelle hier soll gelesen werden und benutzt werden, um Morsco zu produzieren.

Das hier war noch ganz weit vorne. Jetzt kann ich dem Compiler erst mal überhaupt sagen, wie so ein einziger Buchstabe in dieser Tabelle steht. Und jetzt der nächste Job ist, das soll es jetzt sein, der nächste Job ist, diese Tabelle irgendwie abzuspeichern. Sie können das jetzt ja so nicht kompilieren.

Das gibt ja nur Ärger. Diese Tabelle muss irgendwie abgespeichert werden. Mit irgendeiner Variablen. Was war der Job von dieser Strakt? Der Job von dieser Strakt war, genauso eine Zeile darzustellen.

Jede Zeile hier wird ein Objekt vom Typ Morscode. Das wäre der Gedanke. Jede Zeile wird ein Typ vom Objekt Morscode. Und jetzt habe ich eine Liste von solchen Dingen. Was sollte das also werden?

Ja, ein Array aus Objekten vom Typen Morscode. Das schreiben Sie mal auf. Ein Array von Sachen vom Typ Morscode. Und es wird initialisiert mit diesen Werten, die da stehen. Wie schreibe ich das hin?

Ja, nochmal zum Vergleich. Kann nie schaden. Wenn ich ein Array haben will, was ganze Zahlen speichert, würde ich das so schreiben. So sehe das Array aus, was ganze Zahlen speichert. Sie sagen,

es stehen ganze Zahlen drin. Es soll A heißen, oder wie es auch immer heißen soll. Es ist ein Array. Und dann können Sie es initialisieren mit Schweifklammern. Und wenn es nur eindimensional ist, muss ich auch gar nicht angeben, wie viel Einträge der Compiler anlegen soll. Das kann er dann selber zählen. Ganz dumm ist er dann nicht.

So, jetzt für unseren Morscode. Der Typ ist Morscode. Nicht Int, sondern Morscode. Das steht drinnen. Dann nicht vergessen, dass wir einen Namen für das Ganze brauchen. Nehmen wir das Dictionary. Das Wörterbuch.

Dictionary. Ein Array. Was entspricht jetzt dem hier? Der Typ ist nicht mehr Int, sondern Morscode. Der Name ist nicht mehr A, sondern Dictionary oder Tabelle, wenn Sie wollen. Aber Tabelle ist ein bisschen sehr allgemein. Und dann diese eckigen Klammern, um zu sagen, ein Array.

Und jetzt initialisiere ich das gleich. Schweifklammern. Semikolen. Und in die Schweifklammern kommt jetzt rein, wie es initialisiert wird. Und das ist nun offensichtlich eine Nummer aufwendiger als eben bei dem

Array mit Zahlen. Das wird hier etwas großzügiger vom Platzverbrauch. Ich schreibe mal dazu als Beispiel

für Syntax. Der Typ, der Name, ein Array gleich. In Schweifklammern die Initialisierung. Jetzt muss ich hier raus aus der ersten Zeile eine Strakt machen. Wie machen Sie das hier? Zu einer echten Strakt, ein Objekt

von Typ Morscode. Ja, korrekt. Also hier noch ganz viel hässliche Symbolchen drum. Die Daten als solche sind schon da. Jetzt brauchen wir nur ganz viel Krempel drum rum. In Schweifklammern. Wenn Sie eine Datensammlung zu einer Instanz, einer Strakt machen wollen,

setzen Sie sie in Schweifklammern. Und dann Komma natürlich, weil hier noch ein paar weitere kommen. Mit Komma da die einzelnen trennen. Das A da vorne ist ja nicht als Name einer Variable gemeint, sondern das hier ist als Name, was sowieso schwierig wäre in einem Zusammenhang, aber egal.

Das A hier ist ja als Zeichen gemeint. Das Zeichen, was nachher auf dem Bildschirm als A steht, von dem will ich den Zahlencode haben. Was ist die Code-Nummer des Zeichens groß A? Deshalb die einfachen Anführungszeichen. Und hier hinten

es geht auch so, aber schöner wäre jetzt zu sagen, ok, hier steht ja ein Array von Zahlen. Das ist dann etwas hübscher, wenn Sie es so hinschreiben. Also die erste Zeile insgesamt in Schweifklammern, weil das ja insgesamt ein Link vom Typ Morscode ist.

Hier vorne steht ein Zeichen und hier steht jetzt nochmal ein Array von ganzen Zahlen. Man kann in C mit diesen Schweifklammern sehr locker sein. Wahrscheinlich kann man die sogar alle weglassen, aber das ist dann sehr unübersichtlich. Ich würde es lieber so hinschreiben, zumal es in anderen Sprachen dann auch etwas strenger wird.

So. Und so geht das dann weiter. Der Buchstabe E ist hier gemeint und dann soll hier das Array initialisiert werden mit 1 und minus 3. Sobald Sie in C und C plus plus anfangen zu initialisieren, wird der Rest mit Nullen gefüllt.

Das heißt, diese neun Stellen, die ich da habe, diese neun Stellen werden hier mit 1 minus 3 und lauter Nullen gefüllt. Ich gucke nachher nur auf die Null. Die erste Null, dann weiß ich, wo es aufhört.

Wo ich dann mit Morsen aufhören kann. Mal das mal irgendwie effizient hier hinschreiben. Ja, korrekt. Die einfachen Anführungszeichen nicht ohne was drin, sondern mit Leerzeichen drin. Genau.

So. Das Leerzeichen. Das Leerzeichen ist ja in diesem Spiel ein Buchstabe wie alle anderen. So. Wow. Das wäre die Übersetzungstabelle. Ist das ein großes W? War kein

großes W, Entschuldigung. Großes W natürlich. Das wäre die Übersetzungstabelle für diesen Morscode. Wie ich es jetzt aufbauen würde. Die ganzen anderen Buchstaben und Zahlen und so weiter, würde man noch dazuschreiben. Aber ihr könnt sich vorstellen, wie das geht. Das ist jetzt genug an Code, um Hallo Welt auszugeben. Alle Buchstaben da.

Und das Leerzeichen zwischendrin. Das wird jetzt der nächste Job. Jetzt habe ich sozusagen meine Daten in der Basis. Wie Morscode funktioniert. Jetzt ist der nächste Job. Wie kann ich denn jetzt tatsächlich Hallo Welt ausgeben?

Wenn Sie von oben nach unten denken, mal wieder Top-Down-Programmierung. Was müsste das Programm jetzt eigentlich tun, um Hallo Welt auszugeben? Ich sehe gerade hier fehlen noch so ein paar Schweifklammern. Keine Eckenklammern. Schweifklammern. Da fehlen noch Schweifklammern. Besser. So.

Wie verwenden Sie das jetzt um tatsächlich Hallo Welt zu morsen? Lesen Sie das hier wie ein Telefonbuch. Karl Mayer hat

diese Telefonnummer, Erna Müller hat diese Telefonnummer und so weiter. Was ich gleich mache, ist ich gucke nach dem jeweils fälligen Buchstaben und lese dann aus, welche Codefolge das ist. Also diese Buchstabe und diese

ich benutze den Buchstaben zum Nachschlagen und die Codefolge lese ich aus. So wird das funktionieren. Also wir gerade diskutiert haben. Man könnte tatsächlich, wenn man ganz hart drauf ist und sehr viel Speicherplatz sparen will,

könnte man sowas hier veranstalten. Alles in einer Reihe wegspeichern. Ohne irgendeine Hierarchie drinnen. Man wird sich dann darauf verlassen, dass die Buchstaben erst ab 32 anfangen. Hier habe ich Zahlen, die negativ sind oder unter 32 sind und die Buchstaben

sind ab 32 aufwärts. Ich würde dann diese eindimensional Liste solange durchsuchen, bis ich den richtigen Buchstaben gefunden habe. Und ab da finde ich dann den Zahlencode und den lese ich bis da der nächste Buchstabe kommt dahinter. Das würde funktionieren, würde noch ein bisschen Speicherplatz sparen. Ich finde das gefährlich und später

in den höheren Sprachen, glaube ich, kommt man gar nicht auf den Gedanken. Dann hat man unbedingt sowas, das heißt ein später associatives Array. Ich gucke nach, wo ich den ersten finde. Ich suche gerade zum Beispiel erst Buchstaben H. Dann gehe ich mein Array durch. Wo ist der Buchstabe H drin? Und dann lese ich

den zweiten aus. Das sind die Rollen dann ganz deutlich getrennt. Nichts kann durcheinander gehen. So in Reinen C, wenn der Speicher knapp wird, kann man auf solche Gedanken kommen. Also was ich ausgeben will, sollte nicht Chat, sondern Chat. Was ich ausgeben will,

nach einem etwas Text, die Zeichenkette, die ich ausgeben will, habe ich gesagt, soll Hallo Welt sein. Und ja, das erste wird natürlich sein, diese Zeichenkette muss ich mit einer Vorschleife durchgehen. Ich sollte nicht sagen das erste, das äußere wird sein.

Das äußere wird sein, dass ich diese Zeichenkette mit einer Vorschleife durchgehe. So, die Bedingung, das lassen wir jetzt mal frei. Die Bedingung müssen wir gleich nochmal diskutieren. Das war in einigen Stellen noch nicht so klar. Sie können jetzt mal die Schablone

hinschreiben. Eine Vorschleife in runden Klammern. Was läuft von wo bis wo? Und in Schweifklammern, was denn passieren soll in der Schleife? Und danach ist das Programm auch zu Ende nebenbei, nach der Schleife hier. Die Bedingung, ich möchte mit dem i

meine Zeichenkette, Hallo Welt durchlaufen. Ich möchte nicht mit dem i diese Tabelle durchlaufen. Und ich möchte nicht mit dem i so einen Code durchlaufen. Die Bedingung muss sich darauf beziehen, dass ich fertig bin mit dieser Zeichenkette. Sie gucken also,

das hatte ich ja die letzte Mal schon, jetzt können Sie auf diese etwas rustikale Art gucken. Bin ich noch nicht am Ende der Zeichenkette? Habe ich noch nicht, dass die Null erreicht, die da automatisch dahinter geschrieben wird. Das wäre die Bedingung. Oder Sie gucken, ob i kleiner ist als... Wo ist noch mal den?

1, 2, 3, 4, 5, 6, 7, 8, 9, 10. Sie gucken, ob i kleiner ist als 10. Aber da haben Sie natürlich das Problem, wenn da jemanden andere Zeichenkette reinschreibt, stimmt die C nicht mehr. Das ist so schon etwas geschickter.

Sie gucken, ob Sie die Null am Ende der Zeichenkette erreicht haben oder nicht. So, jetzt gehe ich Zeichen für Zeichen vor. In der Schweifklammer. Was sollte ich in der Schweifklammer tun nun? Das wäre also der Job. Ich gehe hier mit der Schleife jeden Buchstaben der Zeichenkette durch,

den ich ausgeben will. Den aktuellen Buchstaben nehmen Sie sich und gucken nach, wo der denn steht im Dictionary. Hier an der ersten Stelle vom Dictionary. Dann wissen Sie, wo man den Zahlencode nachgucken kann. Ich nehme dann als nächstes das A

und finde den Zahlencode, weil es da zum A gehört und so weiter. Also man muss jetzt hier innerhalb der Schweifklammer das Dictionary durchsuchen. Nach dem aktuellen Buchstaben. Wie durchsuchen Sie das Dictionary nach dem aktuellen Buchstaben? So, ich habe mehrere interessante Lösungen gesehen.

Nicht die schönste, aber vielleicht die C-mäßigste. Ich glaube, ich wäre diese hier. Ich gucke so lange mein Dictionary durch, bis ich den richtigen gefunden habe. Dictionary von

J ungleich Text von I. Ich sage gleich nochmal etwas dazu. Ich tippe es gerade erstmal. Eine leere Vorschleife. Ich gehe das Dictionary durch. J zählt jetzt den Eintrag im Dictionary. Vorsicht, einige Leute

hatten nochmal I geschrieben. Nochmal zweites Mal I ist im Allgemeinen keine gute Idee. Was ist jetzt welches I? Der Compiler weiß, welches I er meint. Aber Sie wissen wahrscheinlich nicht mehr, welches I Sie meinen. Deshalb J hier. Dictionary von J soll nicht dasselbe sein wie Text von I.

Ich habe noch etwas vergessen. Dictionary von J ist ja eine komplette Zeile. Ich möchte nicht die komplette Zeile mit irgendwas vergleichen, sondern daraus den Eintrag, den Charakter. So, jetzt stimmt es dann auch. Diese Vorschleife geht das Dictionary durch.

Ab den Nullten Eintrag so lange wie das, was im jeweiligen Eintrag als Buchstabe steht, also dieses L-O-T-W Leerzeichen so weiter, so lange wie das, was im aktuellen Eintrag als Buchstabe steht, nicht der aktuelle Buchstabe aus meiner Zeichenkette ist. Das heißt, diese

Vorschleife endet, wenn diese beiden gleich sind. Und dann habe ich in J das Richtige gefunden. Nächstes Ergernis ist, Sie sehen, ich habe zwar in J das Richtige gefunden, aber ich erfahre es nicht mehr, weil die Variable J nach der Vorschleife nicht mehr zu haben ist. Das heißt, ich muss hier dieses Int J davor

setzen. So wird das besser. Jetzt habe ich das J auch nach der Vorschleife noch. Die Vorschleife geht das Dictionary durch, solange wie der aktuelle Buchstabetext von I nicht das ist, was gerade in der Zeile J steht.

Es endet dann, wenn die beiden stimmen, wenn ich die richtige Zeile gefunden habe. So wie es jetzt hier geschrieben ist, wäre es noch eine unsichere Geschichte, was passiert, wenn ich hier einen Buchstaben habe, in meiner Zeichenkette, der nicht in meinem Dictionary steht. Was würde

nun passieren, wenn Sie diese Schleife hier machen? Genau, das ist eine gefährliche Geschichte. Wenn Sie einen Buchstaben haben, der nicht in der Tabelle vorkommt, ist ja hier dieser Vergleich auf Ungleich immer wahr. Was in meiner Tabelle steht,

ist garantiert ungleich diesem X, egal wo ich gucke, weil dieses X nicht in meiner Tabelle vorkommt. Das heißt, diese Schleife wird über das Ende vom Dictionary hinausgehen. Das ist noch eine unsichere Geschichte. Da könnte man sich noch ein paar Maßnahmen überlegen. Man könnte hier noch zusätzlich fordern, dass J nicht zu groß

sein darf. Oder man könnte hier noch eine extra Zeile am Ende einbauen. Das können Sie sich selbst überlegen. So wird es funktionieren, ist aber unsicher. Am Ende der Vorschleife weiß ich nun, wo in dieser

Tabelle der Zahlencode steht. Da steckt in J drin. J sagt Ihnen nun, ich muss diese Zeile hier ausgeben. Und jetzt im Sinne dieser Top-Down-Programmierung überlege ich mir jetzt,

welche Funktionen ich gerne hätte, um das auszugeben. Ich gehe den Code durch, der da steht. Noch mal eine Vorschleife. Unglaublich. Ich nehme jetzt mal K. Bedingung überlegen wir uns jetzt gleich.

K++ In dieser Vorschleife mache ich anschaulich Folgendes. Ich gehe jetzt hier durch. K gleich 0, K gleich 1, K gleich 2, K gleich 3 und so weiter.

Gucke, ob das Vorzeichen positiv ist. Dann schalte ich das Licht an. Wenn das Vorzeichen negativ ist, schalte ich es aus. Und ansonsten warte ich solange, wie hier steht. Drei Zeiteinheiten, eine Zeiteinheit. Das wird es nachher werden.

Was schreiben Sie hier als Bedingung hin? Wann höre ich auf, das Zeichen auszugeben? Solange, wie ich hier nicht die 0 am Ende dieser Liste von Zahlen gefunden habe, oder hier direkt nach der Minus 4, solange, wie ich nicht die 0 gefunden habe, solange läuft diese Schleife.

Das müsste man jetzt klug hinschreiben. Ich weiß, in welcher Zeile ich nachgucken muss. Dictionary von J ist die aktuelle Zeile. Da, wo mein aktueller Buchstabe steht, die Zeile, die gucke ich mir an. Aus der Zeile gucke ich mir den Code an.

Und von dem Code gucke ich mir den Eintrag K an. Solange der nicht 0 ist, mache ich weiter. So sieht das dann nachher aus. Dictionary von J ist die jeweilige Zeile. Aus der Zeile hole ich mir dieses Array mit dem Code.

Wenn Sie sich erinnern, das hieß ja Code, dieses Array hier, was da hinten dran liegt. Dieses Array hieß Code. jetzt gucke ich, ob der Sonnenzufilter-Eintrag, der gerade dran ist, mit diesem K gehe ich ja hier dieses Array durch, ob der Sonnenzufilter-Eintrag

immer noch ungleich 0 ist. Wenn ja, mache ich weiter. Wenn nicht, bin ich am Ende von der Schleife. Und mache mit dem nächsten Buchstaben weiter. Ausgabe des nächsten Buchstabs. Und der Rest, ein bisschen auf die Tube drücken, der Rest müsste sich dann so von selbst erschließen.

Ich hole mir mal das aktuelle Symbol aus dem Code raus. Genau nach dieser Art. Jetzt weiß ich, ob ich eine Minus 1 oder

eine Plus 3 oder eine Minus 4 habe, was gerade angesagt ist. Ich gucke, ob es negativ ist oder positiv. Wenn es positiv ist, bräuchte ich jetzt irgendeine Funktion, die die Leuchttiode anschaltet.

Wenn es nicht positiv ist, kann es auch nicht 0 sein, sonst hätte ich ja schon aufgehört. Dann muss es negativ

sein und ich schalte das Licht aus. Ich habe diese Funktion hier LightOn und LightOff, die habe ich noch nicht, aber die hätte ich gerne. Deshalb treibe ich die da einfach mal dreist rein. Und dann müsste ich noch passend warten. Ich hätte gerne eine Funktion, die Wait heißt und die passende

Anzahl an Zeiteinheiten wartet jeweils. Und der sollte ich jetzt dann aber die Anzahl an Zeiteinheiten geben. Mal raufgucken hier, was in meinem Dictionary steht.

Z ist jetzt hier diese jeweils einzelne Zahl, die hier steht. Die 1, die Minus 1, die 3, die Minus 1, alle nacheinander durch. Wenn da eine positive Zahl steht, sage ich Licht bitte an. Wenn da eine negative Zahl steht, sage ich Licht bitte aus. Und jetzt möchte ich noch warten für die jeweilige Zeitdauer. Wenn da eine 3 steht, soll ja

dreimal so lange gewartet werden, als wenn da eine 1 steht. Da kann da auch eine Minus 3 stehen. Und dann soll natürlich nicht Minus 3 mal so lange gewartet werden. Wie könnte man das noch regeln? Ich möchte diesem Wait eigentlich immer nur eine positive Zahl geben. Es gibt die eingebaute

Bibliotheksfunktion ABS. Die braucht man natürlich nicht, weil es viel leichter geht, an dieser Stelle. Wenn die Zahl größer ist als 0, ok, anschalten. Wenn die Zahl kleiner ist als 0, das ist jetzt ganz brutal, dass ich dann sage, z ist

gleich, Minus z, so ist das vielleicht etwas hübscher. Wenn die Zahl negativ ist, sage ich einfach, dann ersetzt man sie durch ihr Negatives und dann ist sie hier wieder positiv. Jetzt muss ich also noch 3 Funktionen schreiben, light on, light off, wait. Ich würde mich mal gerade

selber vorwärts hier ein bisschen auf die Hardware zugreifen müssen. Light on. Schreibe ich sinnvollerweise hier oben noch davor. Die Funktion liefert nichts zurück, sie heißt light on. Sie nimmt nichts.

Der Chip hat ein Register, 8 Bit breit für Ein- und Ausgabe, womit man da die Pins ansteuern kann und das einfachste ist Pin Nummer 0 zu nehmen. Ich zeige das gleich nochmal auf dem Board.

Das einfachste ist Pin Nummer 0, den Ausgang Nummer 0 zu nehmen, nicht Pin Nummer 0 zu nehmen, den Ausgang Nummer 0 zu nehmen. Es gibt dann so einen extra Register, Port 1 Out nennt sich das extra Register, das ist hier in dieser ominösen Header-Datei angelegt.

Und da will ich nun das allerunterste Bit setzen. Das kann man auf verschiedene Arten machen. Eine Art das zu machen wäre diese hier. Das sieht vielleicht etwas irritierend aus. Nehme was in diesem Register steht und dann bilde das

bitweise oder mit der Zahl 1. Wow. Es gäbe noch eine andere Art der Vollständigkeit halber P1 out. Bit, man kann

mit diesem Register auch so reden, als ob es eine Strakt wäre. Bitfield nennt sich das in C. Hatte ich nie erklärt, nur als Anmerkung. Also es geht auch eine Nummer schöner. Aber das

sollte hinhauen mit diesen bitweisen Operationen. Ich nehme was da steht und dann nehme ich nicht plusgleich 1 oder malgleich 1, sondern ich sage bitweise oder gleich 1. Und damit ist dann das letzte Bit gesetzt. Das muss ich vielleicht mal aufmalen gerade.

Wenn Sie irgendeine Binärzahl haben und das letzte Bit setzen wollen, dazu soll es vielleicht auf 0 stehen, und das letzte Bit setzen wollen, ist die simpelste Lösung, dass man mit der binären 1 odiert.

Ich nehme diese Zahl oder binär 1. Bitwise ist oder, binär 1. 0 oder 1 ist 1. Falsch oder wahr ist wahr. 1 oder 0 ist 1 und so weiter. Hier vorne, das sind natürlich die selben, die da standen. 0 oder 0 bleibt 0. Also das ist ein billiger Trick, um das letzte Bit zu setzen.

Oder gleich 1. Wenn man sich hier die Header anguckt, es gibt auch Bit 0, direkt vordefiniert, das ist der Wert 1. Aber so ist vielleicht etwas klarer erstmal. Spannend ist dieser Name hier, P1out, der ist definiert

als eine Seudovariable, in der genau das eine Byte steht. Was sagt, was denn ausgegeben werden soll auf die Ports von dem Chip? Vielleicht dazu, light off wird dann sinnvoller Weise sein, dass ich dieses niedrigste Bit, das niederwertigste Bit auf 0 setze.

Das geht dann mit dem logischen und. Oder man macht es so hier unten mit dem. Mit dem logischen und, dann brauche ich hier aber das Gegenteil, das Kompliment. Ich nehme die binär Zahl, die lauter 1 hat, aber auf der letzten Stelle eine 0 hat.

Das logische Gegenteil von der 1, das Bitweise Kompliment von der 1. Alle Bits setzen, aber das letzte nicht. Und jetzt brauchte ich noch eine Routine hier, die das Vade erledigt. Offiziell müsste man dafür einen Timer nehmen, aber wenn man nur eine

Minute Zeit hat, macht man etwas, das eigentlich verboten ist. Eine V-Schleife. Ich weiß gar nicht, wie groß die V-Schleife sein muss. Nehmen wir lieber Long hier. Ne, gleich 1,

Quatsch, 0, probieren wir es mal, 10.000. Eine V-Schleife zum Warten ist eine super schlechte Idee, weil was ist, wenn man später einen Chip hat, der schneller läuft? Dann ist plötzlich die V-Schleife kürzer.

Es kann Ihnen auch der Compiler rein funken und sagen, oh, diese V-Schleife macht ja nichts, die lasse ich mal ganz weg. Optimierung. Total schlechte Idee, das so zu machen. Man verwendet offiziell einen Timer. Das sehen Sie bei meinen Sachen vom Praktikum. Wenn Sie da in den Code reingucken, ich habe hier diese Funktion, Back Milliseconds, die verwendet einen Timer, einen Zeitgeberbaustein,

auf dem Chip. Und dann stimmt die Zeitangabe auch. Dritter Nachteil, das wenn man so macht, was sind jetzt 10.000? Das sind weder Millisekunden noch Sekunden, das müsste ich ausmessen, wie lang es ist. So, das könnte im Prinzip funktionieren. Ich mache mal gerade einen Make, um zu gucken. So ein Warning.

Oh, VadeZ, wir sehen, das passt nicht ganz mit dem hier zusammen. Ich übergebe ja eine ganze Zahl. Das heißt, ich sollte, wieso und u? Ich sollte 10.000 mal Z warten. So, mit einem Schuh draus.

Ich möchte ja mit Z sagen, wie lange ich warte. Ich multipliziere einfach dann damit. Wenn wir gerade gucken, mit 30.040 Grad noch funktionieren. Ich sage hier mal aus, wirklich eine Langzahl. Noch mal Make.

Besser ist das. Eine Geschichte habe ich noch vergessen. Wenn ich dieser Maschine sage, Sie möge etwas ausgeben, da muss ich hier vorher auch noch sagen, Sie möge bitte diese Port so einstellen, dass auch wirklich etwas auszugeben ist. Es gibt noch einen Register namens P1 Dear. Port One Direction.

In welche Richtung sind die einzelnen Pins Eingabepins oder Ausgabepins? Hier muss ich jetzt noch sagen, dass der Nullte zumindest ein Ausgabepin ist. Das habe ich noch vergessen. Auf diese Weise kann man das sagen. Das letzte Bit in diesem Register setzen. Das ging ja auch wieder hübscher auf diese Weise.

Nun sollten wir was sehen. So, und hier haben wir es nun in Position. Das Launchpad Morst. Hallo Welt.

Und noch mal war es so schön warm.