PROGMEM Array an Funktion übergeben

[Heribert B (Gast)]

Hallo,

ich hab ein Led-Pattern

const uint8_t pattern PROGMEM = {0, 255, 255, 0, 255, 255, 0, 0};

welches ich an einer Funktion übergeben möchte. Angesteuert werden damit 
2 Leds. Bekomme das irgendwie nicht hin.

func(pattern);

void func(const uint8_t *pattern)
{
static uint8_t step = 0;

// falls ein pattern nicht ausreicehnd groß ist
if(sizeof(pattern) > step) step = 0;

ledvalue1 = pgm_read_byte(&pattern[step]);
ledvalue2 = pgm_read_byte(&pattern[(step+1);

step++;
}

[Schrumpfkopf (Gast)]

>Bekomme das irgendwie nicht hin.

Das ist höchst bedauerlich.

Wenn Du allerdings Hilfe erwartest, solltest Du das Ist- und 
Sollverhalten genauer beschreiben.

Wolltest Du vielleicht statt

>step++;

nicht eher

step += 2;

schreiben?

[Heribert B (Gast)]

So, hab noch ein bisschen getüfftelt.
Jedoch habe ich noch ein paar Probleme. Zum einen meckert der Compiler
'__progmem__' attribute ignored
Des weiteren kann ich mit sizeof(pattern) nicht die Größe auslesen. 
Ergebnis ist immer 1.

const uint8_t pattern PROGMEM = {0, 255, 255, 0, 255, 255, 0, 0};

func(pattern);

void func(const uint8_t *pattern)
{
static uint8_t step = 0;
uint8_t sizePattern = sizeof(pattern)/sizeof(pattern[0]);
ledValue1 = pgm_read_byte(patter[step]);
step++;
}

[Tom (Gast)]

Bei der Übergabe an die  Funktion wird ein Array zu einem ordinären 
Pointer. Du musst also die Größe in main berechnen und mit übergeben.


http://c-faq.com/aryptr/index.html

[DirkB (Gast)]

Heribert B schrieb:
> Des weiteren kann ich mit sizeof(pattern) nicht die Größe auslesen.
> Ergebnis ist immer 1.

Das sind absolute C-Grundlagen. Wenn das in deinem Tutorial/Buch nicht 
drin steht, dann entsorge dies und bedenke, dass da noch mehr 
Fehlinformationen drin sind.

Heribert B schrieb:
> func(pattern);
>
> void func(const uint8_t *pattern)

Bei der Deklaration sollte der Rückgabetyp mit angegeben werden, da 
sonst implizit int angenommen wird.
Desweiteren ist der Paramtername egal. Der Typ ist wichtig.
(Der Name hilft aber etwas als Dokumentation (wenn er gut gewählt ist)

void func(const uint8_t *pattern);

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

Heribert B schrieb:
> So, hab noch ein bisschen getüfftelt.
Verwende bitte in Zukunft die passenden Tokens um den C-Code (wie knapp 
über der Edit-Box beschrieben):

[c]
  C-Code
[/c]

[Ulrich P. (uprinz)]

Das Problem sind die Grundlagen...

Zuerst beschreibe doch, was Du erreichen willst:

typedef struct {
  uint8_t pattern;
  uint8_t value;
} tPATTERN;

Jetzt kennt der Compiler auch die Größe eines Elements Deines Arrays. 
Damit legst Du ein Array aus vielen Elementen dieser Art an:

const tPATTERN pattern[] = { 
  { 0, 255 },
  { 255, 0 },
... };

Nun, da der Compiler weiß, wie ein Element aussieht, kann er auch die 
Anzahl der Elemente bestimmen, ganz dynamisch zur Compile-Zeit:

#define PATTERNS (sizeof(pattern) / sizeof(pattern[0]))

Da Du Deiner Funktion nun einen Pointer auf ein Element bekannter Größe 
übergeben kannst, kann innerhalb der Funktion auch der Compiler selbst 
die korrekte Schrittweite der Pointer bestimmen:

void blubb( const tPATTERN *pattern) {
  static npat = 0;
  
  ledvalue1 = pgm_read_byte(&pattern[step]->pattern);
  ledvalue2 = pgm_read_byte(&pattern[step]->value);

  step++;
  if (step == PATTERNS) step = 0;
}

Ich persönlich finde, dass man gerade als Anfänger erst einmal 
ausführliche structe ausdenken und diese dann konsequent verwenden 
sollte, bevor man Assembler-artigen Code schreibt, den man selbst nach 
ein paar Tagen Pause nicht mehr versteht.
Außerdem bitte hier im Wiki noch mal nachlesen, einige dieser 
pgm_read_byte sind eventuell nicht mehr nötig, weil moderne AVRGCC 
Versionen das im Hintergrund erledigen können.

[Carl D. (jcw2)]

Heribert B schrieb:
>

> const uint8_t pattern PROGMEM = {0, 255, 255, 0, 255, 255, 0, 0};
> 
> func(pattern);
> 
> void func(const uint8_t *pattern)
> {
> static uint8_t step = 0;
> uint8_t sizePattern = sizeof(pattern)/sizeof(pattern[0]);
> ledValue1 = pgm_read_byte(patter[step]);
> step++;
> }
>

Das grundlegendste Problem an diesem Stück Code ist, daß dem Array die 
[] fehlen.

> Des weiteren kann ich mit sizeof(pattern) nicht die Größe auslesen.
> Ergebnis ist immer 1.

Siehe oben.

[Falk B. (falk)]

@  Heribert B (Gast)


>const uint8_t pattern PROGMEM = {0, 255, 255, 0, 255, 255, 0, 0};

>welches ich an einer Funktion übergeben möchte. Angesteuert werden damit
>2 Leds. Bekomme das irgendwie nicht hin.

Wenn man schon einen aktuellen Compiler hat (Atmelstudio mit avr gcc?), 
dann kann man es auch ein wenig komfortabler machen.

https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Flash_mit_flash_und_Embedded-C

const __flash uint8_t pattern= {0, 255, 255, 0, 255, 255, 0, 0};

void func(const __flash uint8_t *pattern);


void func(const __flash uint8_t *pattern) {
  static uint8_t step = 0;

  if(step >= sizeof(pattern) ) step = 0;
  ledvalue1 = pattern[step];
  ledvalue2 = pattern[step+1];
  step++;
}

[Carl D. (jcw2)]

Warum nicht einfach mal so versuchen:

const __flash uint8_t pattern[] = {0, 255, 255, 0, 255, 255, 0, 0};

void func(const __flash uint8_t *pattern);


void func(const __flash uint8_t *pattern) {
  static uint8_t step = 0;

  if(step >= sizeof(pattern) ) step = 0;
  ledvalue1 = pattern[step];
  ledvalue2 = pattern[step+1];
  step++;
}

mit Array!

Hat eigentlich der GCC sich nie über die Initialisierung von pattern 
beschwert?

[Falk B. (falk)]

2 Dumme, 1 Gedanke ;-)