Morsetrainer

Finden Sie es auch erstaunlich, wie schnell Computer über ein LAN-Kabel kommunizieren: 10 Mbit/s, 100 Mbit/s oder sogar 1 Gbit/s. Zur Erinnerung: Das M steht für Mega, also 1 Million (10 hoch 6), das G für Giga, also 1 Milliarde (10 hoch 9). Bevor uns bei diesen Übertragungsgeschwindigkeiten schwindelig wird, schlage ich vor, dass wir gemeinsam „entschleunigen“ und mit einem selbstgebauten Morsetrainer lernen, rund 100 Zeichen pro Minute zu erkennen.

Informationen zum Morsecode

Wissenswertes über Samuel Morse‘ Erfindung finden Sie u.a. bei Wikipedia, wo ich selbst auch noch einige interessante Einzelheiten entdeckt habe. Das wichtigste fasse ich hier zusammen:

Am Anfang steht sicherlich die Motivation, warum man sich auch heute noch mit dem Morsecode beschäftigen sollte, denn die letzte international beschlossene Änderung liegt nur wenige Jahre zurück. Ich selbst habe es in meiner fliegerischen Ausbildung benötigt, weil die Funkfeuer, also Sender im Mittelwellen- und UKW-Bereich, eine Kennung aussenden, die zusammen mit der eingestellten Frequenz zur eindeutigen Verifizierung führt. Neben den akustischen Signalen können solche Kennungen, z.B. von Leuchtfeuern und Bojen in der Seefahrt, auch als Lichtsignale ausgesendet werden. Im Vordergrund unserer Bemühungen steht also das Verstehen einer Kennung aus meist zwei oder drei „gemorsten“ Buchstaben, z.B. MNE, MNW, MSE, und MSW für die vier ungerichteten Funkfeuer (NDBs) rund um München.

Der Morsecode für die einzelnen Buchstaben besteht aus sogenannten Punkten und Strichen, also kurzen und langen Tönen. Beim Sprechen verwendet man das „di“ oder am Ende „dit“ für den Punkt, ein langes „dah“ für den Strich. Also „di dah di dit“ entspricht dem Morsecode kurz-lang-kurz-kurz. Die Buchstaben bestehen aus 1 bis 4 Zeichen, ursprüngliche Idee: je häufiger der Buchstabe vorkommt, desto kürzer der Morse Code. Wenig überraschend also der Punkt . für das „e“. Zahlen und Sonderzeichen bestehen aus fünf oder noch mehr Zeichen. Das berühmteste Sonderzeichen kennt jedes Kind, den internationalen Notruf di-di-dit - dah-dah-dah-di-di-dit (. . . - - - . . . ). Wie wir sehen werden, hat es zwar Ähnlichkeit mit den Buchstraben S-O-S, es fehlen jedoch die Pausen zwischen den Buchstaben. Save our Souls ist also das erste bekannte „Backronym“.

Wie schnell die Zeichen „gegeben“ werden, hängt natürlich von den Fähigkeiten des Gebers (Senders) und Empfängers ab. In unserem Programm werden wir die Länge ein „dit“ als Variable definieren, die wir später ggf. anpassen können. Dieses „dit“ ist die grundlegende Zeiteinheit, auf die alle anderen Zeiten zurückgeführt werden: Ein „dah“ hat eine Länge von 3 „dit“. Und die Länge der Pausen betragen 1 „dit“ zwischen zwei gesendeten Zeichen, 3 „dit“ zwischen den Buchstaben in einem Wort sowie 7 dit zwischen Wörtern.

Was wir benötigen

Programm in Python

Den ersten Morsetrainer, den ich Ihnen vorstellen möchte, habe ich mit einem Raspberry Pi in der Programmiersprache Python realisiert. Das Problem lässt sich herunterbrechen in zwei Teilaufgaben: Zunächst benötigen wir eine Tabelle mit den „Übersetzungen“. Danach müssen die Punkte und Striche in Töne bzw. Lichtzeichen umgesetzt werden.

In Python gibt es einen Datentyp mit Namen „dictionary“, der für den Zweck der Übersetzung hervorragend geeignet ist. Wir müssen also die nachfolgende Tabelle in ein „dictionary“ z.B. mit dem Namen morse umsetzen.

Für diesen Teil verwende ich Programmcode aus dem Buch von Michael Weigend, mit dem ich Python gelernt habe, und das ich auch heute noch gelegentlich zur Hand nehme.

 #----------------------------------------------------------------
 # Dateiname: morsen.py
 # Text durch Morsezeichen darstellen.
 #
 # Michael Weigend: Raspberry Pi programmieren mit Python, mitp 2013
 # 3.13.2
 # 28.10.2013
 #----------------------------------------------------------------
 ​
 morse = {"a":".-", "b":"-...", "c":"-.-.", "d":"-..", "e":".", "f": "..-.", "g":"--.", "h":"....",
          "i":"..", "j":".---", "k":"-.-", "l":".-..", "m":"--", "n":"-.", "o":"---", "p":".--.",
          "q":"--.-", "r":".-.", "s":"...", "t":"-","u":"..-", "v":"...-", "w":".--", "x":"-..-",
          "y":"-.--", "z":"--..", "ä":".-.-", "ö":"---.", "ü":"..--", "ß":"...--.", " ":" "} 
 ​
 text = input("Geben Sie einen Text ein: ")
 morsetext = []
 for buchstabe in text:
     if buchstabe in morse.keys():
         morsetext.append(morse[buchstabe]) 
 ​
 for m in morsetext:
     print(m, end=" ") 

Die Buchstaben werden innerhalb des „dictionary“ als Schlüssel (keys) verwendet. Hinter dem Doppelpunkt wird der Morsecode mit Punkten und Bindestrichen als Wert (value) aufgeführt.

Da wir nur Kleinbuchstaben im dictionary verwenden, empfiehlt sich die String-Methode lower(), die eine Kopie des Strings mit kleinen Buchstaben erstellt, um keine Lücken zu haben, wenn versehentlich ein Großbuchstabe eingegeben wurde.

In der for-Schleife wird jeder Buchstabe des eingegebenen Textes einzeln umgewandelt und an die anfänglich leere Liste morsetext angefügt. Im Anschluss werden die Elemente der Liste ausgedruckt.

Für die Ausgabe als Ton- oder Lichtsignal schließen wir eine LED und/oder einen Buzzer an einen GPIO-Pin an (hier GPIO24) und schalten den auf HIGH i(led.on() ) bzw. auf LOW (led.off() ). Mit der Funktion sleep() aus dem Modul time bestimmen wir die Dauer des Signals bzw. der Pause. Wie oben erwähnt beziehen sich alle Zeiten auf die Länge eines „dit“, das wir als Variable DIT=0.2 definieren. Zur Erinnerung: Das Dezimalkomma ist in Python der decimal point. Und diesen Wert können Sie später variieren, wenn Sie die Morsezeichen schneller hören möchten.

 #! /usr/bin/python3
 # Morsen_LED.py
 # Programmidee und Algorithmus: Nele Marie Klipp, Enrichment-Kurs 2016/17
 # angepasst an gpiozero: Bernd Albrecht, Kursleiter
 #
 ​
 from time import time, sleep
 from gpiozero import LED
     
 DIT = 0.2
 led = LED(24)
 ​
 MORSECODE = {"a" : ".-" , "b" : "-...", "c" : "-.-.", "d" : "-.." , "e" : ".", "f" : "..-." , "g" : "--." , "h" : "...." ,
            "i" : ".." , "j" : ".---" , "k" : "-.-" , "l" : ".-.." , "m" : "--" , "n" : "-." , "o" : "---" , "p" : ".--." ,
            "q" : "--.-" , "r" : ".-." , "s" : "..." , "t" : "-", "u" : "..-" , "v" : "...-" , "w" : ".--" , "x" : "-...-",
            "y" : "-.--" , "z" : "--.." ,  "1" : ".----" , "2" : "..---" , "3" : "...--" , "4" : "....-" ,
            "5" : "....." , "6" : "-...." , "7" : "--..." , "8" : "---.." , "9" : "----." , "0" : "-----" }
 ​
 def morse(letter):
      print(letter,MORSECODE[letter])
      for a in MORSECODE[letter]:
          if a == ".":
             # print('drin Punkt')
             led.on()
             sleep(DIT)
             led.off()
             sleep(DIT)
          else:
             # print('drin Strich')
             led.on()
             sleep(3*DIT)
             led.off()
             sleep(DIT)
      sleep(3*DIT)
 ​
 def send(text):
     for letter in text:
          if letter in MORSECODE.keys(): 
             morse(letter)
          else:
              sleep(7*DIT)
              print(" ")
 ​
 print('Was soll gesendet werden?\n')
 ​
 Eingabe=input('Text: \n').lower()
 print(Eingabe)
 send(Eingabe)

Download Quellcode Morsen_LED.py

Programm in C++

Um unseren Morsetrainer mit einem Arduino-kompatiblen Micro Controller zu realisieren, müssen wir einen anderen Ansatz wählen, denn C++ kennt kein Dictionary als Datentyp. Alternativ werden wir stattdessen eine Liste der Morsezeichen verwenden, auf die wir dann über den Index auf die einzelnen Buchstaben im Morsecode zugreifen.

Der Einfachheit halber zeige ich das Prinzip nur anhand der Buchstaben ohne Umlaute, Zahlen und Sonderzeichen.

 String morseTable[] = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};

Jetzt muss ich nur noch den Index 0 dem Buchstaben a zuordnen usw. bis Index 25 für den Buchstaben z; also 26 Buchstaben, Index von 0 bis 25!

In der ASCII-Tabelle finde ich die ASCII-Codes 65 bis 90 für die Großbuchstaben A bis Z sowie 97 bis 122 für die kleinen Buchstaben a bis z. Nach der Eingabe der Buchstaben im Seriellen Monitor wird geprüft, ob der ASCII-Wert zwischen den genannten Zahlen liegt. Dann wird der Index durch Subtraktion von 65 bzw. 97 ermittelt und der Morse-Code aus der Liste entnommen. Entsprechend der Anzahl der Morsezeichen eines Buchstabens wird die Schleife für die Ausgabe der Licht- bzw. Tonsignale ein bis viermal durchlaufen. Einen Stolperstein möchte ich noch erwähnen: Bei der if - Abfrage Punkt oder Stich if (morseChar[i]=='.') hatte ich zunächst doppelte Hochkommata verwendet, weil der Morsecode ja als String in der Liste abgespeichert ist. Aber die einzelnen Zeichen des „Strings“ sind ‚Characters‘, also sind einfache Hochkommata zu verwenden.

Hier der Code für unseren Arduino Morsetrainer:

 /* Morse-Trainer mit Arduino
  * Buzzer und LED an Pin 13
  */
 ​
 int ledPin = 13;
 int dit = 200;
 int dah = 3 * dit;
 int oneChar;
 String morseChar;
 String morseTable[] = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
 ​
 void setup() {
   pinMode(ledPin, OUTPUT);
   digitalWrite(ledPin, HIGH);   
   delay(1000);  
   digitalWrite(ledPin, LOW);   
   Serial.begin(9600);
   while (!Serial) {
     ; // wait for serial port to connect. Needed for native USB port only
   }  
   Serial.println("\nEnter group of characters in Serial Monitor");
   Serial.println();  
 }  // end setup()
 ​
 void loop () {
   // get any incoming bytes:
   if (Serial.available() > 0) {
     oneChar = Serial.read();
     Serial.print(char(oneChar));
     Serial.print("   ");    
     morseCode();
   }
 }  //  end loop()
 ​
 void morseCode() {
   if (oneChar >= 65 && oneChar <= 90) {
     morseChar=morseTable[oneChar-65]; }  
   else if (oneChar >= 97 && oneChar <= 122) {
     morseChar=morseTable[oneChar-97];  }
   else {
     morseChar=" ";}
   Serial.println(morseChar);
   outputMorse();
   Serial.println();
 }
 ​
 void outputMorse()  {
   int len = morseChar.length();
 //  Serial.print( "morseChar.length = ");
 //  Serial.println(len);
   for (int i=0; i<len; i++)  {
 //    Serial.print(morseChar[i]);      
     if (morseChar[i]=='.')  {      //reminder: "String" with characters '.' and '-'
       digitalWrite(ledPin, HIGH);   
       delay(dit);  
       digitalWrite(ledPin, LOW);   
       delay(dit);   }
     if (morseChar[i]=='-')  {      //reminder: "String" with characters '.' and '-'
       digitalWrite(ledPin, HIGH);   
       delay(dah);  
       digitalWrite(ledPin, LOW);   
       delay(dit);   }  
     else {
       delay(7*dit);}  
     }
     delay(dah);
   }

Download Quellcode MorseTrainer.ino

Übersicht Morsecode

Zum Erkennen der Morsezeichen hilft die oben gezeigte Tabelle, die alphabetisch sortiert war, leider wenig. Deshalb hier noch einmal die „Umkehrung“ des Morse-Tabelle. Tipp: Beginnen Sie mit den Buchstaben, die maximal drei Zeichen haben. Gerade in den Sommermonaten werden Sie sich sicherlich das E I S am schnellsten merken. Viel Spaß.