PROGMEN Array in Schleife verarbeiten

[Alex (Gast)]

Habe ein Array im Speicher hinterlegt, mit dem ich später in einer 
Schleife arbeiten möchte. Je nach dem, welchen Wert ich wähle, sollen 
alle vorherigen Werte aufaddiert werden.

Wähle ich also Wert 1 soll 7+3=10 raus kommen. s.u.

const uint8_t MENUSTR[] PROGMEM ={
3, 
7, 
3, 
0, 
};

...
main:

uint8_t sub=0;

//Schleife, die nicht funktioniert:
for(uint8_t j=0; j==1; j++){
sub= &MENUSTR[j] + sub);
}

//soll das gleiche machen:
    
uint8_t j=0;
sub= &MENUSTR[j] + sub;
j++;
sub= &MENUSTR[j] + sub;
//funktioniert

Ich habe nun einfach mit einem festen Wert gearbeitet. Anscheinend kommt 
allerdings bei der Schleife immer der Initialwert von sub heraus. Also 
im Beispiel 0.
Wenn ich direkt hintereinander Schreibe, was die Schleife machen soll, 
funktioniert es allerdings.

Woran denke ich nicht?

Würde mich über Hilfe freuen.

Gruß
Alex

[Stefan E. (sternst)]

Auf Werte im Flash kannst du nicht direkt zugreifen. Du musst sie mit 
den dafür vorgesehenen Funktionen aus dem Flash lesen. Das die eine 
Variante auch mit direktem Zugriff zu funktionieren scheint, liegt 
daran, dass der Optimierer hier gleich die Zugriffe durch die 
entsprechenden Werte ersetzt.

[Bernhard M. (boregard)]

Die Vergleichsbedingung in der for Schleife ist falsch, Du willst wohl:

uint8_t sub=0;

//Schleife, die nicht funktioniert:
for(uint8_t j=0; j<=1; j++){
sub= &MENUSTR[j] + sub);
}

[... .. (docean)]

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29

Wenn es ein AVR + GCC ist, was mir meine Glaskugel sagt... *Zaunpfahl 
wink*

[Stefan E. (sternst)]

Und nachdem ich nochmal drauf geschaut habe, wage ich auch zu 
bezweifeln, dass die funktionierende Variante tatsächlich so mit den '&' 
darin funktioniert.

[Alex (Gast)]

Da sieht mans mal. Den Wald vor lauter Bäumen nicht gesehen. Danke für 
den Anstoß. Vergleichsbedinung war natürlich falsch.

Gruß
Alex

[Alex (Gast)]

Hab dann mal noch angepasst. Die Beiträge habe ich leider erst etwas 
später gesehen.

const uint8_t MENUSTR[] PROGMEM ={
3, 
7, 
3, 
0, 
};

const uint8_t *PTMENUSTR PROGMEM = MENUSTR;

und bei der Schleife

for(uint8_t j=0; j<=1; j++){
    sub= PTMENUSTR+j + sub;
    }

War es so gemeint wegen der automatischen Optimierung?

Gruß
Alex

[Stefan E. (sternst)]

Alex schrieb:

> War es so gemeint wegen der automatischen Optimierung?

Was meinst du mit "automatischen Optimierung"?

Bei der Schleifen-Variante führt kein Weg an den Flash-Funktionen 
vorbei.

[Alex (Gast)]

Ob das die gewünschten Funktionen sind, mit denen man die Werte korrekt 
aus dem Flash liest?

[Stefan E. (sternst)]

Alex schrieb:
> Ob das die gewünschten Funktionen sind, mit denen man die Werte korrekt
> aus dem Flash liest?

Ich sehe in dem Code gar keine Funktionen.

Sieh dir den Link an, den docean gepostet hat.

[gast (Gast)]

wenn du

const char buffer[] PROGMEM = { 1,2,3,4]};

hast


must du mit

char wert=0;
for( char i=0; i<=3 , i++)
  {
    wert += pgm_read_byte( &buffer[i]);
  }


zugreifen


oder so ähnlich ^^ kein plan ob das gehen würde

[Alex (Gast)]

pgm_read_byte klappt allerdings nicht und mit dem Geschriebenen wird 
genau auf die Werte im Array zugegriffen.
Also meine Frage:
Wie wird dieses wegoptimiert, was ich geschrieben habe. Bzw. wie sollte 
der Code aussehen? Aus dem Tutorial konnte ich leider nicht mehr 
gewinnen.

[Stefan E. (sternst)]

Alex schrieb:
> pgm_read_byte klappt allerdings nicht

Dann hast du es falsch benutzt.
Wie sieht dein Code dazu aus?

Und ich verstehe nicht, was du jetzt die ganze Zeit mit dem "Optimieren" 
meinst. Der Optimierer hat nur unbeabsichtigterweise dafür gesorgt, dass 
ein Teil deines Codes zufällig funktioniert hat, obwohl er eigentlich 
fehlerhaft war.

[Alex (Gast)]

uint8_t sub=0;

for(uint8_t j=0; j<=1; j++){
sub= pgm_read_byte(&MENUSTR[j]) + sub;
}

So würde er dann aussehen.

[Stefan E. (sternst)]

Ist richtig. Was genau klappt damit nicht?

[Alex (Gast)]

Es wird nicht der Wert an der Stelle j benutzt sondern irgendwas 
anderes.

In meinem Beispiel:

const uint8_t MENUSTR[] PROGMEM ={
3, 
7, 
3, 
0, 
};

sollte dann an der Stelle j=0 der Wert 3 benutzt werden. Wird er aber 
nicht. Bekomme dann nur komisches Zeug raus. Wenn ich allerdings 
pgm_read_byte weg lasse kommt alles richtig heraus.

Hatte es vorher ja auch mit pgm_read_byte versucht aber dann einfach mal 
weg gelassen. Und es ging.

Gruß
Alex

[Karl H. (kbuchegg)]

Alex schrieb:

> Hatte es vorher ja auch mit pgm_read_byte versucht aber dann einfach mal
> weg gelassen. Und es ging.

Zeig mal dein ganzes Programm mit dem du testest.

[Alex (Gast)]

Steht nicht so viel mehr drin:

#include <stdio.h>
#include <string.h>

// AVR include files
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

//P.Fleury
#include "lcd.h"

uint8_t sub=0;

const uint8_t MENUSTR[] PROGMEM ={
3, 
7, 
3, 
0, 
};


int  main()
{  
DDRG &=(1<<PG2);
DDRA &=(1<<PA4) & (1<<PA5) & (1<<PA6) & (1<<PA7);


//Werden noch nicht benötigt
PORTG |= (1<<PG2);  // Taster Pullups
PORTA |= (1<<PA4) | (1<<PA5) | (1<<PA6) | (1<<PA7); // Taster Pullups




//   LCD Initialisierung
  lcd_init (LCD_DISP_ON);
        lcd_clrscr();

for(uint8_t j=0; j<=1; j++){
    sub= &MENUSTR[j] + sub;
    }

lcd_gotoxy(1,1);

//Hier kann ich die Ergebnisse mit LCD Ausgabe prüfen

if(sub==10){
  lcd_puts("ok");
}else{
  lcd_puts("nicht ok");
}

  for (;;){}
}

[Stefan E. (sternst)]

Sorry, aber das funktioniert so nie und nimmer. Nicht nur, dass der 
richtige Flashzugriff fehlt, du addierst auch Pointer auf. Wenn du ein 
"ok" bekommst, ist das reiner Zufall.

[Karl H. (kbuchegg)]

Tja.
Und aus der Ausgabe 'OK' bzw. 'Nicht OK' kann man so wunderbare 
Rückschlüsse darauf ziehen, was denn das Problem ist. :-)

Warum lässt du dir denn nicht einfach mal sub ausgeben!
Aus dem Zahlenwert sieht man doch viel mehr als aus einer OK/Nicht OK 
Meldung.


for(uint8_t j=0; j<=1; j++){
    sub= &MENUSTR[j] + sub;
    }

Das ist Unsinn!
Du MUSST über pgm_read_byte gehen.
Alles andere kann ev. das Richtige ergeben (weil ja immer an jeder 
Speicherstelle irgendetwas drinnen steht und jedes Teil eine Adresse 
hat), aber das ist dann Zufall!

Und achte ein bischen auf die äußere Form deines Programmes. 
Interessanterweise sind es nämlich meistens die 
Hässlichen-Kraut-und-Rüben Programme, die solch seltsame sporadische 
Fehler aufweisen.

#include <stdio.h>
#include <string.h>

// AVR include files
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

//P.Fleury
#include "lcd.h"

uint8_t sub=0;

const uint8_t MENUSTR[] PROGMEM ={
  3, 
  7, 
  3, 
  0, 
};

void lcd_puti( int number )
{
  char buffer[10];

  itoa( number, buffer, 10 );
  lcd_puts( buffer );
}

int  main()
{  
  DDRG &=(1<<PG2);
  DDRA &=(1<<PA4) & (1<<PA5) & (1<<PA6) & (1<<PA7);

  //Werden noch nicht benötigt
  PORTG |= (1<<PG2);  // Taster Pullups
  PORTA |= (1<<PA4) | (1<<PA5) | (1<<PA6) | (1<<PA7); // Taster Pullups

  //   LCD Initialisierung
  lcd_init (LCD_DISP_ON);
  lcd_clrscr();

  sub = 0;
  for( uint8_t j = 0; j <= 1; j++ ) {
    sub = sub + pgm_read_byte( &MENUSTR[j] );
  }

  lcd_gotoxy( 1, 1 );
  lcd_puti( sub );

  if( sub == 10 ) {
    lcd_puts("ok");
  }
  else {
    lcd_puts("nicht ok");
  }

  for (;;)
  {
  }
}

[Alex (Gast)]

Stimmt. Ich werds mal ausgiebig testen. Werde aber erst nächste Woche 
wieder dazu kommen. Bis hier hin schon mal Danke an alle Helfer.