AVR-GCC: const __flash struct mydata_t *[4]

[Walter T. (nicolas)]

Hallo zusammen,
ich habe ein großes Struct, daß mir empfindlich viel SRAM wegnimmt. 
Deswegen will ich es in den Flash verlegen. Dummerweise komme ich so 
langsam mit den Datentypen ins Schleudern. Zum Testen habe ich ein 
kleines Mock-up gemacht:

// Struct und seine Inhalte
void dummyfkt(void) {
  glcd_putstr_P(PSTR("Ich schreibe also bin ich"));
  glcd_drawnow();  
}

int16_t dummyvar = 0;  

const __flash char TEXT1[] = "Hallo";
const __flash char TEXTN[] = {'\0'};

typedef struct {
  const __flash char *text;
  voidFcn_t fktpointer; 
  int16_t *numvar;
} mydata_t;  

 const __flash mydata_t DAT_TESTS[] = {
   {TEXT1,dummyfkt,&dummyvar},
   {TEXT1,dummyfkt,&dummyvar},
   {TEXT1,dummyfkt,&dummyvar},
   {TEXTN,NULL,NULL}, // Nullzeile markiert Ende des structs
 };

// Test
void test(const __flash mydata_t *(data[])) {
 
  snprintf_P(glstr_Buf,N_TEXTBUF,PSTR("hallo"));
  glcd_putstr(glstr_Buf);
  glcd_drawnow();

  voidFcn_t fkt;
  fkt = data[1]->fktpointer;
  fkt(); // Geht schief

  snprintf_P(glstr_Buf,N_TEXTBUF,&(data[1]->text)); // Geht auch schief
  glcd_putstr(glstr_Buf);
  glcd_drawnow();
}

// Aufruf
void wirdvonmainaufgerufen(void) {
  test(&DAT_TESTS);
}

Wie man sieht, enthält das struct Funktionszeiger, Zeiger auf globale 
Variablen und Zeiger auf Text im Flash. So ganz sicher bin ich mir noch 
gar nicht, welche Teile sich davon überhaupt im Flash speichern lassen.

Und ich bin gerade völlig ratlos: Wie dereferenziert man richtig einen 
Zeiger in einem Struct im Flash auf einen String im Flash?

Viele Grüße
W.T.

[Karl H. (kbuchegg)]

Walter Tarpan schrieb:

> void test(const __flash mydata_t *(data[])) {

Die Funktion kriegt ein Array von Pointern?
Bist du dir da sicher, dass du das willst?

Hmm.
Du verwendest es hier

fkt = data[1]->fktpointer;

fast richtig (wir fangen bei 0 zu zählen an und nicht bei 1). Ich denke 
aber trotzdem nicht, dass das das ist, was du eigentlich wolltest. Und 
zwar wegen dem hier

  test(&DAT_TESTS);

Grundsätzlich.
Du kannst ein Array auf 2 verschiedenen Schreibweisen übergeben.

Entweder in Pointer-Syntax

void foo( int *arg )
{
  arg[0] = 5;
  arg[1] = 6;
}

int main()
{
  int val[2];

  foo( val );
}

oder mit Array Schreibweise

void foo( int arg[] )
{
  arg[0] = 5;
  arg[1] = 6;
}

int main()
{
  int val[2];

  foo( val );
}

Beides ist gleichwertig und bewirkt auch dasselbe.
Aber du willst die Dinge hier nicht mischen. Das hier

void foo( int *(arg[]) )
{
  arg[0] = 5;
  arg[1] = 6;
}

int main()
{
  int val[2];

  foo( &val );
}

macht etas komplett anders und wird auch in einem komplett anderen Fall 
benötigt. zb dann, wenn du mehrere Arrays hast, deren Adressen du in 
einem weiteren Array einträgst und du dann dieses Pointer Array an eine 
Funktion übergibst.

Ich denke nicht, dass du das hier willst.

Also: nicht so kompliziert

const __flash mydata_t DAT_TESTS[] = {
   {TEXT1,dummyfkt,&dummyvar},
   {TEXT1,dummyfkt,&dummyvar},
   {TEXT1,dummyfkt,&dummyvar},
   {TEXTN,NULL,NULL}, // Nullzeile markiert Ende des structs
 };

void test(const __flash mydata_t data[]) {

...
}

void wirdvonmainaufgerufen(void) {
  test( DAT_TESTS );
}

dann klappt es auch mit dem Zugriff.
Und da du in der Funktion ein Array von mydata_t Objekten hast, ist ein 
Objekt von diesem Array zum Beispiel der

   data[1]

Da es sich dabei um ein komplettes mydata_t Objekt handelt (es ist ja 
ein Objekt aus dem ganzen Array), wird ein Member von diesem Objekt, zum 
Beispiel der fktpointer, mit der ganz normalen . Notation angesprochen. 
Der fktpointer vom data[1] ist daher

   data[1].fktpointer

Das wäre dann der hier

const __flash mydata_t DAT_TESTS[] = {
   {TEXT1,dummyfkt,&dummyvar},
   {TEXT1,dummyfkt,&dummyvar},                <-------------
   {TEXT1,dummyfkt,&dummyvar},
   {TEXTN,NULL,NULL}, // Nullzeile markiert Ende des structs
 };

> Wie man sieht, enthält das struct Funktionszeiger, Zeiger auf globale
> Variablen und Zeiger auf Text im Flash. So ganz sicher bin ich mir noch
> gar nicht, welche Teile sich davon überhaupt im Flash speichern lassen.

passt schon.
Das sind alles Zeiger. Solange sie nicht auf irgendwas anderes zeigen 
können müssen, ist das ok.

[Walter T. (nicolas)]

Hallo Karl-Heinz,
wie schaffst Du das nur, so schnell eine Übersicht in mein 
undurchsichtiges verzeifeltes herumprobieren zu bringen und dann auch 
noch die Geduld zu haben, das wirklich zu machen?

Der Compiler warnt mich zwar bei

test(&DAT_TESTS);

 mit "passing argument 1 of 'test' from incompatible pointer type", aber 
das wird jetzt gnadenlos mit

test( (const __flash mydata_t *) &DAT_TESTS);

unterdrückt.

Vielen Dank für Deine Hilfe!
W.T.

EDIT: Wahnsinn! Ich habe gerade fast 500 bytes Stack geschenkt bekommen! 
Und nochmals Danke!

[Karl H. (kbuchegg)]

Walter Tarpan schrieb:

>

> test( (const __flash mydata_t *) &DAT_TESTS);
>

Das & da drinnen ist hoffentlich nur ein Tippfehler hier im Forum.
Das gehört da nicht hin

Falls nicht:
Und wenn du es dann weg gibst, dann kannst du auch den Cast wieder raus 
nehmen.

-> Du hast auf die Fehlermeldung falsch ragiert. Der Cast war nicht die 
Lösung, um auf das Problem zu reagieren, das der Compiler angemerkt hat.


Siehe hier

void foo( int arg[] )
{
  arg[0] = 5;
  arg[1] = 6;
}

int main()
{
  int val[2];

  foo( val );
}

an dieser Stelle, beim Funktionsaufruf, fungiert der Name des Arrays 
bereits als seine Adresse im Speicher. Perfekt passend, um in der 
Funktion in einer Pointervariablen (die hier durch die Array Syntax 
verschleiert wurde) gespeichert zu werden. Da braucht es kein &. Ganz im 
Gegenteil: es ist definitiv falsch, auch wenn manche Compiler das 
stillschweigend korrigieren.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> -> Du hast auf die Fehlermeldung falsch ragiert. Der Cast war nicht die
> Lösung, um auf das Problem zu reagieren, das der Compiler angemerkt hat.

Wenn es um Pointer geht, dann ist eigentlich meistens ein Cast NICHT die 
Lösung um auf eine Datentypunverträglichkeit (die jetzt nicht auf 
volatile oder const zurückzuführen ist) zu reagieren. Wenn dir der 
Compiler eine Datentypunverträglichkeit im Zusammenhang mit Pointern 
meldet, dann ist das ein ernst zu nehmendes Problem - den Compiler mit 
einem Cast ruhig zu stellen ist in 99% aller Fälle die meistens falsche 
Lösung. Es ist wie das Überkleben der Öl-Warnung im Auto mit Klebeband. 
Das die Lampe leuchtet siehst du nicht mehr. Aber deswegen hat sich das 
Problem im Ölkreislauf ja nicht gelöst.

[Walter T. (nicolas)]

Du hast Recht! Das habe ich in der Euphorie, daß in der Funktion, die 
das große struct bearbeitet, nichts außer dem Header geändert werden 
muß, übersehen.

[Torsten C. (torsten_c)]

typedef struct {
  const __flash char *text;
  voidFcn_t fktpointer; 
  int16_t *numvar;
} mydata_t;

Aber so ein "Gemisch" geht nicht, oder kann ich was dazu lernen? 
Manchmal wär's ganz praktisch.

[Walter T. (nicolas)]

Warum nicht? Es sind alles Zeiger auf zur globale Variablen, also zur 
Kompilier-/Linkerzeit bekannt.