Mal wieder String auf LCD

[Henk (Gast)]

Tag Ihr Leute,

ich komm gleich zur Sache, kay?
Umgebung: ATMEGA16 @8Mhz mit HD44780 im 4Bit Modus mit Data an C0-C3; 
programmierung unter WinAVR, Zeichenausgabe funktioniert mit folgender 
Funktion:

______________________________________________________________________ 
_
void dout(unsigned char data)
{
  unsigned char dbackup=data;  //backup machen
  data=data>>4;      //oberers nibble nach unten
  data=data&0x0F;      //oberes nibble 0
  PORTC=data|(1<<PC4);    //an LCD-Port und RS (PC4) high
  en();        //enable strobe

  dbackup=dbackup&0x0F;    //original char, oberes nibble 0
  PORTC=dbackup|(1<<PC4);    //an LCD-Port mit RS high
  en();        //enable strobe
}
______________________________________________________________________ 
_

Geht alles wie gesagt "wunderbärchen", aber ich kriegs auch NACH googlen 
und  Tutorial- bzw. Forumssuche nicht hin, einen String aufs Display zu 
zaubern. Das wird wohl mit nem char-array[] in verbindung mit sprintf 
und nem zeiger gemacht, aber ich kriegs nicht gebacken.
Für die alten Hasen im Haus (KaHeBu, PeDa & Co.) sind das um drei Uhr 
nachts drei Zeilen in drei Sekunden aber mir könnte es drei Tage des 
langen WE versauen : )

Wenn jemand nen Vorschlag hätte und vielleicht noch was zum Thema 
Fließkomma nach String unter selben Voraussetzungen beizutragen hätte, 
das wär einfach, ja - wie Ostern halt.

Cheers,

Henk

[ARM-Fan (Gast)]

Bin zwar keiner der genannten "Hasen", aber ich kriegs auch hin... ;-)

void LcdString(char * pStr)
{
  while(*pStr)
  {
     dout(*pStr++);
  }
}

void main()
{
  char meinText[] = "Hallo Welt";
  char meinBuffer[10];
  float zahl = 123.45;

  LcdString(&meinText);

  sprintf(&meinBuffer, "Wert: %f", zahl);
  LcdString(&meinBuffer);
}

[ARM-Fan (Gast)]

Sorry, das mit dem sprintf wird in die Hose gehen, weil der "buffer"
mit seinen 10 Zeichen nicht groß genug für das Ergebnis ist.

Aber sollte ja nur ein Beispiel sein... ;-)

[He Ro (Gast)]

Moin,

du solltest die & weglassen, denke ich - denn meinBuffer bzw. meinText 
ist ja schon ein Pointer auf das erste Zeichen des Strings (oder halt 
&(meinText[0]) schreiben - wobei ich denke, man kann hier die Klammern 
auch weglassen)

Wenn man nun die Adresse des Pointers übergibt...

Ohne Gewähr, HeRo

[Robert S. (razer)]

Klammern sind nicht notwendig

[Henk (Gast)]

Yahoo!

Werds direkt morgen ausprobieren...

Besten Dank, ihr Buben!

Henk

[Henk (Gast)]

Funktioniert! Danke nochmal!

[Joachim B. (jojo84)]

Guten Morgen!

Ich benutze einfach mal dieses Thema hier, weil es passt und ich dann 
nicht extra ein neues Thema aufmachen muß :)

Aaalso, ich hab hier ein Pollin-LCD, wo ein nicht ganz standardmäßiger 
Zeichensatz drin ist (wer hätts gedacht ;) ...).

Jetzt möchte ich ein Array als String mit z.B. Umlauten ausgeben. Wo 
sich die Umlaute und so im Speicher des LCD befinden hab ich schon 
rausgefunden. Aber ich krieg da iwie keine hübsche Syntax hin!

Zur Ausgabe von Strings benutze ich die Funktion aus dem Tutorial. Wenn 
ich jetzt z.B. "Zurück" ausgeben will, und das "ü" z.B. an Stelle 0x9A 
im Speicher liegt, muß ich das natürlich explizit an die 
Ausgabe-Funktion übergeben. Da würd ich gern schreiben:

char string_1[] = {"Zur", 0x9A, "ck"};
lcd_string(string_1);

Aber das geht nicht. Da sagt der Compiler:
../menue.c:12: error: (near initialization for 'string_1')
../menue.c:12: error: excess elements in char array initializer
(2x)

Ich muß im Moment schreiben:

char string_1[] = {'Z', 'u', 'r', 0x9A, 'c', 'k'};
lcd_string(string_1);

Aber da tipp ich mir ja nen Wolf! Ich hab schon das Netz durchforstet, 
aber ich find nix geschickteres... :( Hab ihr ne Idee, wie das hübscher 
geht?

Danke,
mfG,

Joachim

[Peter D. (peda)]

char string_1[] = {"Zur" "\x9A" "ck"};
lcd_string(string_1);

Peter

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

"Zur", 0x9A, "ck"
ist gleich
 'Z', 'u', 'r', '\0', 0x9A, 'c', 'k', '\0'
Fällt dir was auf?

Mach doch eine Konvertierung in Echtzeit. Wenn also deine Ausgaberoutine 
ein 'ü' bekommt gibt sie ein 0x9A aus. Das kostet zwar etwas Rechenzeit, 
ist aber an andere Displays problemlos anpassbar.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> char string_1[] = {"Zur" "\x9A" "ck"};
Geht das wirklich? Werden die Strings ohne Terminierung zusammengefasst?

[Stefan B. (stefan)]

char * string_1 = "Zur\232ck"; // \232 ist eine Oktalzahl

[Klaus W. (mfgkw)]

char string_1[] = {"Zur""\x9A""ck"};

Edit: ok, zu spät

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> char * string_1 = "Zur\232ck"; // \232 ist eine Oktalzahl
Was, wenn ich jetzt aber "Menü3" ausgeben will?
char * string_1 = "Men\2323"; // \2323 ist auch eine Oktalzahl

[Klaus W. (mfgkw)]

Lothar Miller schrieb:
> Geht das wirklich? Werden die Strings ohne Terminierung zusammengefasst?

Ja!
Seit K&R werden aufeinanderfolgende Strings vom Compiler zusammengefasst 
und nur der letzte terminiert.

[Klaus W. (mfgkw)]

Lothar Miller schrieb:
>> char * string_1 = "Zur\232ck"; // \232 ist eine Oktalzahl
> Was, wenn ich jetzt aber "Menü3" ausgeben will?
> char * string_1 = "Men\2323"; // \2323 ist auch eine Oktalzahl

Deshalb die zusätzlichen "":

char * string_1 = "Men\232""3";

[Stefan B. (stefan)]

Lothar Miller schrieb:
>> char * string_1 = "Zur\232ck"; // \232 ist eine Oktalzahl
> Was, wenn ich jetzt aber "Menü3" ausgeben will?
> char * string_1 = "Men\2323"; // \2323 ist auch eine Oktalzahl

Probiere es doch mal aus.

[Karl H. (kbuchegg)]

Lothar Miller schrieb:
> "Zur", 0x9A, "ck"
> ist gleich
>  'Z', 'u', 'r', '\0', 0x9A, 'c', 'k', '\0'
> Fällt dir was auf?
>
> Mach doch eine Konvertierung in Echtzeit. Wenn also deine Ausgaberoutine
> ein 'ü' bekommt gibt sie ein 0x9A aus. Das kostet zwar etwas Rechenzeit,
> ist aber an andere Displays problemlos anpassbar.

Ist eine Möglichkeit.
Eine andere sieht so aus

#define CHAR_UE  "\x9A"

...
  char string_1[] = {"Zur" CHAR_UE "ck"};
  lcd_string(string_1);
...

Dann ist ebenfalls die leichte Austauschbarkeit gegeben.

[Klaus W. (mfgkw)]

Makros gross zu schreiben, ist ja gut und schön.
Aber wie willst du jetzt ein großes Ü definieren? :-)

(Nicht schlagen, ich bin schon weg!)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> Seit K&R werden aufeinanderfolgende Strings vom Compiler
> zusammengefasst und nur der letzte terminiert.
An dem Tag muß ich gerade krank gewesen sein... ;-)
Man lernt nie aus...

Stefan B. schrieb:
> Probiere es doch mal aus.
Gesagt, getan. Ergebnis:

   char t1[] = { "Hallo" " " "\"Welt\"" };
   printf("%s\n", t1);

   char t2[] = { "Hallo"" ""Welt" };
   printf("%s\n", t2);

   char t3[] = { "Hallo" " " "Welt" };
   printf("%s\n", t3);

   char t4[] = { "\x48""allo"" ""Welt" };
   printf("%s\n", t4);

   char t5[] = { "\110""allo"" ""Welt" };
   printf("%s\n", t5);

   char t6[] = { "\110allo"" ""Welt" };
   printf("%s\n", t6);

Gibt (mit MSVC++ 6.0)

Hallo "Welt"
Hallo Welt
Hallo Welt
Hallo Welt
Hallo Welt
§ a   b b

Fazit: die Oktalzahl sollte mit einem " terminiert werden... ;-)

[Karl H. (kbuchegg)]

Lothar Miller schrieb:
>> Seit K&R werden aufeinanderfolgende Strings vom Compiler
>> zusammengefasst und nur der letzte terminiert.
> An dem Tag muß ich gerade krank gewesen sein... ;-)
> Man lernt nie aus...

Ja, das wissen viele nicht.
Dabei ist das so praktisch

  char Helptext[] = { "Dies ist ein Helptext\n"
                      "der aus mehreren Zeilen besteht.\n"
                      "Zwecks leichterer Editierbarkeit\n"
                      "wird er an den tatsächlichen Zeilenenden\n"
                      "auch im Editor umgebrochen, damit man auch im\n"
                      "Editor schon ungefähr sieht, wie es nachher\n"
                      "bei der Ausgabe aussehen wird.\n"
                      "\n"
                      "Besonders bei Tabellen oder wenn irgendwelche\n"
                      "Ausrichtungen zu berücksichtigen sind,\n"
                      "ist sowas extrem hilfreich:"
                      "Optionen      Bedeutung\n"
                      "-t            Tab auflösen\n"
                      "-n            kein CR senden\n"
                      "-s            sortiert\n"

[Stefan B. (stefan)]

Lothar Miller schrieb:

> Stefan B. schrieb:
>> Probiere es doch mal aus.
> Gesagt, getan. Ergebnis:
>
>    char t6[] = { "\110allo"" ""Welt" };
>    printf("%s\n", t6);
>
> Gibt (mit MSVC++ 6.0)
> § a   b b
> Fazit: die Oktalzahl sollte mit einem " terminiert werden... ;-)

Seltsam, das kann ich nicht nachvollziehen. GCC (MinGW/MSYS) verhält 
sich beim Beispiel t6 ganz anders (s. Anhang)

[Klaus W. (mfgkw)]

Lothar Miller schrieb:
>> Seit K&R werden aufeinanderfolgende Strings vom Compiler
>> zusammengefasst und nur der letzte terminiert.
> An dem Tag muß ich gerade krank gewesen sein... ;-)
> Man lernt nie aus...

Ich musste mich auch schwer beherrschen, nicht dezent auf
ein C-Buch hinzuweisen :-)
Aber das wäre bei dir erstens ungerecht gewesen, und zweitens
früher oder später auf mich zurück gefallen, wenn ich wieder
einen Bock schieße.

Aber in den Fingern hat es schon ziemlich gejuckt...

[Klaus W. (mfgkw)]

Klaus Wachtler schrieb:
> Seltsam, das kann ich nicht nachvollziehen. GCC (MinGW/MSYS) verhält
> sich beim Beispiel t6 ganz anders (s. Anhang)

Ich habe auch ziemlich fest in Erinnerung, daß bei Hex-Werten
maximal zwei Stellen genutzt werden und der Rest nicht dazu gehört,
und bei Oktalzahlen drei Stellen.
Der gcc 4.3.2 scheint da gelegentlich auch mehr Stellen vernaschen zu
wollen; ich glaube fest, daß sich das Verhalten hier geändert hat -
vielleicht im Zuge der Unicode-Infektion.
Was der Standard dazu sagt (welcher überhaupt?), weiß ich nicht.

Aber in Zukunft wird man wohl ein paar mehr Gänsefüßchen spendieren 
müssen.

[Klaus W. (mfgkw)]

PS: Was macht das Board hier denn falsch?
Ich habe nicht mich selbst zitiert, sondern Stefan B. (stefan).

[Joachim B. (jojo84)]

Ui, das schlug ja ein, wie eine Bombe ;) ...

Auf jeden Fall Dankeschön für die Antworten, das hat geholfen!

Gruß

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Stefan B. schrieb:
> Seltsam, das kann ich nicht nachvollziehen.
Das hat mich stutzig gemacht, und tatsächlich:
ich habe mich selber aufs Glatteis gelegt... :-/

   char t1[] = { "Hallo" " " "\"Welt\"" };
   printf("%s\n", t1);

   char t2[] = { "Hallo"" ""Welt" };
   printf("%s\n", t2);

   char t3[] = { "Hallo" " " "Welt" };
   printf("%s\n", t3);

   char t4[] = { "\x48""allo"" ""Welt" };
   printf("%s\n", t4);

   char t5[] = { "\110""allo"" ""Welt" };
   printf("%s\n", t5);

   char t6[] = { "\110allo"" ""Welt" };
   printf("%s\n", t6);

   char t7[] = { "\60\61""2""\x33""4" }; // = "01234"
   printf("%s\n", t7);

Gibt korrekt:

Hallo "Welt"
Hallo Welt
Hallo Welt
Hallo Welt
Hallo Welt
Hallo Welt
01234

Mit

char t7[] = { "\60\612""\x334" }; // = "01234"

Kommen die Fehler
error C2022: '394' : too big for character
error C2022: '820' : too big for character
Es werden also sowohl bei Oktal- wie auch bei Hexzahlen alle in Frage 
kommenden Ziffern dazugenommen...

EDIT:
>> PS: Was macht das Board hier denn falsch?
Es markiert nur 2 Stellen einer Hex-Zahl als signifikant (s.o. \x33 
lila, die 4 dann rot).

[Andreas F. (aferber)]

Lothar Miller schrieb:
> Mit
>

> char t7[] = { "\60\612""\x334" }; // = "01234"
>

> Kommen die Fehler
> error C2022: '394' : too big for character
> error C2022: '820' : too big for character
> Es werden also sowohl bei Oktal- wie auch bei Hexzahlen alle in Frage
> kommenden Ziffern dazugenommen...

Bei Oktal nach Standard: nö, nicht alle, aber bis zu drei Stellen, wobei 
es nur darauf ankommt, dass das gültige Oktalziffern (0-7) sind, nicht 
ob am Ende noch ein gültiges Zeichen rauskommt (bei 8 Bit i.d.R. \000 
bis \377).

octal-escape-sequence:
        \ octal-digit
        \ octal-digit octal-digit
        \ octal-digit octal-digit octal-digit

Bei Hex: hier werden in der Tat beliebig viele Stellen geschluckt, 
solange es gültige Hexziffern sind.

hexadecimal-escape-sequence:
        \x hexadecimal-digit
        hexadecimal-escape-sequence hexadecimal-digit

Andreas