LCD-Anzeige: Verständnisproblem bei einem Pointer

[S. L. (lonci)]

Hallo,

ich habe gerade eine Routine für ein 2-zeiliges (2x16) LCD Display 
(DOGM-Serie) programmiert.

Mit

Disp_String("Hello World");  // Send string to display

übergebe ich eine Zeichenkette an die Funktion

void Disp_String(char *cData)

Als Übergabeparameter habe ich hier einen Pointer auf char. Dieser 
Pointer zeigt auf das erste Zeichen, welches übergeben wurde. Wurde das 
erste Zeichen an das Display übertragen, wird mit  ++ cData;  der 
Pointer um eins erhöht und zeigt somit auf das zweite Zeichen usw.

Verstehe ich das so richtig?


Hier der Code:

void Disp_String(char *cData)
{
  PORTB = (1 << RS); // Data Mode vorbeireiten; setze RS high

  while (*cData)
  {
    SPDR = *cData; // Starte übertragung
    while(!(SPSR & (1<<SPIF)));  // Warte auf ende der Übertragung
    
    //Übertragung abschließen durch RS toggle
    PORTB &= ~(1 << RS); //low
    PORTB = (1 << RS); // high
    _delay_us(50); // warte auf Display
    
    ++ cData;  // increment pointer
  }
}

int main ()
{
  InitSPI();            // SPI init
  InitDisp();            // Display init
  _delay_ms(100);          // Delay for display

  while (1)
  {
    Disp_Clear();        // Clear display
    _delay_ms(10);        // Display delaytime
    dogm_gotoxy(3, 0);      // Cursorposition column 3, row 0
    Disp_String("Hello World");  // Send string to display
    dogm_gotoxy(4, 1);      // Cursorposition column 4, row 1
    Disp_String("2. Zeile");    // Send string to display
    
    for(uint8_t i=0; i<50 ;i++)  // Delaytime 5 seconds
    {
      _delay_ms(100);
    }
  }
}

[Georg G. (df2au)]

Genau so ist es

[S. L. (lonci)]

ok, dann noch eine Frage zu:

while (*cData)
{
  ....
}

*cData ist ja der Pointer. Also führe die Schleife aus solange der 
Pointer "true" ist ?

Wann ist der Pointer nicht mehr "true" bzw. wann ist er überhaupt 
"true"?

[Alram L. (alram)]

streng genommen, heisst es nicht "führe die schleife aus, solange der 
pointer true ist", sondern "führe die schleife aus, solange der inhalt, 
auf den der pointer zeigt, true ist". der stern vor cData macht da den 
unterschied aus.

in c ist generell alles, was nicht 0 ist, true. da am ende des strings 
ein Null-Char zwecks terminierung ist, wird die schleife dort dann 
abbrechen.

vg

[Karl H. (kbuchegg)]

S. Lonci schrieb:

> Wann ist der Pointer nicht mehr "true" bzw. wann ist er überhaupt
> "true"?

Wie Alram schon sagte, der Dereferenzierstern macht den Unterschied. 
Hier wird also nicht der Pointer befragt, sondern das worauf der Pointer 
zeigt.

In C gilt die Regel:
0 wird als logisch falsch gewertet, alles was nicht 0 ist gilt als 
logisch wahr.

Und da kommt jetzt ins Spiel, wie in C Strings aufgebaut sind.
Strings sind nichts anderes als eine Abfolge von Zeichen (die in Form 
ihres ASCII Code gespeichert sind, alles ist in einem Computer letzten 
Endes immer nur eine Zahl), die mit einem 0-Byte abgeschlossen wird.

Hast du also den String
"Hallo World"
dann steht der so im Speicher

    +---+---+---+---+---+---+---+---+---+---+---+---+
    | H | a | l | l | o |   | W | o | r | l | d |\0 |
    +---+---+---+---+---+---+---+---+---+---+---+---+

d.h. eigentlich steht er nicht so im Speicher, sondern die Zeichen 
stehen in Form ihres ASCII Codes dort

    +---+---+---+---+---+---+---+---+---+---+---+---+
    | 48| 61| 6C| 6C| 6F| 20| 57| 6F| 72| 6C| 64| 00|
    +---+---+---+---+---+---+---+---+---+---+---+---+

und es ist genau dieses abschliessende Byte mit dem Wert 0x00 (in 
C-Schreibweise als Zeichen '\0' geschrieben), welches dafür sorgt, dass 
die Schleife hier

  while( *cData )
...

abbricht. Denn ein Wert von 0 (der ja im Speicher ganz hinten im String 
steht und auf den der Pointer irgendwann mal zeigen wird, wenn er 
laufend erhöht wird) gilt ja als logisch falsch. Man könnte die 
Schleifenbedingung auch so formulieren

  while( *cData != '\0' )
...

das wäre genau dasselbe aussagt bzw. macht.
In C ist das oft eine Gratwanderung, ob man den Vergleich != 0 explizit 
hinschreibt oder nicht, denn der ist bei der Auswertung eines Ausdrucks, 
der als Bedingung für irgendwas benutzt wird, sowieso automatisch mit 
drinnen.


BTW:
Teile dir deine Stringausgabefunktion auf

void Disp_Char(char c)
{
  PORTB = (1 << RS); // Data Mode vorbeireiten; setze RS high

  SPDR = c;                    // Starte übertragung
  while(!(SPSR & (1<<SPIF)));  // Warte auf ende der Übertragung
    
  //Übertragung abschließen durch RS toggle
  PORTB &= ~(1 << RS); //low
  PORTB = (1 << RS); // high
  _delay_us(50); // warte auf Display
}
    
void Disp_String(char *cData)
{
  while (*cData)
    Disp_Char( *cData++ );
}

denn eine Funktion die ein einzelnes Zeichen ausgeben kann, ist genauso 
nützlich, wie eine die einen String ausgeben kann.

[Karl H. (kbuchegg)]

    for(uint8_t i=0; i<50 ;i++)  // Delaytime 5 seconds
    {
      _delay_ms(100);
    }

brauchst du nicht so kompliziert machen.
Es gab mal eine Beschränkung für _delay_ms. Aber seit langer, langer 
Zeit ist die aufgehoben. Heute kannst du problemlos ganz einfach

   _delay_ms( 5000 );

schreiben.

[S. L. (lonci)]

@ Karl Heinz: Danke für deine ausführliche Erklärung!

Ich habe noch eine Frage zu den Adressen des Pointers bzw. der 
Pointervariablen.

Beim Debuggen im Atmel-Studio stehen bei mir folgende Werte im RAM:
(siehe Abbildung)

Hier meine eigene Interpretation:

1. Der String "Hello World" steht nach dem flashen im RAM an den 
Adressen 0x0100 bis 0x010B (inkl.0-Byte).

2. Die Pointervariable selbst steht an der Adresse 0x0490. Der Inhalt 
dieser Adresse ist der Wert der Pointervariablen.

Habe ich das so richtig verstanden?