Morseübungen mit dem PSF154
Für verschiedene Morseübungen braucht man zunächst einmal eine
Tabelle der verwendeten Morsezeichen. Sie ist hier nach dem bewährten
Verfahren aufgebaut, wobei in jedem Byte eine führende 1 von Punkten
(0) und Stichen(1) gefolgt wird. Die Funktion CW_out() wertet diesen
Code aus und ruft die Punkte und Striche auf.
static void CW_Code (void)
{
BYTE i, d;
i = A;
if (i==0) {d = 0b00000101;} //A
if (i==1) {d = 0b00011000;} //B
if (i==2) {d = 0b00011010;} //C
if (i==3) {d = 0b00001100;} //D
if (i==4) {d = 0b00000010;} //E
if (i==5) {d = 0b00010010;} //F
if (i==6) {d = 0b00001110;} //G
if (i==7) {d = 0b00010000;} //H
if (i==8) {d = 0b00000100;} //I
if (i==9) {d = 0b00010111;} //J
if (i==10) {d = 0b00001101;} //K
if (i==11) {d = 0b00010100;} //L
if (i==12) {d = 0b00000111;} //M
if (i==13) {d = 0b00000110;} //N
if (i==14) {d = 0b00001111;} //O
if (i==15) {d = 0b00010110;} //P
if (i==16) {d = 0b00011101;} //Q
if (i==17) {d = 0b00001010;} //R
if (i==18) {d = 0b00001000;} //S
if (i==19) {d = 0b00000011;} //T
if (i==20) {d = 0b00001001;} //U
if (i==21) {d = 0b00010001;} //V
if (i==22) {d = 0b00001011;} //W
if (i==23) {d = 0b00011001;} //X
if (i==24) {d = 0b00011011;} //Y
if (i==25) {d = 0b00011100;} //Z
if (i==26) {d = 0b00111111;} //0
if (i==27) {d = 0b00101111;} //1
if (i==28) {d = 0b00100111;} //2
if (i==29) {d = 0b00100011;} //3
if (i==30) {d = 0b00100001;} //4
if (i==31) {d = 0b00100000;} //5
if (i==32) {d = 0b00110000;} //6
if (i==33) {d = 0b00111000;} //7
if (i==34) {d = 0b00111100;} //8
if (i==35) {d = 0b00111110;} //9
if (i==36) {d = 0b01001100;} //?
if (i==37) {d = 0b01110011;} //,
if (i==38) {d = 0b01010101;} //.
if (i==39) {d = 0b00110010;} ///
if (i==40) {d = 0b00110001;} //-
if (i==41) {d = 0b00101010;} //ar
if (i==42) {d = 0b01111010;} //sk
if (i==43) {d = 0b00110101;} //ka
if (i==44) {d = 0b00110001;} //bt
if (i==45) {d = 0b01011010;} //ac @
A = d;
}
static void Dot (void)
{
Byte t;
t = 70;
if (speed == 2) {t=53;}
if (speed == 3) {t=43;}
if (speed == 4) {t=35;}
if (prog < 11) {PA.6=1;}
do
{
PA.3 = 1; //CW-Ton an PA3
.delay(30);
PA.3 = 0;
.delay(30);
} while (--t);
if (prog < 11) {PA.6=0;}
t = 50;
if (speed == 2) {t=38;}
if (speed == 3) {t=30;}
if (speed == 4) {t=25;}
do
{
.delay(100); //ca. 100 ms
} while (--t);
}
static void Dash (void)
{
Byte t;
t = 210;
if (speed == 2) {t=159;}
if (speed == 3) {t=129;}
if (speed == 4) {t=105;}
if (prog < 11) {PA.6=1;}
do
{
PA.3 = 1; //CW-Ton an PA3
.delay(30);
PA.3 = 0;
.delay(30);
} while (--t);
if (prog < 11) {PA.6=0;}
t = 50;
if (speed == 2) {t=38;}
if (speed == 3) {t=30;}
if (speed == 4) {t=25;}
do
{
.delay(100); //ca. 100 ms
} while (--t);
}
static void CW_out (void)
{
BYTE j, i, d, b, t;
d = A;
b = 1;
do
{
d = d << 1;
b +=1;
} while (d < 128);
do
{
d = d << 1;
b += 1;
if (d >= 128) {Dash();}
if (d < 128) {Dot();}
} while (b < 8);
t = 50; // + ca. 200 ms = ca. 300 ms
if (speed == 2) {t=38;}
if (speed == 3) {t=30;}
if (speed == 4) {t=25;}
do
{
.delay(200);
} while (--t);
}
Das Programm 2 (Jumper: B L LS 0 0 G 0 0 1 0) erzeugt das
Morsealphabet in vier Lektionen und mit optionaler Übungsantwort mit
klassischer Taste. Die Übungen erzeugen jeweils neun Buchstaben in der
alphabetischen Folge. Man braucht also keine Vorkenntnisse und weiß
immer, welches der nächste Buchstabe sein wird. Die Geschwindigkeit ist
unveränderlich 60 BpM. Mit den beiden Jumpern T1 und T2 wird diesmal
die Zeichengruppe ausgewählt
B L LS 0 0 G 0 0 1 0: A B C D E F G H I
B L LS 0 1 G 0 0 1 0: J K L M N O P Q R
B L LS 1 0 G 0 0 1 0: S T U V W X Y Z 0
B L LS 1 1 G 0 0 1 0: 1 2 3 4 5 6 7 8 9
Jeder Zeichenfolge wird immer endlos nach einer kurzen Wartezeit
wiederholt. Einfaches Zuhören reicht, um nach und nach alle Zeichen am
Klang zu unterscheiden. Zwischen den Zeichen gibt es überlange Pausen.
Unwillkürlich denkt man mit und stellt sich das folgende Zeichen
klanglich vor. Im Kopf morst man mit. Aber die lange Pause kann auch
benutzt werden, um das Zeichen mit der Sensortaste selbst zu morsen, in
diesem Fall mit nur einem Finger auf der oberen Kontaktfläche. Damit
ist der direkte Vergleich gegeben. Wenn sich beide Zeichen gleich
anhören, wurde das Zeichen sauber wiederholt. Die Übung kann Gruppe für
Gruppe beliebig oft wiederholt werden.
if (prog == 2) //ABC Ausgabe + Key-Antwort
{
n = 9;
i = 0;
do
{
i = i + speed;
} while (--n);
speed = 1;
n = 9;
do
{
A= i - n;
CW_Code();
CW_out();
Key();
.delay (15000);
} while(--n);
.delay (100000);
}
if (prog == 3) //ABC Ausgabe + Bug-Amtwort
{
n = 9;
i = 0;
do
{
i = i + speed;
} while (--n);
speed = 1;
n = 9;
do
{
A= i - n;
CW_Code();
CW_out();
.delay (10000);
Elbug();
.delay (15000);
} while(--n);
.delay (100000);
}
Das Programm 3: erzeugt ebenfalls alphabetische Zeichenfolgen. Alles
funktioniert wie beim Programm 2, aber mit dem Unterschied, dass man
nun mit der Automatiktaste antworten kann. Am Anfang hört man
vielleicht nur zu. In den verlängerten Pausen morst man dann
automatisch in Gedanken mit oder stellt sich schon das folgende Zeichen
vor. Mein Sohn Fabian versucht gerade, seine alten Morsekenntnisse
wieder aufzufrischen, die er vor Jahren mal bei einem Lehrgang erworben
hat. Er berichtet mir, dass die Übungen gut voran gehen. Er arbeitet
ausschließlich mit der Automatiktaste. Am Anfang hat er immer das
gehörte Zeichen nachgemorst. Inzwischen ist er dazu übergegangen,
in der Pause immer das folgende Zeichen zu morsen. Die Ausgabe des
Controllers bestätigt es dann. Jeder Fehler wird sofort erkennbar. Die
eigenen Zeichen und die des Controllers werden mit unterschiedlicher
Frequenz hörbar, sodass es auch für den Zuhörer ein echter Dilaog wird.
if (prog == 4) //Key-Morsen + Ausgabe
{
do
{
Key();
if (A > 1) {CW_Out();}
} while (PA.5 == 1);
}
if (prog == 5) //Bug-Morsen + Ausgabe
{
Byte b;
do
{
Elbug();
b = A;
.delay (5000);
A = b;
if (A > 1) {CW_Out();}
} while (PA.5 == 1);
}
Es geht auch anders herum. Die Programme 4 und 5 warten jeweils auf ein
Morsezeichen des Operators und senden es dann zurück.
Diesmal kann man wieder die gewünschte Geschwindigkeit zwischen 80 BPM
und 120 PBM einstellen. Die Übung funktioniert mit beliebigen
Morsezeichen, also auch mit solchen, die es gar nicht gibt. Jedes
Zeichen wird so wiederholt, wie der Controller es verstanden hat. Man
wird also dezent auf seine Fehler hingewiesen. Punkte zu lang, Striche
zu kurz, ein Punkt zu viel, man hört sofort, wo der Fehler lag und kann
es sofort noch einmal versuchen.
if (prog == 8 || prog == 9 || prog == 10 ) //CW 5er Gruppen/ + Ziffern / + Sonderzeichen
{
cw_count = 20;
rnd = rnd2;
r = r2;
if ( prog == 8) {code_end= 25;}
if ( prog == 9) {code_end= 35;}
if ( prog == 10) {code_end= 45;}
.delay (20000);
beep();
.delay (20000);
beep();
.delay (40000);
do
{
CW_Gruppe();
.delay (50000);
if (PA.5==0) //Reset-Taster
{
while (PA.5 == 0) {.delay (1000);}
// reset;
r2 = rnd;
cw_count = 1;
}
} while (--cw_count);
.delay (50000);
}
Wer schon alle Zeichen gut kennt, kann sich an die Fünfergruppen mit
den Programmen 8 bis 10 wagen. Während beim Programm 8 nur Buchstaben
gesendet werden, kommen beim Programm 9 auch Ziffern und beim Programm
10 zusätzlich noch Sonderzeichen hinzu. Beim Start hört man zunächst
zwei Punkte, sodass man sich mit Stift und Papier bereitmachen kann.
Dann folgen die 20 Fünfergruppen. Die gesamte Serie wird beliebig oft
wiederholt, sodass man mehrfach die gleichen Gruppen hört und seine
Mitschrift kontrollieren oder fehlende Zeichen ergänzen kann. Es ist
möglich, während der laufenden Übung die Geschwindigkeit zu ändern, was
dann jeweils im folgenden Durchgang wirksam wird. Auf die Weise kann
jeder sich auf eine höhere Geschwindigkeit trainieren. Wenn man aber
beim Ende einer Gruppe auf den Reset-Taster drückt, werden ab da ganz
neue Fünfergruppen gegeben.