Eine Funktion elegant mehrmals hintereinander aufrufen

[PIC N. (eigo)]

Hallo zusammen,
ich habe mal eine Frage an die C-Gurus: Gibt es eine Möglichkeit eine 
Funktion in C, welcher immer genau ein Char Wert übergeben wird, 
mehrmals hintereinander elegant in Kurzform aufzurufen?

*Hintergrund*: Ich habe eine Zeichenausgabe für ein GLCD geschrieben und 
ich möchte nicht für jedes Zeichen, dass ich ausgeben möchte, immer 
wieder die Funktion aufschreiben.

Also das man so etwas vereinfachen kann:

GLCD_Schreiben(H);
GLCD_Schreiben(a);
GLCD_Schreiben(l);
GLCD_Schreiben(l);
GLCD_Schreiben(o);

Ich hoffe es ist verständlich was ich meine..
Nabend

[holger (Gast)]

void GlcdText(char *txt)
{
 while(*txt)
  {
   GLCD_Schreiben(*txt);
   txt++;
  }
}


GlcdText("Hallo");

[remote one (Gast)]

mach dir eine zweite Funktion für ganze Zeichenketen:

void GLCD_Schreiben_string (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
        GLCD_Schreiben(*s);
        s++;
    }
}

Hier kannst du nun schreiben

GLCD_Schreiben_string ("Hallo");

[Falk B. (falk)]

@  Nicolas M. (eigo) Benutzerseite

>ich habe mal eine Frage an die C-Gurus:

Bich ich zwar nicht, will aber trotzdem was sagen . . .

>Gibt es eine Möglichkeit eine
>Funktion in C, welcher immer genau ein Char Wert übergeben wird,
>mehrmals hintereinander elegant in Kurzform aufzurufen?

Nennt sich Schleife.

>*Hintergrund*: Ich habe eine Zeichenausgabe für ein GLCD geschrieben und
>ich möchte nicht für jedes Zeichen, dass ich ausgeben möchte, immer
>wieder die Funktion aufschreiben.

Hmm, ist dein C-Buch sooooo schlecht? Oder hast du am Ende gar keins? 
Hmmmm . . .

>GLCD_Schreiben(H);
>GLCD_Schreiben(a);
>GLCD_Schreiben(l);
>GLCD_Schreiben(l);
>GLCD_Schreiben(o);

>Ich hoffe es ist verständlich was ich meine..

Ja.

http://www.mikrocontroller.net/articles/Erweiterte_LCD-Ansteuerung

Schau dir mal die Funktionen lcd_string an und staune.

MfG
Falk

[Klaus W. (mfgkw)]

Mindestens so elegant wie eine Schleife wäre Rekursion :--)

[PIC N. (eigo)]

Okay, das ging schnell =) Dankeschön!

[PIC N. (eigo)]

 void GLCD_Schreiben_string (char *s)
 {
     while (*s)
     {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
         GLCD_Schreiben(*s);
         s++;
     }
}

Ich habe die Variante probiert aber es scheint nicht zu funktionieren. 
Liegt es evtl. daran, dass ich mit dem T6963c arbeite und ich nicht 'A' 
schreibe sondern A, da ich zuvor das A definiert habe mit 0x21 (ist ja 
der interne Zeichensatz vom Controller)?

[Peter (Gast)]

Nicolas M. schrieb:
> Ich habe die Variante probiert aber es scheint nicht zu funktionieren.
> Liegt es evtl. daran, dass ich mit dem T6963c arbeite und ich nicht 'A'
> schreibe sondern A, da ich zuvor das A definiert habe mit 0x21 (ist ja
> der interne Zeichensatz vom Controller)?

dann zeig doch mal den code den du geschrieben hast.

[holger (Gast)]

>Liegt es evtl. daran, dass ich mit dem T6963c arbeite und ich nicht 'A'
>schreibe sondern A, da ich zuvor das A definiert habe mit 0x21 (ist ja
>der interne Zeichensatz vom Controller)?

Schreib den Text ganz normal.

void GlcdText(char *txt)
{
 while(*txt)
  {
   GLCD_Schreiben(*txt - 0x20);
   txt++;
  }
}


GlcdText("Hallo");

[Spess53 (Gast)]

Hi

>da ich zuvor das A definiert habe mit 0x21 (ist ja
>der interne Zeichensatz vom Controller)?

Hättest du dir sparen können. Einfach an geeigneter Stelle 0x20 vom 
ASCII-Zeichen abziehen und du kannst normale Zeichen übergeben.

MfG Spess

[PIC N. (eigo)]

Okay. Ich habe den Code (oben) genommen:

void GLCD_Schreiben_String (char *S)
{
    while (*S)
    {   
        GLCD_Schreiben(*S);
        S++;
    }
}

Und habe jetzt versucht "Hallo" auszugeben:

  GLCD_Schreiben_String("Hallo");

Da ich den T6963c ansteuere, welche ja iwie nicht so richtig ASCII treu 
ist oder wie auch immer man das nennen mag. Habe ich z.B. die Buchstaben 
vorerst einmal definiert (nur zum Testen). Und habe die dann einzeln 
ausgegeben:

#define H 0x28
...

Und vorher hab ich sie eben so ausgegeben:

GLCD_Schreiben(H);

Und nicht so:

GLCD_Schreiben('H');

[PIC N. (eigo)]

Spess53 schrieb:

> Einfach an geeigneter Stelle 0x20 vom ASCII-Zeichen abziehen
> MfG Spess

Danke!

[PIC N. (eigo)]

Tut mir Leid aber irgendwas scheint noch schief zu laufen. Es wird beim 
String nichts dargestellt. Hier mein Code:

Unterprogramm für die Zeichenkette:

void GLCD_Zeichenkette (unsigned char *Text)
{
    while (*Text)
    {   
        GLCD_Schreiben(*Text);
        Text++;
    }
}

Unterprogramm für die Ausgabe:

void GLCD_Schreiben (unsigned char Zeichen)
{
  unsigned char ASCII;  

  // Wird eine 0 gesendet, dann direkt ausgeben
  // Zum Beispiel beim Display löschen.. 
  if(Zeichen==0)          
  {
    GLCD_Daten   (Zeichen);
    GLCD_Befehl  (0xC0);    
  }

  // Wenn ein ASCII Zeichen gesendet wird, dann
  // die Information um 32 verringern (T6963c)
  else
  {
    ASCII = Zeichen-0x20;
    GLCD_Daten   (ASCII);
    GLCD_Befehl  (0xC0);
  }
}

Und so klappt es nicht mit der Ausgabe:

  GLCD_Zeichenkette("Hallo");

So schon:

  GLCD_Schreiben('H');

PS: Compiler ist C18

[Karl H. (kbuchegg)]

Nicolas M. schrieb:

> PS: Compiler ist C18

Kann es sein, dass das wieder so ein Müll ist von wegen: Zeichenketten 
werden ganz woanders gespeichert, nur nicht im RAM?

[holger (Gast)]

>Kann es sein, dass das wieder so ein Müll ist von wegen: Zeichenketten
>werden ganz woanders gespeichert, nur nicht im RAM?

Könnte schon sein;)

Hier mal eine uralte Routine aus meinen PIC Zeiten (auch für T6963):

void LCDText(const rom char *txt)
{
 char ps;

 while(ps = *txt)
  {
   txt++;
   WriteData1(ps,0xC0);
  }
}

Das besondere ist wohl das "const rom".

[PIC N. (eigo)]

Funktioniert! Kann mir jemand erklären warum? ^^

[holger (Gast)]

>Funktioniert! Kann mir jemand erklären warum? ^^

So langsam dämmert es wieder;)

Beispiel:

LCDWriteText("Hallo");

"Hallo" ist hier beim C18 ein konstanter Text im ROM (Flash).
Das dumme daran ist das man das dann so nicht mehr machen kann:

char buffer[egal];
LCDWriteText(buffer);

buffer liegt im RAM. Der Datentyp "const rom" stimmt dann nicht.
Es wird eine zweite Routine benötigt die dann Text aus dem RAM
anzeigen kann.

Beim AVR-GCC ist es genau umgekehrt:

LCDWriteText("Hallo");

"Hallo" liegt im RAM. Für Texte aus dem ROM (Flash) wird eine
andere Routine die Texte per pgm_read_byte() ausgiebt benötigt.