Struct welches im Flash liegt an Funktion übergeben

[Tobias B. (horschtx)]

Hallo Hallo,

ich hänge mal wieder an Pointern rum..
Habe da noch so meine schwierigkeiten.

Es gibt aber bestimmt wieder jemand der Helfen kann :)

Ich möchte gerne Daten die als Struct im Flash abgelegt sind an eine 
Funktion übergeben. Je nachdem welche Daten ich verwenden möchte.
Das ganze soll auf einem XMega mit dem AVR Studio laufen.

So habe ich es mal jetzt Probiert.

Das ist das Struct und die Daten.

typedef struct
{
  uint8_t B2[4];
  uint8_t B1[4];
  uint8_t B0[4];
  uint8_t A2[4];
  uint8_t A1[4];
}Filter;



const Filter _50_Hz_TP PROGMEM =  
{{0x00,0x00,0x00,0x0B},
                   {0x00,0x00,0x00,0x16},
                   {0x00,0x00,0x00,0x0B},
                   {0xFF,0x00,0x97,0x7A},
                   {0x01,0xFF,0x68,0x5A}};

Der Funktionsprototyp:

void write_dsp_hp(Filter filter_array);

Die Funktion selber:

void write_dsp_hp(Filter filter_array)
{
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1B2_2, Crossover_BYTE, filter_array.B2);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1B1_2, Crossover_BYTE, filter_array.B1);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1B0_2, Crossover_BYTE, filter_array.B0);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1A2_2, Crossover_BYTE, filter_array.A2);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1A1_2, Crossover_BYTE, filter_array.A1);}

so ruf ich die Funktion auf

write_dsp_hp(_50_Hz_HP);

Ich bekomme es so kompiliert, aber die Daten was ich bekomme sind 
falsch.

Wenn ich das filter_array.x direkt mit _50_Hz_TP.x ersetze funktioniert 
es.

Jetzt bin ich halt gerade an einem Punkt wo ich nicht mehr weiterkomme 
und die Hilfe was mich weiterbringt konnte ich nicht finden.

Danke schön fürs Helfen

Gruß Tobias

[*pointer (Gast)]

Wenn du auf einen Pointer zugreifen willst, musst du auch einen Pointer 
übergeben.

[Tobias B. (horschtx)]

mhh... hab jetzt schon viel probiert, bekomme es aber nicht hin..
vielleicht kann mir ja jemand unter die Arme greifen.

Gruß Tobias

[Stefan F. (Gast)]

Du hast die ganze Struktur als Übergabeparameter definiert. Beim 
Funktionsaufruf werden daher die ganzen Bytes, aus denen die Struktur 
physikalisch besteht, auf den Stack kopiert.

Aber: Dieser Kopiervorgang funktioniert nur, wenn denn die Quelldaten im 
RAM liegen. Tun sie aber nicht.

Deswegen, und auch aus Performancegründen solltest du einen Pointer 
übergeben. Des weiteren musst du den Programmspeicher mit 
pgm_read_byte() lesen.

   void write_dsp_hp(Filter *filter_array) {
     uint8_t temp[4];
     temp[0]=pgm_read_byte(&(filter_array.B2[0]));
     temp[1]=pgm_read_byte(&(filter_array.B2[1]));
     temp[2]=pgm_read_byte(&(filter_array.B2[2]));
     temp[3]=pgm_read_byte(&(filter_array.B2[3]));
     Sigma_block_write(...,  temp);
     temp[0]=pgm_read_byte(&(filter_array.B1[0]));
     temp[1]=pgm_read_byte(&(filter_array.B1[1]));
     temp[2]=pgm_read_byte(&(filter_array.B1[2]));
     temp[3]=pgm_read_byte(&(filter_array.B1[3]));
     Sigma_block_write(...,  temp);
     temp[0]=pgm_read_byte(&(filter_array.B0[0]));
     temp[1]=pgm_read_byte(&(filter_array.B0[1]));
     temp[2]=pgm_read_byte(&(filter_array.B0[2]));
     temp[3]=pgm_read_byte(&(filter_array.B0[3]));
     Sigma_block_write(...,  temp);
     temp[0]=pgm_read_byte(&(filter_array.A2[0]));
     temp[1]=pgm_read_byte(&(filter_array.A2[1]));
     temp[2]=pgm_read_byte(&(filter_array.A2[2]));
     temp[3]=pgm_read_byte(&(filter_array.A2[3]));
     Sigma_block_write(...,  temp);
     temp[0]=pgm_read_byte(&(filter_array.A1[0]));
     temp[1]=pgm_read_byte(&(filter_array.A1[1]));
     temp[2]=pgm_read_byte(&(filter_array.A1[2]));
     temp[3]=pgm_read_byte(&(filter_array.A1[3]));
     Sigma_block_write(...,  temp);
   }

   int main() {
     write_dsp_hp(&_50_Hz_HP);
   }

Der Punkt ist, dass die normalen Speicherzugriffe von C sich immer auf 
das RAM beziehen. Der Programmspeicher wird jedoch über einen anderen 
Bus angesprochen, mit anderen Maschinen-Instruktionen, die C nicht 
beherrscht. Die avr C library stellt daher in avr/pgmspace.h spezielle 
Funktionen zum Lesen des Programmspeichers bereit, die in Assembler 
implementiert wurden. Leider können diese Funktionen nur einfache 
Datentype (byte, integer, etc) lesen. Deswegen musst du den 
Programspeicher "zu fuß" byteweise auslesen und daraus ein neues 
temporäres Array im RAM basteln.

Wenn du denn Quelltext von Sigma_block_write() ändern kann, würde ich 
das dort machen. Eventuell kannst du dann den Kopiervorgang in das 
temporäre Array weg optimieren.

Lesestoff dazu: http://www.nongnu.org/avr-libc/user-manual/pgmspace.html

[Stefan F. (Gast)]

Mir ist gerade noch eingefallen, dass man die vier Bytes auch am Stück 
mit memcp_P() kopieren kann.

[(prx) A. K. (prx)]

In neueren Versionen von GCC (z.B. 4.7.2) geht das deutlich entspannter:

const __flash struct S { int a, b, c, d; } var; // => ROM

extern void f(struct S param);
extern void g(const struct S __flash *param);

void h(void)
{
        f(var); // wird vom ROM zum Stack kopiert
        g(&var); // g() greift direkt auf ROM zu
}

[Bshit (Gast)]

Stefan Us schrieb:
> Der Punkt ist, dass die normalen Speicherzugriffe von C sich immer auf
> das RAM beziehen.

Was n das n für Quatsch? C kennt kein RAM oder ROM.

Du spielst hier auf die Harvard Architektur an, oder?

[(prx) A. K. (prx)]

Bshit schrieb:
> Was n das n für Quatsch? C kennt kein RAM oder ROM.

C ursprünglich nicht, AVRs jedoch schon und die Implementierung von GCC 
auf AVRs mittlerweile auch. Daher kein Quatsch.

> Du spielst hier auf die Harvard Architektur an, oder?

Ja.

[(prx) A. K. (prx)]

Siehe auch hier, insbesondere die universellen Pointer per __memx
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Flash_mit_flash_und_Embedded-C

[Stefan F. (Gast)]

> Du spielst hier auf die Harvard Architektur an, oder?
Ja, ich auch

[Karl H. (kbuchegg)]

Stefan Us schrieb:
> Mir ist gerade noch eingefallen, dass man die vier Bytes auch am Stück
> mit memcp_P() kopieren kann.

Man könnte auch die komplette Struktur mittels memcpy_P in einem Rutsch 
vom Flash ins SRAM kopieren. Nur fürs Protokoll, das würde dann 
beispielsweise so aussehen

const Filter _50_Hz_TP PROGMEM =  
{ {0x00,0x00,0x00,0x0B},
  {0x00,0x00,0x00,0x16},
  {0x00,0x00,0x00,0x0B},
  {0xFF,0x00,0x97,0x7A},
  {0x01,0xFF,0x68,0x5A}
};

void write_dsp_hp(Filter* filterFlash)
{
  Filter filterSRAM;

  memcpy_P( &filterSRAM, filterFlash, sizeof(FilterSRAM) );

  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1B2_2, Crossover_BYTE, filterSRAM.B2);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1B1_2, Crossover_BYTE, filterSRAM.B1);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1B0_2, Crossover_BYTE, filterSRAM.B0);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1A2_2, Crossover_BYTE, filterSRAM.A2);
  Sigma_block_write( DEVICE_ADDR_IC_1, Crossover_HP_1A1_2, Crossover_BYTE, filterSRAM.A1);
}

...
  write_dsp_hp(_50_Hz_HP);
...

Aber egal wie man es dreht und wendet, es muss einen Kopiervorgang vom 
Flash ins SRAM geben. Die von A.K angesprochene Variante mit dem 'neuen' 
__flash Schlüsselwort ist die deutlich eleganteste Lösung dafür. Zum 
einen macht der Compiler dann den Kopiervorgang, wenn auf die 
tatsächlichen Werte zugegriffen wird und zum anderen kann der Compiler 
auch die Weitergabe von Pointer an Funktionen besser überwachen, da 
__flash anders ins Sprachkonzept von C eingebunden ist als die alte 
PROGMEM Lösung, die die Hauptverantwortung für die korrekte Verwendung 
im Code ausschliesslich an den Programmierer abgetreten hatte. Letzters 
ging dann schon auch mal schief.

[Le X. (lex_91)]

Karl Heinz schrieb:
> Man könnte auch die komplette Struktur mittels memcpy_P

Man könnte auch die PROGMEM Krücke in Würde sterben lassen und 
konsequent nur noch __flash verwenden. (Von legacy Projekten mal 
abgesehen).
Und Anfänger auch zur Benutzung dieses auffordern, anstatt ihnen 
Workarounds für den Workaround anzubieten.

[Karl H. (kbuchegg)]

le x. schrieb:

> Und Anfänger auch zur Benutzung dieses auffordern, anstatt ihnen
> Workarounds für den Workaround anzubieten.

Mit welchem Teil meines Postings, das die von A.K. angesprochene und von 
dir propagierte Lösung ebenfalls als die deutlichst bessere Variante 
hervorhebt, bist du nicht einverstanden?

Eventuell benutzt er ja noch (so wie ich) eine gcc Version, die __flash 
noch nicht kann. Spätestens dann muss er wissen was da dahinter steckt, 
so wie es nicht schadet, wenn er auch weiss, dass __flash vom Compiler 
eine andere Behandlung erfordert und es daher zb nicht egal ist, wenn er 
es (so wie manchmal bei einem volatile) einfach wegcastet, bzw. das 
__flash nicht ohne einen Laufzeit-Penalty daher kommt und worin dieser 
besteht.

[Bshit (Gast)]

Karl Heinz schrieb:
> dann muss er wissen was da dahinter steckt,
> so wie es nicht schadet, wenn er auch weiss, dass

... die Havard Architektur getrennte Adressräume für Code und Daten hat. 
Und gleiche Adressen auf unterschiedliche Speicherzellen zeigen (Code / 
Daten). Und dass Variablen ersteinmal im Datenbereich liegen. Und der µC 
auf (konstante) Variblen im Codebereich nicht einfach so zugreifen kann. 
Und ...

http://www.netzmafia.de/skripten/mikrocomputer/harvard.gif
http://de.wikipedia.org/wiki/Harvard-Architektur

[Tobias B. (horschtx)]

So, jetzt funktioniert es.

Danke für die Hilfe und die Denkanstöße. Das hat mir weitergeholfen.