ELO Mikrocontroller und Programmierung Bascom-AVR Morse-Terminal

Weitere Artikel aus dem Elo-Magazin

Technik mit Bascom - Verbesserungen - Aufrüsten

Morse-Terminal

In diesem Projekt entsteht ein Halbduplex-Morseterminal, das sowohl serielle Signale in Morse ausgeben als auch Morseeingaben in serielle Signalen wandeln kann.

von Ralf Beesner

Mein vorheriges Projekt „Seriell-Morse-Wandler" deckt nur eine Richtung ab - die Ausgabe serieller Signale als Morsecode. In diesem Projekt wird nun auch die Gegenrichtung realisiert - es entsteht ein Halbduplex-Morseterminal, das sowohl serielle Signale in Morse ausgeben als auch Morseeingaben in serielle Signalen wandeln kann. Die Morseeingabe erfolgt (wie bei einem Squeeze- Elbug) mit zwei Paddles.

Damit wird es möglich, sich in Morse auf einem Rechner einzuloggen, der den Login über eine serielle Schnittstelle unterstützt. Auf einem Linux-Rechner läßt sich das mit Bordmitteln einrichten.

Ganzen Artikel lesen...

Allerdings zeigt sich, daß die Kommunikation doch recht mühsam ist, weil der Login- Vorgang einerseits recht geschwätzig ist (er ist halt auf einen vergleichsweise schnellen Modemzugang und nicht auf langsames Morse ausgerichtet) und andererseits keine kleinen Fehler verzeiht, so daß der Login leicht in die „Grütze" geht.

Da nur wenige I/Os benötigt werden und um die Sache spannender zu machen, basiert das Projekt auf einem ATtiny 45. Der "Seriell-Morse-Wandler" mit einem ATtiny 13 hatte gezeigt, daß ein Software-UART mit selbstgestrickten Zeichenpuffer schnell genug ist, und der Attiny 45 bietet mit seinen 256 Byte SRAM Platz für einen Zeichenpuffer von etwa 180 Bytes. Da auch der Flashspeicher grosszügig bemessen ist, war Platz für eine interaktive Geschwindigkeitseinstellung.

Prinzip der Codierung

Die Codierung erfolgt wie in meinen älteren Projekten:

1 Byte pro Zeichen, niederwertiges Bit zuerst
hat das Bit den Wert 0: Morsepunkt (dit)
hat das Bit den Wert 1: Morsestrich (dah)
da Morsezeichen unterschiedlich lang sind, ist ein Ende- Zeichen erforderlich; es ist ebenfalls ein 1 - Bit
Beispiel Morsezeichen "a" (dit dah): &B00000110
Beispiel Morsezeichen "9" (dah dah dah dah dit): &B00101111

Das Umsetzen empfangener serieller Signale in Morsezeichen erfolgt nach dem bekannten Muster:

In der Tabelle wird das zu dem empfangenen ASCII- Zeichen gehörende Morsebyte nachgeschlagen. Es wird das niedrigstwertige Bit ausgelesen; ist es eine "0", wird ein Morsepunkt erzeugt, ist es eine "1", wird ein Morsestrich gebildet. Danach wird der Byteinhalt nach rechts geschoben und wieder das niederwertigste Bit ausgewertet. Hat das Byte nur noch den Gesamtwert "1", ist das Ende- Zeichen rechts angekommen; es wird eine Zeichenpause eingefügt und das nächste ASCII- Zeichen ausgewertet.

Für die Senderichtung ist eine Hilfsvariable erforderlich:

Die Byte- Hilfsvariable „K„ wird zunächst auf "1" gesetzt. Mit jedem Morsetakt wird das "1" - Bit um eine Stelle nach links geschoben. Wurde der Morsetakt durch den Strich- Hebel ausgelöst, wird der Wert von "K" in einer Variablen "D" aufaddiert. In "D" befindet sich also - von rechts nach links gelesen - pro Punkt eine "0" und pro Strich eine "1".

Wird kein Hebel mehr gedrückt, weil das Zeichen komplett ist, wird die Trennzeit zwischen zwei Morsezeichen abgewartet und dann das Ende- Zeichen durch letztmaliges Addieren von "K" zu "D" angefügt. Anschließend wird per Lookdown in der Zeichentabelle das zu dem Morsebyte passende ASCII- Zeichen nachgeschlagen und über die serielle Schnittstelle ausgesandt.

Hardware

Die Hardware ist an das LP Mikrocontroller angelehnt und auf einer Lochrasterplatine aufgebaut. Die serielle Schnittstelle "hängt" an den Ports PB0, PB1, PB2; allerdings habe ich, weil die Pins der D-Sub- Leiterplattensteckverbinder nicht im 2,54mm- Raster liegen, einen 10- poligen Wannensteckverbinder verwendet. Früher hatte ich Wannenstecker gemieden, weil die beiden Stiftreihen nur 2,54 mm auseinander liegen und das Auftrennen der Leiterbahnen zwischen den Reihen daher schwierig ist, aber wenn man die Leiterbahnen bereits vor dem Verlöten des Wannensteckers mit einem Messer aufritzt und dann mit einer Schraubendreherklinge den Spalt etwas verbreitert, lassen sich die Wannenstecker auch auf Lochrasterplatinen recht gut verarbeiten.

Die Verbindung zur PC- seitigen D-Sub- Steckbuchse erfolgt mit 10- poligem Flachbandkabel; die zehnte Ader an Pin 10 des Wannensteckers dient der Zuführung der Betriebsspannung, die an einer USB- Buchse des PC abgegriffen wird. Zu beachten ist die unterschiedliche Zählweise der Wannensteckerpins und der D-Sub- Pins. Die Betriebsspannung kann wahlweise auch über die RTS- Leitung und eine Diode 1N4148 bereitgestellt werden, um die Kompatibilität zum LP Microcontroller zu wahren.

An PB3 und PB3 liegen zwei Mikrotaster, mit denen die Striche und Punkte eingegeben werden; an PB0 der Buzzer. Ein "Mäuseklavier" mit zwei Schaltern legt den Reset auf Masse bzw. unterbricht die Verbindung PB0 - Buzzer. Schließt man den Reset- Schalter und öffnet man den Buzzer- Schalter, lässt sich der Attiny über die serielle Schnittstelle programmieren.

Flashen

Attiny 13 lassen sich in dieser Schaltung mit Burkhard Kainkas LPMicroISP.exe programmieren. Für Attiny 45 eignet sich das Kommandozeilenprogramm avrdude.exe; ich beschreibe in einem separaten Beitrag, wie man ihm - auch wenn man mit der Kommandozeile auf Kriegsfuß steht - mit passenden Batchdateien seinen Schrecken nehmen kann.

Software

Die Software gliedert sich in folgende Blöcke:

Interrupt- Routine "seriellelesen", sie buffert die Zeichen, die über die serielle Schnittstelle eingehen
"Speed" fragt nach einem Reset die gewünschte Morsegeschwindigkeit ab (Frage und Antwort in Morse)
"Zeichenlesen" und "Morse" geben die Zeichen aus dem seriellen Buffer akustisch in Morse aus
"Decodekeyer" wandelt die mit den Paddles eingegebenen Morsezeichen in Ascii und sendet sie auf die serielle Schnittstelle
"Main" ruft Zeichenlesen und "Decodekeyer" abwechselnd auf

Für die Eingabe der Morsezeichen wird die Geschwindigkeit auf 2/3 herabgesetzt, um Gebefehler zu minimieren, außerdem wird die Tonhöhe etwas abgesenkt, damit man eigene Eingaben besser von Ausgaben unterscheiden kann.

Da das Morsealphabet keinen Zeilenumbruch kennt, dieser aber für die Kommunikation mit einer Maschine wichtig ist, habe ich das Zeichen "KN" (ohne Zwischenraum gegeben) als Zeilenumbruch definiert.

Ich habe den Code auch auf den ATmega8 und den Atmega88 portiert; die ATmega88- Version orientiert sich am Franzis- LP Bascom (die beiden vorhandenen Taster werden als Punkt- und Strichkontakt genutzt; der Trimmwiderstand dient zur Geschwindigkeitseinstellung).

Einrichten des Linuxrechners

Da Linux einige Sonderzeichen verwendet, die das Morsealphabet nicht kennt und da es auch "zu geschwätzig" ist, habe ich einen neuen User "m" eingerichtet und versucht, einige Probleme zu umschiffen.
Der User "m" hat ein leeres Passwort. Im Homeordner liegen ein paar Dateien, die den User "morsekompatibler" machen sollen: Eine 0-Byte Datei namens .hushlogin verkürzt den Login- String auf das nötigste, und in der Datei .bashrc wird der Prompt vom schwer zu morsenden

m@robbi:/home/m>

auf

++ <KN>

abgeändert.

Außerdem muss man den login über eine serielle Schnittstelle freischalten. Linux stellt auf dem Rechner (neben dem Grafikmodus) mehrere Textkonsolen bereit, zwischen denen man mit F1 ... F6 hin- und herschalten kann. Sie sind in der Datei /etc/inittab konfiguriert. Analog zu diesen virtuellen Terminals kann man über einen inittab- Eintrag ein echtes serielles Terminal einrichten (Neustart des Rechners erforderlich, damit der Eintrag übernommen wird):

# Local serial lines:
s1:12345:respawn:/sbin/agetty -L -w -i -t 300 ttyS0 9600 dumb

Agetty ist das Programm, das den login entgegennimmt. Die Parameter für agetty unterdrücken das Warten auf den Carrier Detect, den ein Modem ausgeben würde, agetty wartet stattdessen auf einen Carriage return, der den login startet, verlängern die Anmeldezeit auf 300 Sekunden und lassen agetty auf der ersten seriellen Schnittstelle horchen; die Datenrate ist 9600 bit/s und es werden keine speziellen Terminal- Steuerzeichen ausgewertet.

Unter Ubuntu funktioniert das so nicht, weil Ubuntu nicht die klassische Unix- Start- Maschinerie "Init", sondern einen neueren Ansatz namens „Upstart" verwendet. Man kann /sbin/agetty testweise auch als root direkt in einem Terminal starten, aber es verhält sich dann etwas sonderbar.

Praktische Demonstration

Das ganze ist ziemlich umständlich und nicht wirklich praktikabel, aber funktioniert grundsätzlich, wie diese MP3- Datei (m.mp3) zeigt. Hier ist der Dialog in plain text; die Morse- Ausgaben des Systems sind in Kleinschrift, meine Morse-Eingaben in Großschrift:

robbi login:

M
password:
login incorrect

robbi login:
M

++
LS
hello.txt profile vertrag.txt
++
CAT HELLO.TXT

this is slackware 13.1 morse shell
how are you ?
have fun.
++
EXIT
abgemeldet

Erläuterung: Der erste login ist fehlerhaft, der erneute klappt dann; mit "ls" werden anschließend die Dateien im Heimatordner aufgelistet. Anschließend wird mit "cat hello.txt" der Inhalt der Datei "hello.txt" ausgegeben. Danach erfolgt mit dem Befehl "exit" die Abmeldung.

Fazit

Zur Kommunikation mit einem PC ist das Morse-Terminal nicht wirklich brauchbar; es ist einfach zu langsam und hinsichtlich des Zeichensatzes zu beschränkt.

Es eignet sich aber durchaus zur Kommunikation mit einem anderen Microcontrollersystem, das nur wenige Ein- und Ausgaben erfordert (z.B. einen Konfigurations- Dialog).

Die Subroutinen des Programms lassen sich in anderen Projekten (z.B. Speichermorsetaste, Codeschloss oder ATtiny-45-Morseuhr) zur direkten Steuerung des Mikrocontrollers verwenden, da man über nur zwei IO-Pins Befehle an den Mikrocontroller senden kann und nur einen Pin für die "Gegenrichtung" benötigt.

Download:

Bascom Quelltexte und Hex-Files für M8, M88 und T45: Morseterminal.zip

'
' Programm gibt über die serielle Schnittstelle eingehende Zeichen akustisch als Mosecode aus und
' sendet über die Paddles eingegebenen Morsecode auf die serielle Schnittstelle
'
' Die Tonhöhe ist fest eingestellt.
'
' Pin PB0 wird als Timer0-Ausgang OC0a verwendet, Ton wird durch Umschalten des
' Pins als Eingang / Ausgang ein- und ausgeschaltet
'
' Das Paddle für die Eingabe der Morsezeichen liegt an PB3 (Punktkontakt) und PB4 (Strichkontakt)
'
' Pin PB1 und PB2 bilden einen Software- UART (eingetippte Zeichen werden aber nicht als Echo auf das Terminal
' zurückgesendet)
'
' Version mit Terminalbuffer: Pegeländerungen am seriellen Eingang lösen einen Interrupt aus. Die Zeichen werden
' im Hintergrund in einen FIFO geschrieben und durch die Morseroutine Zug um Zug ausgelesen.
' Der FIFO speichert 178 Zeichen.
' Damit der Buffer scvhnell genug ist, Taktrate 8 MHz OHNE Vorteiler
'
'
' Der FIFO nutzt die Overlay- Funktionalität. Der FIFO wird mit den komfortablen String- Manipulationsbefehlen
' bearbeitet; das Auslesen des ältesten Zeichens im FIFO erfolgt jedoch direkt als Byte statt als 1-Zeichen-String;
' das erspart die Umwandlung String -> Byte
'
' Version 2 fragt nach Reset erst mal die gewünschte Geschwindigkeit ab. Sendegeschwindigkeit ist geringer (2/3)
'
' Version 2a vermindert die Anforderungen an die Gebepräzision; auch bei kleinen Pausen zwischen Punkt und Strich
' wird auf ein gemeinsames Zeichen erkannt

' Version 3 sendet bei Pause > 5 Punkte genau ein Leerzeichen auf des Terminal
'
'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
'
' Grundeinstelllungen:
$regfile = "ATtiny45.dat"
$crystal = 8000000 ' interner RC-Oszillator, KEIN Vorteiler
$hwstack = 40 ' 32 Byte wegen Interrupt + 8 bBytes für max.4 Unterprogramme
$swstack = 0
$framesize = 0
Baud = 9600

'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

'Variablen und Konstanten dimensionieren:
'

Dim Recbyte As Byte
Dim Recchar As String * 1
Dim I As Byte 'Für temporären Gebrauch als Schleifenzähler
Dim J As Byte
Dim K As Byte ' ''
Dim Z As Byte ' Z=1, wenn bereits ein Leerzeichen gesendet wurde
Dim M As Byte ' Index des aktuellen Morsebuchstabens in unserer Tabelle
Dim L As Byte ' für niederwertigstes Bit beim bitweisen Erzeugen des Morsezeichens

Dim D As Byte ' Morsebyte in der Decodierroutine
Dim P As Byte ' Punktspeicher-Bit der Decodierroutine
Dim E As Byte ' resultierendes ACCII-Byte der Decodierroutine

Dim Pufferstring As String * 178
Dim Puffer(3) As Byte At Pufferstring Overlay
Dim Txtstring As String * 4
Dim Txt(4) As Byte At Txtstring Overlay
Dim T As Byte

Const Tonhoehe1 = 25 ' Tonhöhe
Const Tonhoehe2 = 40
Dim G(2) As Word

Dim Punktlaenge1 As Word ' Punktlänge in "Empfangsrichtung"
Dim Punktlaenge2 As Word ' Punktlänge in "Senderichtung"
Dim Punktachtel As Word
Dim Strichlaenge1 As Word ' Strichlänge
Dim Strichlaenge2 As Word
Dim Wortpause1 As Word ' Länge Wortpause
Dim Wortpause2 As Word
'
Buzzer Alias Ddrb.0
Punktkontakt Alias Pinb.3
Strichkontakt Alias Pinb.4

'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
'Initialisierung des Programms:
'
'

' Morseton mit Timer0 erzeugen:
'
' Timer0 zählt das Register TCNT0 hoch. Es wird mit Register OCR0A verglichen.
' Wenn TCNT0 = OCR0A, wird Output OC0A/PB0 umgeschaltet (getoggled)
' Timer0 erzeugt so Dauerton; er wird jedoch nur an den Ausgangspin durchgeschaltet,
' wenn das Datenrichtungs- Register DDRB.0 = 1 ist. Bei 0 wird der Ton unterdrückt.
'
Config Timer0 = Counter , Prescale = 1024 , Compare A = Toggle , Clear Timer = 1

Acsr.acd = 0 ' Analog-Komparator ausschalten, spart etwas Strom
Pcmsk.2 = 1 ' PCINT für Port B.2 freigeben
Gimsk.5 = 1 ' PCints aktivieren
Sreg.7 = 1 ' Interrupts gernerell freigeben

Portb = &B00011000 ' Pullups für Strich- und Punktkontakt
Ddrb = &B00000000 ' erstmal alles Eingang

Open "comb.2:9600,8,n,1,inverted" For Input As #1 ' Software- UART Input an PortB.2
Open "comb.1:9600,8,n,1,inverted" For Output As #2 ' Software- UART Output an PortB.1

On Pcint0 Seriellelesen

'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Speed:

' vorläufige Werte

Punktlaenge1 = 80 ' Punktlänge in "Empfangsrichtung"
Punktlaenge2 = 100 ' Punktlänge in "Senderichtung"
Punktachtel = 20
Strichlaenge1 = Punktlaenge1 * 3 ' Strichlänge
Strichlaenge2 = Punktlaenge2 * 3
Wortpause1 = Punktlaenge1 * 5 ' Länge Wortpause
Wortpause2 = Punktlaenge2 * 5

' Wunschgeschwindigkeit abfragen; Eingabe 2-stellig

Ocr0a = Tonhoehe1
Txtstring = "WPM?"
Gosub Sendmorsestring

I = 0

If Punktkontakt = 0 Or Strichkontakt = 0 Then ' Punkt - oder Strichkontakt gedrückt
I = I + 1
Gosub Decodekeyer
G(i) = Val(e) ' jeweils einstellige Zahl abholen
End If

Loop Until I = 2

' Aus dem abgefragten Wert neue Geschwindigkeit berechnen

G(1)1 = 10 * G(1) ' Zehnerstelle WPM
G(1) = G(1) + G(2) ' Einerstella addieren
Punktlaenge1 = 1320 / G(1) ' aus WPM Punkitlänge errechnen
Strichlaenge1 = Punktlaenge1 * 3
Wortpause1 = Punktlaenge1 * 5

Punktlaenge2 = 3 * Punktlaenge1 ' Sendegeschwindigkeit soll nur 2/3 der
Punktlaenge2 = Punktlaenge2 / 2 ' Empfangsgeschwindigkeit sein
Punktachtel = Punktlaenge2
Shift Punktachtel , Right , 3 ' Achtel- Punkt
Strichlaenge2 = Punktlaenge2 * 3
Wortpause2 = Punktlaenge2 * 5

Ocr0a = Tonhoehe1

If G(1) < 10 Or G(1) > 30 Then ' auf plausiblen Wert prüfen

Txtstring = "rpt " ' meckern
Gosub Sendmorsestring
Goto Speed ' Geschwindigkeitsabfrage wiederholden
End If

' wenn Geschwindigkeit plausibel, "ok" senden

Txtstring = "ok "
For T = 1 To 3
M = Asc(txt(t))
M = Lookup(m , Morsetabelle) ' Morsezeichen aus Tabelle holen
Gosub Morse
Next T

Main:

Gosub Zeichenlesen

If Punktkontakt = 0 Or Strichkontakt = 0 Then ' Punkt - oder Strichkontakt gedrückt
Gosub Decodekeyer
Put #2 , E ' aufs Terminal senden
Z = 0 ' Leerzeichenflag zurücksetzen
If D <> 45 Then ' an ein Return darf kein Leerzeichen angehängt werden
Gosub Leerzeichenpruefg
End If
End If

Loop

Zeichenlesen:

Ocr0a = Tonhoehe1
If Puffer(1) = 0 Then ' Puffer leer
Return
End If

M = Asc(puffer(1)) ' Ascii- Wert des untersten Zeichens im Puffer ermitteln
M = Lookup(m , Morsetabelle) ' Morsezeichen aus Tabelle holen
Gosub Morse
Pufferstring = Mid(pufferstring , 2) ' das unterste Zeichen im Pufferstring entfernen

Return

' Morsezeichenerzeugung:

Morse:

If M = 0 Then ' Sonderfall: Leerzeichen;
Waitms Wortpause1
Goto Zeichenende
End If

For I = 1 To 8
If M = 1 Then ' Das Byte hat nur noch den Wert 1; Zeichenende!
Goto Zeichenende
End If
L = M And &B00000001 ' niederwertigstes Bit lesen
Buzzer = 1
If L = 1 Then
Waitms Strichlaenge1 ' ist das Bit 1 -> dah
Else
Waitms Punktlaenge1 ' ist das Bit 0 -> dit
End If
Buzzer = 0
Waitms Punktlaenge1 ' Pause innerhalb des Morsezeichens
Shift M , Right , 1 ' Bits um eine Stelle nach rechts shiften
Next I
Zeichenende:
Waitms Strichlaenge1 ' Pause zwischen Morsezeichen

Return

Seriellelesen:

Pcmsk.2 = 0 ' Solange Bits reinkommen, PCINT sperren
Get #1 , Recbyte ' Byte lesen
' Put #2 , Recbyte ' Byte auf Terminal senden (Echo)
Recchar = Chr(recbyte) ' Byte in ASCII- Zeichen wandeln
Pufferstring = Pufferstring + Recchar ' ASCII- Zeichen ans Ende des Pufferstrings anhängen
Pcmsk.2 = 1 ' PCINT wieder freigeben

Return

Decodekeyer: ' Prinzip: eine 1 wird in der Variablen "K" von links nach rechts geschoben.
' nur wenn Strich gedrückt wurde, wird die 1 in die Variable D übernommen
Ocr0a = Tonhoehe2
D = 0
K = 1
Do

If Punktkontakt = 0 Then ' Punktkontakt gedrückt
Buzzer = 1 ' Ton an
Waitms Punktlaenge2
Buzzer = 0 ' Ton aus
Waitms Punktlaenge2
Shift K , Left ' Byteinhalt wandert 1 Stelle nach links, von rechts wird eine "0" eingeschoben

End If

Mark:

If Strichkontakt = 0 Then ' Strichkontakt gedrückt
Buzzer = 1 ' Ton an
Waitms Strichlaenge2
D = D + K ' die 1 für den Strich wird in die Variable "D" übernommen
Shift K , Left ' Byteinhalt wandert 1 Stelle nach rechts, von links eine "0" eingeschoben
If Punktkontakt = 0 Then
P = 1 ' wenn Punktkontakt ebenfalls gedrückt
End If ' Punktspeicher setzen

Buzzer = 0 ' Ton aus
Waitms Punktlaenge2

If P = 1 Then ' Punktspeicher prüfen
Buzzer = 1 ' Ton an
Waitms Punktlaenge2
Buzzer = 0 ' Ton aus
Waitms Punktlaenge2
Shift K , Left ' Byteinhalt wandert 1 Stelle nach links, rechts wird 0 eingeschoben
P = 0 ' Punktspeicher zurücksetzen
Goto Mark ' Prüfen, ob Strichkontakt bereits wieder gedrückt
End If

End If

J = 0
Do ' wir warten max. halbe Punktlänge, um unexakte Gebeweise abzufangen
If Punktkontakt = 0 Or Strichkontakt = 0 Then ' vorzeitiger Ausstieg, wenn Punktkontakt oder Strichkontakt gedrückt
Exit Do
End If
Waitms Punktachtel
J = J + 1
Loop Until J = 4 ' Abbruch bei halber Punktlänge

Loop Until Punktkontakt = 1 And Strichkontakt = 1 ' kein Kontakt mehr gedrückt; Morsezeichen fertig

D = D + K ' eine 1 wird als Endbit angehängt

E = Lookdown(d , Morsetabelle , 128) ' inverse Lookup in der Tabelle, um den zugehörigen Ascii- Wert zu ermitteln
E = E - 1 ' Data- Elemente werden ab 1 gezählt, Ascii- Tabelle beginnt bei Null
If E > 64 Then ' "lookdown" findet stets die Grossbuchstaben.
E = E + 32 ' Wir wollen Kleinbuchstaben (wichtig für Linux)
End If

Return

Leerzeichenpruefg:

I = 0

If Z = 0 Then ' noch kein Leerzeichen auf Terminal gesendet

If Punktkontakt = 0 Or Strichkontakt = 0 Then ' Abruch, wenn Punkt- oder Strichkontakt gedrückt
Exit Do
End If
Waitms Punktachtel
I = I + 1
Loop Until I = 48 ' 48 Achtel = 6 Punktlängen

If I = 48 Then
Put #2 , &H20 ' Leerzecihen auf Terminal
Z = 1 ' Flag, dass Leerzeichen gesendet wurde
End If

End If
Return

Sendmorsestring:

For T = 1 To 4 ' Textstring "WPM ?" ausgeben
M = Asc(txt(t))
M = Lookup(m , Morsetabelle) ' Morsezeichen aus Tabelle holen
Gosub Morse
Next T

Return

'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Morsetabelle:

'Ascii 0 - 32 ; hier wird nur Linefeed in <kn> umgesetzt

Data 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , &B00101101 , 0 , , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0

' Ascii 32 - 47 -> _!"#$%&'()*+,-./
Data 0 , 0 , &B01010010 , 0 , 0 , 0 , 0 , 0 , &B00101101 , &B01101101 , 0 , &B00101010 , &B01110011 , &B01100001
Data &B01101010 , &B00101001

'Ascii 48 - 57 -> 0123456789
Data &B00111111 , &B00111110 , &B00111100 , &B00111000 , &B00110000 , &B00100000 , &B00100001 , &B00100011 , &B00100111 , &B00101111

'Ascii 58 - 64 -> :;<=>?@
Data &B01000111 , &B01110011 , &B00101101 , &B00110001 , &B01101101 , &B01001100 , 0

'Ascii 65 - 90 ABCDEFGHIJKLMNOPQRSTUVWXYZ
Data &B00000110 , &B00010001 , &B00010101 , &B00001001 , &B00000010 , &B00010100 , &B00001011 , &B00010000 , &B00000100
Data &B00011110 , &B00001101 , &B00010010 , &B00000111 , &B00000101 , &B00001111 , &B00010110 , &B00011011 , &B00001010
Data &B00001000 , &B00000011 , &B00001100 , &B00011000 , &B00001110 , &B00011001 , &B00011101 , &B00010011

'Ascii 91 - 96 -> Muell

Data 0 , 0 , 0 , 0 , 0 , 0

' Ascii 97 - 122 abcdrfghijklmnopqrstuvwxyz

Data &B00000110 , &B00010001 , &B00010101 , &B00001001 , &B00000010 , &B00010100 , &B00001011 , &B00010000 , &B00000100
Data &B00011110 , &B00001101 , &B00010010 , &B00000111 , &B00000101 , &B00001111 , &B00010110 , &B00011011 , &B00001010
Data &B00001000 , &B00000011 , &B00001100 , &B00011000 , &B00001110 , &B00011001 , &B00011101 , &B00010011

'Ascii 123 - 127 -> Muell

Die passende Ergänzung zu diesem Artikel: