Pointer auf String im Flash

[Thomas (Gast)]

Hallo,
ich habe ein Problem mit dem zeichenweise auslesen eines Strings aus
dem Flashspeicher eines AVR.
Den Text im Flash habe ich so angelegt:

const char h1[] PROGMEM= "Hallo, ich bin aus dem Flash";

Die Zeichen sollen über die serielle Schnittstelle ausgegeben werden,
was ich bis jetzt so gemacht habe:

for (i = 0; i < strlen_P(h1); i++) {
  zeichen = pgm_read_byte(&(h1[i]));   
  uputchar(zeichen);
}

So funktioniert es. Normalerweise mache ich sowas in einer Funktion mit
Pointerarithmetik, was jedoch nicht funktioniert:

char *ptr_h1;
ptr_h1 = h1;

while (*ptr_h1) {
  zeichen = pgm_read_byte(ptr_h1);  
  uputchar(zeichen);
  *ptr_h1++;
}

Dann werden bei mir teilweise Zeichen gesendet die im String h1 so
nicht drinstehen, aber wieso?

[Timmo H. (masterfx)]

Also die Variable schein ja bekannt zu sein, warum machst du dann nicht
einfach so:

char i=0;
while(hl[i]){
  uputchar(hl[i++]);
}

[Timmo H. (masterfx)]

Ahh sehe es gerade, beim Atmel geht das ja gar nicht. Ihh, hab das bis
jetzt nur mit nem Motorola gemacht da ist das Teilweise besser.

[Timmo H. (masterfx)]

Dein Fehler ist glaub ich die Zeile

*ptr_h1++;

ich weiss jetzt nicht mehr die Priorität, aber ich glaube du
inkrementierst nur den Inhalt des Speicherbereichs (was ja nicht geht).
Also

ptr_h1++;

[Thomas (Gast)]

Irgenwie scheint es einem selber weiterzuhelfen wenn man das Problem
aufschreibt.
Der Fehler liegt bei mir in der Zeile:
while (*ptr_h1)
Das Zeichen kann aus dem Flash ja nur mittels pgm_read_byte ausgelesen
werden. So wie ich es programmiert habe wird er wohl irgendwas aus dem
RAM auslesen bis da zufällig mal eine \0 drinsteht.
Mit

while (zeichen = pgm_read_byte(ptr_h1)) {
  uputchar(zeichen);
  *ptr_h1++;
}

geht es jetzt. Trotzdem Danke.

[Orakel (Gast)]

      while (zeichen = pgm_read_byte(ptr_h1)) {
      uputchar(zeichen);
      *ptr_h1++;
      }

sollte sein

      while (zeichen = pgm_read_byte(ptr_h1)) {
      uputchar(zeichen);
      ptr_h1++;
      }

oder kurz

      while (zeichen = pgm_read_byte(ptr_h1++))
          uputchar(zeichen);

[Thomas (Gast)]

Hm, funktioniert sogar beides, also *ptr_h1++ und ptr_h1++.

[Jörg W. (dl8dtl) (Moderator)]

Bei *ptr_h1++ ist der * nur sinnlos, da er einen Zeiger
dereferenziert, um das Ergebnis danach wegzuwerfen.  Falls
der Zeiger als "volatile" markiert wäre, würde der Compiler
das Dereferenziern sogar wirklich ausführen, so kann er es
wegwerfen.  Wenn er gut ist, schmeißt er noch 'ne Warnung
(computed value is not used oder sowas).

[Thomas (Gast)]

Warnung bekomme ich an dem Punkt keine.
An der Zeile
ptr_h1 = h1;
gibts jedoch ein Warning "assignment discards qualifiers from pointer
target type".
Und dies auch wenn ich mal probeweise den Qualifier const weglasse.

[Werner B. (Gast)]

Typ(const char [] PROGMEM) != Typ(char *);

Da musst du ptr_h1 als PGM_P definieren, dann geht das ohne Warnung.
PGM_P ptr_h1; /* PGM_P: siehe avr/pgmspace.h */

Warum das mit "pgm_read_byte(ptr_h1)" nicht geht ist etwas
komplizierter und liegt daran wie der Flash-Speichertype (und der
Zugriff darauf) über Makros definiert ist. Du solltest hier eigentlich
immer das Format &h1[index] verwenden, auch wenn der index immer fest 0
ist und das Ergebnis aus C Syntax-Sicht identisch ist. Aber wegen der
Art wie AVR-GCC diesen Ausdruck auswertet (und auch muss, sonst würden
es nicht funktionieren) ergibt sich zwingend dieses Format.

      while (zeichen = pgm_read_byte(&ptr_h1[0])) {
         uputchar(zeichen);
         ptr_h1++;
      }

Das ist nur etwas mehr Schreibarbeit, die Effektivität des generierten
Maschinencodes leidet darunter nicht, es wird nicht erst 0 zum Zeiger
addiert.