Morsegenerator

[Thraxas]

Hi, wir sollten in der Schule ein Programm für den Asuro schreiben in dem SOS gemorst werden sollte, ich habe das Programm nun noch weiter ausgebaut, da ich das etwas leingweilig fand. Ich wollte jetzt noch, das man das Wort/der Satz, der gemorst werden soll, im Hyper-Terminal eingibt und er dann gemorst wird. Nur hab ich keine Idee wie ich das machen soll, da ich auch nicht die funktion dafür finde.
Ich benutze das AVR-Studio.

Hier mal mein Code:



/* +---------------------------------+
| |
| Morse-Code-Generator |
| von René Becker |
| |
+---------------------------------+
*/

//---------------------------------------------------------

/* +-----------------+
| | | |
| | Includes | |
| | & | |
| | Defines | |
| V V |
+-----------------+
*/

//---------------------------------------------------------
#include <avr/io.h>
//---------------------------------------------------------
#define sekunden 0.2
#define a blinken(1,1); blinken(1,3);
#define b blinken(1,3); blinken(3,1);
#define c blinken(1,3); blinken(1,1); blinken(1,3); blinken(1,1);
#define d blinken(1,3); blinken(2,1);
#define e blinken(1,1);
#define f blinken(2,1); blinken(1,3); blinken(1,1);
#define g blinken(2,3); blinken(1,1);
#define h blinken(4,1);
#define i blinken(2,1);
#define j blinken(1,1); blinken(3,3);
#define k blinken(1,3); blinken(1,1); blinken(1,3);
#define l blinken(1,1); blinken(1,3); blinken(2,1);
#define m blinken(2,3);
#define n blinken(1,3); blinken(1,1);
#define o blinken(3,3);
#define p blinken(1,1); blinken(2,3); blinken(1,1);
#define q blinken(2,3); blinken(1,1); blinken(1,3);
#define r blinken(1,1); blinken(1,3); blinken(1,1);
#define s blinken(3,1);
#define t blinken(1,3);
#define u blinken(2,1); blinken(1,3);
#define v blinken(3,1); blinken(1,3);
#define w blinken(1,1); blinken(2,3);
#define x blinken(1,3); blinken(2,1); blinken(1,3);
#define y blinken(1,3); blinken(1,1); blinken(2,3);
#define z blinken(2,3); blinken(2,1);
#define wortende mysleep(7*einheit);
#define punkt blinken(1,1); blinken(1,3); blinken(1,1); blinken(1,3); blinken(1,1); blinken(1,3);
//---------------------------------------------------------

/* +--------------------------+
| | | |
| | Unterprogramme | |
| V V |
+--------------------------+
*/
//---Einheit-----------------------------------------------
long einheit = sekunden/0.00000438;
//---------------------------------------------------------

//---mysleep-----------------------------------------------
int mysleep (long sleepdauer)
{
long zaehler;
for (zaehler=0 ; zaehler<=sleepdauer ; zaehler++ )
{
asm volatile ( "nop":: ) ;
}
}
//---------------------------------------------------------


//----Blinken----------------------------------------------
int blinken(int anzahl,int multipl)
{
int xx;
for (xx=0;xx<anzahl;xx++)
{
PORTD = 0b01000000;
mysleep (multipl*einheit);
PORTD = 0b00000000;
mysleep (multipl*einheit);
}
mysleep(3*einheit);
}
//---------------------------------------------------------

/* +-------------------------+
| | | |
| | Hauptprogramm | |
| V V |
+-------------------------+
*/

//---Main--------------------------------------------------
int main ()
{
DDRD = 0b01000000;
while(1)
{
t;e;s;t;wortende;

}
}
//---------------------------------------------------------


Hoffe es kann jemand helfen!

[PicNick]

Du meinst, wie du von einem Terminal-"a" zu .- kommst ?

[radbruch]

Hallo Thraxas

Wenn du die Library des asuros verweden möchtest/darfst, ist es recht einfach:

#include "asuro.h"

#define a blinken(1,1); blinken(1,3);
#define b blinken(1,3); blinken(3,1);
#define c blinken(1,3); blinken(1,1); blinken(1,3); blinken(1,1);

#define x blinken(1,3); blinken(2,1); blinken(1,3);
#define y blinken(1,3); blinken(1,1); blinken(2,3);
#define z blinken(2,3); blinken(2,1);

char einZeichen[] = "#";

int blinken(int anzahl,int multipl)
{
return(0);
}

int main(void)
{
while(1)
{
SerRead(einZeichen,1,0); // warten bis ein Zeichen über IR kommt
SerWrite(&einZeichen[0],1); // Kontrollausgabe zum Terminal
switch (einZeichen[0]) // der erste Index von einZeichen[] ist 0
{
case ('a'): a
case ('b'): b
case ('c'): c
// ...
case ('x'): x
case ('y'): y
case ('z'): z
}
}
return(0);
}

Ohne ist es zäh, UART initialisieren, Empfangsroutine schreiben...

Gruß

mic

[Thraxas]

Vielen Dank radbruch, dann setz ich mich mal noch ein bischen ran.

[Warringer]

Natürlich könnte man auch das Programm so modifizieren, daß der Asuro eine vollständige Zeichenkette einliest und dan nach einem druck auf 'Tab' diese Zeichenkette ausgibt.

So etwas wie dies hier: (Keine Gewähr ob es wirklich so funktioniert...)


#include "asuro.h"

#define a blinken(1,1); blinken(1,3);
#define b blinken(1,3); blinken(3,1);
#define c blinken(1,3); blinken(1,1); blinken(1,3); blinken(1,1);

#define x blinken(1,3); blinken(2,1); blinken(1,3);
#define y blinken(1,3); blinken(1,1); blinken(2,3);
#define z blinken(2,3); blinken(2,1);

char einZeichen[] = "#";
char Zeichenkette[] = "";
uint8_t z1, z2 = 0;

int blinken(int anzahl,int multipl)
{
return(0);
}

int main(void)
{
while(1)
{
while (einZeichen != 0x09)
{
SerRead(einZeichen,1,0); // warten bis ein Zeichen über IR kommt
SerWrite(&einZeichen[0],1); // Kontrollausgabe zum Terminal
z1++;
}
for (z2 = 0; z2 < z1; z2++)
{
switch (einZeichen[z2]) // der erste Index von einZeichen[] ist 0
{
case ('a'): a
case ('b'): b
case ('c'): c
// ...
case ('x'): x
case ('y'): y
case ('z'): z
case (' '): wortende
}
}
}
return(0);
}

[damaltor]

wenn du etwas zeit über hast, und was richtig cooles vorstellen willst, dann versuch mal den asuro sie töne hörbar ausgeben zu lassen. er kann mittlerweile schon musik machen und auch sprechen (ohne lautsprecher!), da werden auch morse-codes gehen.

[Thraxas]

Leider funktioniert der Code von Warringer nicht, weiß villeicht jemand wo der fehler liegt?

[damaltor]

was funktioniert denn nicht?

warringer: ich denke dass ein zeichen lange DEFINES ihn killen könnten. lieber sowas wie MORSE_A oder so

[Warringer]

Ich hab nur den Code von radbruch genommen und ein wenig modifiziert. :p

Aber ich schätze damltor hat Recht mir den längeren Defines.

[Thraxas]

mit den längeren defines funktioniert es leider auch nicht, der code von radbruch funktioniert, nur kann man halt nur ein zeichen senden und nicht eine ganze zeichenkette

[damaltor]

ok..m was funktioniert denn nicht? das compilieren? das flashen? das ausführen? oder macht es einfach nicht das was es soll? wenn es so ist, was macht es dann?

[Thraxas]

Also das compilieren funktioniert ohne error, wenn ich nun z.B. test im hyperterminal eingebe und dann tab drücke passiert garnichts, der asuro blinkt nicht.

[liggi]

du hast das ganze ABC ergänzt und die funktion blinken???

edit: kommt eigentlich irgendwas im terminal zurück?

mfg liggi

[Warringer]

Mist, ich habe einen Fehler in dem Code gemacht... >_<


#include "asuro.h"

#define a blinken(1,1); blinken(1,3);
#define b blinken(1,3); blinken(3,1);
#define c blinken(1,3); blinken(1,1); blinken(1,3); blinken(1,1);

#define x blinken(1,3); blinken(2,1); blinken(1,3);
#define y blinken(1,3); blinken(1,1); blinken(2,3);
#define z blinken(2,3); blinken(2,1);

char einZeichen[] = "#";
char Zeichenkette[] = "";
uint8_t z1, z2 = 0;

int blinken(int anzahl,int multipl)
{
return(0);
}

int main(void)
{
while(1)
{
while (einZeichen != 0x09)
{
SerRead(einZeichen,1,0); // warten bis ein Zeichen über IR kommt
SerWrite(&einZeichen[0],1); // Kontrollausgabe zum Terminal
Zeichenkette[z1] = einZeichen[0];
z1++;
}
for (z2 = 0; z2 < z1; z2++)
{
switch (Zeichenkette[z2]) // der erste Index von einZeichen[] ist 0
{
case ('a'): a
case ('b'): b
case ('c'): c
// ...
case ('x'): x
case ('y'): y
case ('z'): z
case (' '): wortende
}
}
}
return(0);
}

Der müsste funktionieren... theoretisch jedenfalls.

[radbruch]

Hallo

Das war mir schon klar, dass die Erweiterung auf ganze Wörter so nicht funktioniert:

while (einZeichen != 0x09)
{
SerRead(einZeichen,1,0); // warten bis ein Zeichen über IR kommt
SerWrite(&einZeichen[0],1); // Kontrollausgabe zum Terminal
z1++;
}


Wo werden die einZeichen[0] in der

char Zeichenkette[] = "";

eingetragen und wo werden sie wieder ausgelesen?

for (z2 = 0; z2 < z1; z2++)
{
switch (einZeichen[z2]) // der erste Index von einZeichen[] ist 0
{
case ('a'): a


Natürlich könnte ich ein komplettes Programm posten, aber selbst tüfteln macht doch viel mehr Spass. Blöd dass der Herr Morse kein ASCII kannte...

Gruß

mic

*lol* Da war ich mal wieder zu langsam. btw: ich teste meine Codes meist, bevor ich sie anbiete...

Und kompilieren kann ich es auch nicht:

avr-gcc -mmcu=atmega8 -Os -mno-interrupts -funsigned-char -funsigned-bitfields -Wall -Wstrict-prototypes -ggdb -c -DF_CPU=8000000UL -Wa,-acdhlmns=morsen.lst morsen.c -o morsen.o
morsen.c: In function `main':
morsen.c:24: warning: comparison between pointer and integer
morsen.c:43: error: `wortende' undeclared (first use in this function)
morsen.c:43: error: (Each undeclared identifier is reported only once
morsen.c:43: error: for each function it appears in.)
morsen.c:43: error: syntax error before '}' token
make: *** [morsen.o] Error 1

Der Fehler ist ja klar, aber die Warnung ist mir unklar: Wurden die Klammern hinter einZeichen mit Absicht entfernt?

[Warringer]

Was weis ich radbruch... Ich habe den Teil des Codes aus deinem Beispiel...

[radbruch]

Hallo Warringer

Ne, der Code stammt von dir, hier Zeile 24:

while (einZeichen != 0x09)

Du vergleichst den Zeiger auf einZeichen[] (den SerRead() benötigt) mit der Endekennung deines Wortes 0x09. Richtig wäre

while (einZeichen[0] != 0x09)

Aber mit vorherigem Löschen von einZeichen[], sonst wird beim nächsten Wort das letzte 0x09 geprüft und die Schleife nie mehr betreten. Richtig gut (nach meiner Meinung) wäre:

uint8_t z1, z2;

while(1)
{
z1=0;
do
{
SerRead(einZeichen,1,0); // warten bis ein Zeichen über IR kommt
SerWrite(&einZeichen[0],1); // Kontrollausgabe zum Terminal
Zeichenkette[z1] = einZeichen[0];
z1++;
} while (einZeichen[0] != 0x09); // solange Zeichen einlesen bis VT erkannt wird
for (z2 = 0; z2 < z1; z2++)
{

Ich weiß, man kann sich auch verkünsteln...

Noch 'ne Frage: Warum wird das Ende des Wortes mit 0X09 markiert? Das ist ein horizontaler Tab? Wäre cr ('\r') oder newline ('\n') nicht sinnvoller? Eben das, was die Enter-Taste sendet? Viele Wege führen eben auch hier zum Ziel.

Übrigens ist der Wikieintrag zum Morsealphabet (http://de.wikipedia.org/wiki/Morsealphabet) auch lesenswert. Speziell das Kapitel über die Übertragungsrate (WPM) im Zusammenhang mit automatischem Senden der Zeichen.

Noch eine kleine Anmerkung zum Anschluß: An diesem Beitrag habe ich nun fast 40 Minuten gebastelt. Ich hoffe, er ist inhaltlich richtig und halbwegs verständlich formuliert. Das mache ich nicht immer so sorgfältig, aber speziell bei Newbee-Fragen versuche ich es. Und nun gebe ich den Ball wieder ab an Thraxas.

Gruß

mic

[Thraxas]

Vielen Dank schon mal für eure Bemühungen! Werde mir morgen früh mal alles genauer anschauen.

Gruß

René

[Thraxas]

Also der code den radbruch als letztes gepostet hat funktioniert schon mal zum Teil! Wenn ich jetz "sos" morse passiert folgendes, er morst ... - ..- ...- .- - -..- -.-- --.. . (die leerzeilen sind die pausen). Eigentlich sollte aber ... --- ... ankommen. Hat da vielleicht noch jemand eine Idee?

[damaltor]

sind die zeichen denn richtig gespeichert?

[radbruch]

Hallo Thraxas


Hat da vielleicht noch jemand eine Idee?
Bitte immer das Programm zeigen, woher sollen wir den sonst wissen, was das Problem verursacht. Bei kleinen Programmen (so wie deins im Moment) komplett, bei umfangreicheren Programmen ein Ausschnitt, möglichst lauffähig, auf das Problem reduziert.

Gruß

mic

[Thraxas]

Hier der Code:



/* +---------------------------------+
| |
| Morse-Code-Generator |
| von René Becker |
| |
+---------------------------------+
*/

//---------------------------------------------------------

/* +-----------------+
| | | |
| | Includes | |
| | & | |
| | Defines | |
| V V |
+-----------------+
*/

//---------------------------------------------------------
#include <avr/io.h>
#include <asuro.h>

//---------------------------------------------------------
#define sekunden 0.4
//---------------------------------------------------------
#define MORSE_a blinken(1,1,0); blinken(1,3,2);
#define MORSE_b blinken(1,3,0); blinken(2,1,0); blinken(1,1,2);
#define MORSE_c blinken(1,3,0); blinken(1,1,0); blinken(1,3,0); blinken(1,1,2);
#define MORSE_d blinken(1,3,0); blinken(1,1,0); blinken(1,1,2);
#define MORSE_e blinken(1,1,2);
#define MORSE_f blinken(2,1,0); blinken(1,3,0); blinken(1,1,2);
#define MORSE_g blinken(2,3,0); blinken(1,1,2);
#define MORSE_h blinken(3,1,0); blinken(1,1,2);
#define MORSE_i blinken(1,1,0); blinken(1,1,2);
#define MORSE_j blinken(1,1,0); blinken(2,3,0); blinken(1,3,2);
#define MORSE_k blinken(1,3,0); blinken(1,1,0); blinken(1,3,2);
#define MORSE_l blinken(1,1,0); blinken(1,3,0); blinken(1,1,0); blinken(1,1,2);
#define MORSE_m blinken(1,3,0); blinken(1,3,2);
#define MORSE_n blinken(1,3,0); blinken(1,1,2);
#define MORSE_o blinken(2,3,0); blinken(1,3,2);
#define MORSE_p blinken(1,1,0); blinken(2,3,0); blinken(1,1,2);
#define MORSE_q blinken(2,3,0); blinken(1,1,0); blinken(1,3,2);
#define MORSE_r blinken(1,1,0); blinken(1,3,0); blinken(1,1,2);
#define MORSE_s blinken(2,1,0); blinken(1,1,2);
#define MORSE_t blinken(1,3,2);
#define MORSE_u blinken(2,1,0); blinken(1,3,2);
#define MORSE_v blinken(3,1,0); blinken(1,3,2);
#define MORSE_w blinken(1,1,0); blinken(1,3,0); blinken(1,3,2);
#define MORSE_x blinken(1,3,0); blinken(2,1,0); blinken(1,3,2);
#define MORSE_y blinken(1,3,0); blinken(1,1,0); blinken(1,3,0); blinken(1,3,2);
#define MORSE_z blinken(2,3,0); blinken(1,1,0); blinken(1,1,2);
#define MORSE_wortende ownsleep(5*einheit);
#define MORSE_punkt blinken(1,1,0); blinken(1,3,0); blinken(1,1,0); blinken(1,3,0); blinken(1,1,0); blinken(1,3,2);
//---------------------------------------------------------

/* +----------------------+
| | | |
| | Unterprogramme | |
| V V |
+----------------------+
*/
//---Einheit-----------------------------------------------
long einheit = sekunden/0.00000438;
//---------------------------------------------------------

//---Wort/Satz/Buchstabe-----------------------------------
char einZeichen[] = "#";
char Zeichenkette[] = "";
uint8_t z1, z2 = 0;

//---------------------------------------------------------

//---mysleep-----------------------------------------------
int ownsleep (long sleepdauer)
{
long zaehler;
for (zaehler=0 ; zaehler<=sleepdauer ; zaehler++ )
{
asm volatile ( "nop":: ) ;
}
}
//---------------------------------------------------------


//---Blinken-----------------------------------------------
int blinken(int anzahl,int multipl,int endsleep)
{
int xx;
for (xx=0;xx<anzahl;xx++)
{
PORTD = 0b01000000;
ownsleep (multipl*einheit);
PORTD = 0b00000000;
ownsleep (1*einheit);
}
ownsleep(endsleep*einheit);
}
//---------------------------------------------------------

//----Hyperterminaleingabe---------------------------------

//---------------------------------------------------------






/* +----------------------+
| | | |
| | Hauptprogramm | |
| V V |
+----------------------+
*/


//---Main--------------------------------------------------
int main ()
{
DDRD = 0b01000100;
DDRC = 0b00000011;
DDRB = 0b00000000;
char einZeichen[] = "#";
char Zeichenkette[] = "";
while(1)
{

z1=0;
do
{
SerRead(einZeichen,1,0); // warten bis ein Zeichen über IR kommt
SerWrite(&einZeichen[0],1); // Kontrollausgabe zum Terminal
Zeichenkette[z1] = einZeichen[0];
z1++;
}
while (einZeichen[0] != 0x09); // solange Zeichen einlesen bis VT erkannt wird
for (z2 = 0; z2 < z1; z2++)
{

{
switch (Zeichenkette[z2]) // der erste Index von einZeichen[] ist 0
{




case ('a'): MORSE_a
case ('b'): MORSE_b
case ('c'): MORSE_c
case ('d'): MORSE_d
case ('e'): MORSE_e
case ('f'): MORSE_f
case ('g'): MORSE_g
case ('h'): MORSE_h
case ('i'): MORSE_i
case ('j'): MORSE_j
case ('k'): MORSE_k
case ('l'): MORSE_l
case ('m'): MORSE_m
case ('n'): MORSE_n
case ('o'): MORSE_o
case ('p'): MORSE_p
case ('q'): MORSE_q
case ('r'): MORSE_r
case ('s'): MORSE_s
case ('t'): MORSE_t
case ('u'): MORSE_u
case ('v'): MORSE_v
case ('w'): MORSE_w
case ('x'): MORSE_x
case ('y'): MORSE_y
case ('z'): MORSE_z
case (' '): MORSE_wortende
case ('.'): MORSE_punkt

}

}
}
}

return(0);
}


@damaltor: die morsecodes zu den buchstaben stimmen

[Warringer]

Ich hab mir den Code nochmal angesehen und möchte dir vorschlagen, daß du vielleicht die Sleep Funktion der Asuro Lib verwendest und am Angang des Programmes einfach mal Init() aufrufst.

Keine Gewähr für diesen Code.


/* +---------------------------------+
| |
| Morse-Code-Generator |
| von René Becker |
| Modifiziert von Warringer |
| |
+---------------------------------+
*/

//---------------------------------------------------------

/* +-----------------+
| | | |
| | Includes | |
| | & | |
| | Defines | |
| V V |
+-----------------+
*/

//---------------------------------------------------------
#include <asuro.h>

//---------------------------------------------------------
#define sekunden 0.4
//---------------------------------------------------------
#define MORSE_a blinken(1,1,0); blinken(1,3,2);
#define MORSE_b blinken(1,3,0); blinken(2,1,0); blinken(1,1,2);
#define MORSE_c blinken(1,3,0); blinken(1,1,0); blinken(1,3,0); blinken(1,1,2);
#define MORSE_d blinken(1,3,0); blinken(1,1,0); blinken(1,1,2);
#define MORSE_e blinken(1,1,2);
#define MORSE_f blinken(2,1,0); blinken(1,3,0); blinken(1,1,2);
#define MORSE_g blinken(2,3,0); blinken(1,1,2);
#define MORSE_h blinken(3,1,0); blinken(1,1,2);
#define MORSE_i blinken(1,1,0); blinken(1,1,2);
#define MORSE_j blinken(1,1,0); blinken(2,3,0); blinken(1,3,2);
#define MORSE_k blinken(1,3,0); blinken(1,1,0); blinken(1,3,2);
#define MORSE_l blinken(1,1,0); blinken(1,3,0); blinken(1,1,0); blinken(1,1,2);
#define MORSE_m blinken(1,3,0); blinken(1,3,2);
#define MORSE_n blinken(1,3,0); blinken(1,1,2);
#define MORSE_o blinken(2,3,0); blinken(1,3,2);
#define MORSE_p blinken(1,1,0); blinken(2,3,0); blinken(1,1,2);
#define MORSE_q blinken(2,3,0); blinken(1,1,0); blinken(1,3,2);
#define MORSE_r blinken(1,1,0); blinken(1,3,0); blinken(1,1,2);
#define MORSE_s blinken(2,1,0); blinken(1,1,2);
#define MORSE_t blinken(1,3,2);
#define MORSE_u blinken(2,1,0); blinken(1,3,2);
#define MORSE_v blinken(3,1,0); blinken(1,3,2);
#define MORSE_w blinken(1,1,0); blinken(1,3,0); blinken(1,3,2);
#define MORSE_x blinken(1,3,0); blinken(2,1,0); blinken(1,3,2);
#define MORSE_y blinken(1,3,0); blinken(1,1,0); blinken(1,3,0); blinken(1,3,2);
#define MORSE_z blinken(2,3,0); blinken(1,1,0); blinken(1,1,2);
#define MORSE_wortende Msleep(5*einheit);
#define MORSE_punkt blinken(1,1,0); blinken(1,3,0); blinken(1,1,0); blinken(1,3,0); blinken(1,1,0); blinken(1,3,2);
//---------------------------------------------------------

/* +----------------------+
| | | |
| | Unterprogramme | |
| V V |
+----------------------+
*/

//---Einheit-----------------------------------------------
uint16_t einheit = sekunden*1000;
//---------------------------------------------------------

//---Wort/Satz/Buchstabe-----------------------------------
char einZeichen[] = "#";
char Zeichenkette[] = "";
uint8_t z1, z2 = 0;

//---Blinken-----------------------------------------------
int blinken(int anzahl,int multipl,int endsleep)
{
int xx;
for (xx=0;xx<anzahl;xx++)
{
BackLED(ON, ON);
Msleep(multipl*einheit);
BackLED(OFF, OFF);
Msleep(einheit);
}
Msleep(endsleep*einheit);
return(0);
}
//---------------------------------------------------------

//----Hyperterminaleingabe---------------------------------

//---------------------------------------------------------

/* +----------------------+
| | | |
| | Hauptprogramm | |
| V V |
+----------------------+
*/

//---Main--------------------------------------------------
int main ()
{
Init();
while(1)
{
z1=0;
do
{
SerRead(einZeichen,1,0); // warten bis ein Zeichen über IR kommt
SerWrite(&einZeichen[0],1); // Kontrollausgabe zum Terminal
Zeichenkette[z1] = einZeichen[0];
z1++;
}
while (einZeichen[0] != 0x09); // solange Zeichen einlesen bis VT erkannt wird
for (z2 = 0; z2 < z1; z2++)
{
switch (Zeichenkette[z2]) // der erste Index von einZeichen[] ist 0
{
case ('a'): MORSE_a; break;
case ('b'): MORSE_b; break;
case ('c'): MORSE_c; break;
case ('d'): MORSE_d; break;
case ('e'): MORSE_e; break;
case ('f'): MORSE_f; break;
case ('g'): MORSE_g; break;
case ('h'): MORSE_h; break;
case ('i'): MORSE_i; break;
case ('j'): MORSE_j; break;
case ('k'): MORSE_k; break;
case ('l'): MORSE_l; break;
case ('m'): MORSE_m; break;
case ('n'): MORSE_n; break;
case ('o'): MORSE_o; break;
case ('p'): MORSE_p; break;
case ('q'): MORSE_q; break;
case ('r'): MORSE_r; break;
case ('s'): MORSE_s; break;
case ('t'): MORSE_t; break;
case ('u'): MORSE_u; break;
case ('v'): MORSE_v; break;
case ('w'): MORSE_w; break;
case ('x'): MORSE_x; break;
case ('y'): MORSE_y; break;
case ('z'): MORSE_z; break;
case (' '): MORSE_wortende; break;
case ('.'): MORSE_punkt; break;
default: break;
}
}
}
return(0);
}


Möglich daß da die breaks in der Case Unterscheidung gefehlt haben...

Noch ein kleiner Tip, benutze einen einfachen Texteditor um den Code ein wenig leserlicher zu machen wenn, du ihn hier postest.

[Thraxas]

Vielen Dank für die Hilfe, es funktioniert :-)