Lerne den Morse-Code kennen, dekodiere (entschlüssle) geheime Nachrichten und baue deinen eigenen Telegrafen: Ein Tastendruck wird zum Signal: Aus Punkten und Strichen werden Buchstaben, Pausen geben ihnen Bedeutung.
Benötigte Vorkenntnisse
Starte vorher mit einer der beiden Boxen „Musik programmieren“ oder „Segment-Counter“. In dieser Box vertiefst du Befehle/Funktionen und entwickelst daraus den Morse-Code.
Schwerpunkte
Funktionen für Dit und Dah geben dem Morse-Code seine Zeichen. Hier vertiefst du den Einsatz von Funktionen und achtest auf das richtige Timing.
Zentrales Bauteil
LED oder Piezo: Der Morse-Code wird zu einer Zeichenfolge aus Licht und Ton. Kurze und lange Signale blitzen auf und Pausen codieren die Buchstaben. In einer Bonus-Lektion lernst du selbst zu morsen; dabei begegnet dir ein neues Bauteil.
Umfang
5 Module: Vom ersten Morse-Zeichen bis zur eigenen Nachricht entwickelst du deinen Code immer weiter, baust einen elektrischen Telegrafen und vertiefst praktische Anwendungen mit Funktionen.
Alle Projekte der Mikrocontrolling Kurswelt kannst du entweder mit Codeblöcken oder mit Text-Code programmieren. Du entscheidest selbst, welcher Weg besser zu dir passt.
Programmiere mit Text
Beim Programmieren mit Text schreibst du deinen Code selbst. Du hast mehr Freiheiten als bei Codeblöcken, musst aber auch genauer auf Details wie Klammern und Semikolons achten.
➔ Ausgewählt: Programmieren mit Text
Programmiere mit Codeblöcken
Programmierst du mit Codeblöcken, baust du dein Programm aus bunten Bausteinen zusammen.
Der Morse-Code besteht nur aus Punkten (=Dit) und Strichen (=Dah): Suche die passenden Buchstaben im Morsealphabet, um die Wörter zu entschlüsseln.
Entschlüssle den Code und finde die Wörter. Das Morse-Alphabet hilft dir dabei.
Eigenes Hardware-Set
Arbeite mit echten Bauteilen und baue deine Schaltungen auf. Wenn du mit „echter“ Hardware arbeitest, musst du eventuell noch ein paar Dinge vorbereiten, damit dein PC den Mikrocontroller erkennt und du deinen Code übertragen kannst.
Mit einem Simulationstool
Vor allem am Anfang ist ein Simulationstool wie TinkerCAD eine gute Alternative – du brauchst keine Hardware und kannst sofort starten. Verbinde die Bauteile direkt am Bildschirm, programmiere sie wie echte Bauteile und simuliere alles, was du aufgebaut hast.
Beim Programmieren ist es wichtig, dass du deine Programme sinnvoll strukturierst. Gerade am Anfang ist das schwer. In den nächsten Modulen sind einige Teile des Programms schon fertig, andere fehlen. Die Aufgaben führen dich durch den Code und helfen dir dabei, dein eigenes Morse-Programm aufzubauen.
Um Morsezeichen zu programmieren, verwenden wir Funktionen. Ein Teil des Codes ist bereits fertig: Es geht darum, den Buchstaben „L“ mithilfe einer LED zu morsen.
void setup(){
dit();
dah();
dit();
dit();
}
void loop(){
// Der Buchstabe soll
// nur 1x gemorst werden
}
Im Morse-Code ist alles genau definiert, außer das Dit:
Dit = Dauer frei wählen
Dah = 3x so lang wie ein Dit
Die Pause zwischen den Symbolen ist ebenfalls so lange wie ein Dit.
Dit = Punkt, Dah = Strich
Wir verwenden für die Dauer eines Dits 500ms, daraus ergibt sich alles andere automatisch:
Dit ➔ LED an = 500ms
Pause ➔ 500ms aus
Dah ➔ LED an = 1500ms
Pause ➔ 500ms aus
Dit ➔ LED an = 500ms
Pause ➔ 500ms aus
Dit ➔ LED an = 500ms
Pause ➔ LED aus; Programm Ende
dit(); und dah(); sind Befehle, die er noch garnicht gibt: Wir haben noch keine passenden Funktionen dazu erstellt!
void dit(){
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
}
void dah(){
digitalWrite(13, HIGH);
delay(1500);
digitalWrite(13, LOW);
delay(500);
}
void setup(){
pinMode(13, OUTPUT);
// Morse den Buchstaben L
dit();
dah();
dit();
dit();
}
void loop(){
// L soll nur 1x gemorst werden
}
Beim Morse-Code entscheiden nicht nur Punkte und Striche. Kurze Pausen trennen Punkte und Striche, längere Pausen Buchstaben und noch längere Pausen ganze Wörter. Jetzt kommt es darauf an, wie du die Funktionen einbaust: Achte auf die Pausenzeiten!
Im Morse-Code werden alle Zeiten über ein Dit bestimmt.
Erweitere deinen Code und sende die Nachricht „LED CODE“. Ergänze hierzu die fehlenden Symbole und achte auf die richtigen Pausen.
L = .-..
E = .
D = -..
C = -.-.
O = ---
D = -..
E = .
void dit(){
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
}
void dah(){
digitalWrite(13, HIGH);
delay(1500);
digitalWrite(13, LOW);
delay(500);
}
void setup(){
pinMode(13, OUTPUT);
// L = . - ..
dit();
dah();
dit();
dit(); // Pause 500ms in Funktion
// 1500ms Pause - 500ms
delay(1000);
// E = .
dit(); // Pause 500ms in Funktion
// 1500ms Pause - 500ms
delay(1000);
// D = -..
dah();
dit();
dit(); // Pause 500ms in Funktion
// 3500ms Pause - 500ms
delay(3000);
// C = -.-.
dah();
dit();
dah();
dit(); // Pause 500ms in Funktion
// 1500ms Pause - 500ms
delay(1000);
// O = ---
dah();
dah();
dah(); // Pause 500ms in Funktion
// 1500ms Pause - 500ms
delay(1000);
// D = -..
dah();
dit();
dit(); // Pause 500ms in Funktion
// 1500ms Pause - 500ms
delay(1000);
// E = .
dit();
}
void loop(){
}
Wenn du den Code geschickt aufgebaut hast, kannst du mit minimalen Änderungen den Code mit Licht und Ton senden: Erweitere dein Morse-Code-Programm mit einem Piezo für passende Töne.
Erweitere deinen Code so, dass der Code mit Licht und Ton übermittelt wird.
Den passiven Piezo programmierst du ähnlich zu einer LED: Starte den Ton und Stopp den Ton. verwenden kannst du jede Frequenz, beispielsweise Ton A = 440Hz.
In deinem Code entstehen die Morse-Buchstaben nur aus den Funktionen dit() und dah(). Genau hier musst du den Piezo ergänzen.
void dit(){
digitalWrite(13, HIGH);
tone(12, 440);
delay(500);
digitalWrite(13, LOW);
noTone(12);
delay(500);
}
void dah(){
digitalWrite(13, HIGH);
tone(12, 440);
delay(1500);
digitalWrite(13, LOW);
noTone(12);
delay(500);
}
Wieder sind wir an der Stelle, wo unser Code viel zu lang wird. Die Idee ist einfach, die Umsetzung liegt bei dir. Einige Teile des Programms sind schon fertig, andere fehlen.
void setup(){
morse_L();
morse_E();
morse_D();
morse_C();
morse_O();
morse_D();
morse_E();
}
void loop(){
}
dit(); und dah(); sind Befehle, die die Hardware (an-)steuern.
Die IDEE: Wir können für jeden Buchstaben eine eigene Funktion erstellen und hier dit() und dah() aufrufen, um einzelne Buchstaben zu morsen.
Wichtig: Auch hier darfst du die Pausen zwischen Buchstaben und Wörtern nicht vergessen. Versuch sie ebenfalls in die Buchstaben-Funktionen einzubauen, achte aber auf die Pause zwischen Wörtern!
// Aus dem Bonus-Modul:
// dit() und dah() wahlweise mit oder ohne Piezo
void dit(){
digitalWrite(13, HIGH);
tone(12, 440);
delay(500);
digitalWrite(13, LOW);
noTone(12);
delay(500);
}
void dah(){
digitalWrite(13, HIGH);
tone(12, 440);
delay(1500);
digitalWrite(13, LOW);
noTone(12);
delay(500);
}
// Hier definieren wir die Buchstaben
// Pausen nicht vergessen
void morse_C(){
dah();
dit();
dah();
dit();
delay(1000);
}
void morse_D(){
dah();
dit();
dit();
delay(1000);
}
void morse_E(){
dit();
delay(1000);
}
void morse_L(){
dit();
dah();
dit();
dit();
delay(1000);
}
void morse_O(){
dah();
dah();
dah();
delay(1000);
}
// Jetzt müssen wir nurnoch die Buchstaben aufrufen
void setup(){
pinMode(13, OUTPUT);
morse_L();
morse_E();
morse_D();
// Hier musst du aufpassen:
// Am Ende von dit() warten wir 500ms
// Am Ende von morse_D warten wir 1000ms
// 3500 - 500 - 1000
delay(2000);
morse_C();
morse_O();
morse_D();
morse_E();
}
void loop(){
}
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.
Die Ziffern rasen über die Anzeige und der Zufall entscheidet, wo die Zahl stehen bleibt: Aus deinem Segment-Counter kann mehr werden. Kombiniere die 7-Segment-Anzeige mit einem Taster und einer Zufallsfunktion. Auf Knopfdruck erscheint eine neue Zahl — gesteuert von deinem Mikrocontroller und programmiert von dir.
Hast du beide Teile des geheimen Codes, kannst du das Projekt „Der elektronische Würfel“ kostenlos freischalten.
Im Segment-Counter hast du die 7-Segment-Anzeige kennengelernt und erste eigene Ziffern programmiert. Hier findest du den ersten Teil des geheimen Codes.
Im Projekt „Der Taster-Code“ baust du einen Taster ein und arbeitest mit Kontrollstrukturen und Abfragen. Dort findest du den zweiten Teil des geheimen Codes.
Zwei Projekte schließen direkt an den Segment-Counter an: Der Morse-Code greift alles aus dem Themenfeld „Starter“ auf und vertieft Funktionen – der Taster-Code öffnet ein neues Themenfeld voller Verzweigungen, Eingaben und Kontrollstrukturen.
Lerne den Morse-Code kennen, dekodiere (entschlüssle) geheime Nachrichten und baue deinen eigenen Telegrafen. Hier baust du Funktionen für Dit und Dah, definiere die Länge der Zeichen und bestimmst die Pausen. Mit dem Projekt vertiefst du alles, was du hier gelernt hast in einem großen Projekt rund um geheime Texte, die du selbst Programmierst.
Ein Tastendruck verändert alles: Du entscheidest, was wann in deinem Code ausgeführt wird. Schreibe intelligente Programme, baue eine Fußgänger-Ampel und merke dir Zustände. In diesem Projekt erwarten dich neue Bauteile und Kontrollstrukturen – zusätzlich findest du den zweiten Teil des geheimen Codes, um den elektronischen Würfel freizuschalten.
7-Segment-Anzeigen für mehrstellige Zahlen – Texte, Strings und Variablen auf einem LCD-Display oder blinkende Punkte auf der LED-Matrix: Hier leuchten Buchstaben auf, Pixel setzen sich zu eigenen Symbolen zusammen und Zahlen laufen über deine Anzeige. Mache deinen Code sichtbar und lass ihn mit der Welt kommunizieren.