Funktion soll Zeiger auf Struct zurück liefern

[Christian J. (Gast)]

Hallo,

ist sicher für viele trivial aber nicht, wenn man das noch nicht gemacht 
hat.

Ich habe eine Struktur vom Typ

typedef struct {
  byte  hour,
        min,
    alarms;
} __attribute__((packed)) logfile_t;

und einen Array, der aus einzelnen Elementen dieses Type besteht names 
logfile.

Ich möchte diesen Array nun aus einem EEPROM füllen und dabei wenn es 
geht die Funktion selbst als Rückgabewert benutzen. Also nicht wie im 
Beispiel unten eine Zeigerübergabe bei einer void Funktion.

Geht das überhaupt? Und wenn ja wie? Die 3 Bytes des Struct werden 
einzeln aus dem EE gefüllt.

/* Liest einen Alarm Datensatz aus dem externen EE aus */
void EE_ReadDataSet(logfile_t *ptr, uint16_t nr)
{
  char *p = (char*)ptr;
  uint16_t pos = (nr * sizeof(ptr));
  for (int i = pos; i < (pos + sizeof(ptr)); i++) {
    *p++ = eeprom.readByte(pos);
  }
}

Bisher.... hätte aber gerne *p = EE_ReadDataSet(i);

/* Externes EE auslesen ins RAM */
  logfile_t* p = logfile;
        for (int i = 0; i < logCnt; i++) {
         EE_ReadDataSet(p++,i);
}

[Christian J. (Gast)]

Nur eine Vermutung, kann das derzeit nicht testen. Kompiliert aber 
durch.

/* Liest einen Alarm Datensatz aus dem externen EE aus */
logfile_t EE_ReadDataSet(uint16_t nr)
{
  logfile_t *res;

  uint16_t pos = (nr * sizeof(res));
  for (uint16_t i = pos; i < (pos + sizeof(res)); i++) {
      *(char*)res++ = eeprom.readByte(pos);
  }
  
  return (*res);
}

[mh (Gast)]

Christian J. schrieb:
> Kompiliert aber
> durch.

Ohne Warnungen?

Christian J. schrieb:
> *(char*)res++ = eeprom.readByte(pos);

Es wird ein Byte aus dem EEPROM gelesen. Aber an welche Stelle im 
Speicher (RAM/Register) wird das Byte geschrieben?

[Christian J. (Gast)]

mh schrieb:

> Christian J. schrieb:
>> Kompiliert aber
>> durch.
>
> Ohne Warnungen?
>
> Christian J. schrieb:
>> *(char*)res++ = eeprom.readByte(pos);
>
> Es wird ein Byte aus dem EEPROM gelesen. Aber an welche Stelle im
> Speicher (RAM/Register) wird das Byte geschrieben?

Das brachte den AVR dann auch zum Absturz, vermutlich weil es irgendwo 
hin geschrieben wurde, wo es nicht hin gehörte.

war inzwischen fleissig, das EE angeschlossen statt "trocken" zu 
programmieren, so funktioniert es. Geht sicher immer noch etwas 
optimaler, wenn man noch mehr castet. Aber der GCC fasst das ohnehin 
alles zusammen.

Denkfehler war auch dass sizeof(res) = 2 ist und nicht 3, wie erwartet. 
Also die Länge des Zeigers und nicht die worauf er zeigt.

/* Liest einen Alarm Datensatz aus dem externen EE aus */
logfile_t EE_ReadDataSet(uint16_t nr)
{
  logfile_t res;      // Ergebnis
  char *p = (char*)&res;    // Byte-Zeiger auf Ergebnis
  uint16_t pos = (nr * sizeof(logfile_t));
  
  /* Struct einzeln mit Bytes füllen */
  for (uint16_t i = pos; i < (pos + sizeof(logfile_t)); i++) 
    *p++ = eeprom.readByte(i);
  return (res);
}

[du brauchst immer speicher (Gast)]

Christian J. schrieb:
> /* Liest einen Alarm Datensatz aus dem externen EE aus */
> void EE_ReadDataSet(logfile_t *ptr, uint16_t nr)
> {
>   char *p = (char*)ptr;
>   uint16_t pos = (nr * sizeof(ptr));
>   for (int i = pos; i < (pos + sizeof(ptr)); i++) {
>     *p++ = eeprom.readByte(pos);
>   }
> }

[c]
logfile *EE_ReadDataSet(logfile_t *ptr, uint16_t nr)
{
...
return ptr;
}

[du brauchst immer speicher (Gast)]

Christian J. schrieb:
> logfile_t EE_ReadDataSet(uint16_t nr)
> {
>   logfile_t res;      // Ergebnis

neeee, pointer auf temporäre variable!

[Christian J. (Gast)]

du brauchst immer speicher schrieb:
> logfile *EE_ReadDataSet(logfile_t *ptr, uint16_t nr)

Nope, kompiliert nicht, wenn man aus der Funktion einen Vektor macht.
Wenn dann logfile_t.

logfile_t *EE_ReadDataSet(logfile_t *ptr, uint16_t nr)

[Christian J. (Gast)]

du brauchst immer speicher schrieb:
> neeee, pointer auf temporäre variable!

Also wie?

Das hier läuft ja.... und wie mit * ?

Oh... wurde ja schon geändert das Posting.... logfile_t *ptr braucht es 
aber nicht im Parametersatz. Ein Datensatz ist eindeutig zu finden über 
seine Nummer und hat die Adresse Nummer * Datensatzgröße.

[Christian J. (Gast)]

Macht es eigentlich Sinn die Funktionen allgemein gültig zu halten und 
nicht an einen Typ zu binden?

Lässt sich der Hilfszeiger aus dem Cast

char *p = (char*)target;

noch mit dem

*p++ = eeprom.read(target++);

irgendwie verschmelzen?

Gibt ja die abenteuerlichsten * und ** und & Konstruktionen...

/* Schreibt einen undefinierten Struct weg */
void EE_Ext_WriteData(uint16_t target, void *source, size_t len)
{
  char *p = (char*)source;
  for (uint16_t i = 0; i < len; i++) {
    eeprom.write(target++, *p++);
  }
  
}

/* Beschreibt einen undefinierten Struct mit EE Daten */
void EE_Ext_ReadData (uint16_t eesrc, void *target, size_t len)
{
  char *p = (char*)target;
    for (uint16_t i = 0; i < len; i++) {
      *p++ = eeprom.read(target++);
    }
}

[x^y (Gast)]

Christian J. schrieb:
> Macht es eigentlich Sinn die Funktionen allgemein gültig zu halten und
> nicht an einen Typ zu binden?

Wie immer: It depends. Hier im speziellen würde ich statt "void*" ein 
"uint8_t*" nehmen. Erstens, um klar zu machen, dass es Alignment und 
Padding zu beachten gilt wenn man die Funktion nutzt. Zweitens bezieht 
sich die Länge ja auf etwas und in diesem Fall auf Bytes, also uint8_t.

Die Write Funktion kann ein "const void*" Zeiger bekommen.

[Christian J. (Gast)]

Danke,

ich kriege trotzdem noch die Flöhe, weil das falsche drin steht :-(((
Mann, so schwer ist das doch nicht. Das EE lässt sich einwandfrei 
beschreiben in for Schleifen. Das ist also schon mal ok. Aber der Rest 
ist Murks.

Aufrufe:
EE_Ext_WriteData(logCnt-1, (uint8_t*)&logfile[logCnt-1],sizeof(logfile_t));
      EE_Ext_ReadData(logCnt-1,(uint8_t*)&logfile[logCnt-1],sizeof(logfile_t));


/* Schreibt einen undefinierten Struct weg */
void EE_Ext_WriteData(uint16_t target, uint8_t *source, size_t len)
{
    for (uint16_t i = 0; i < len; i++) {
           eeprom.writeByte(target++, *(source++));
    }
}

/* Beschreibt einen undefinierten Struct mit EE Daten */
void EE_Ext_ReadData(uint16_t eesrc, uint8_t *target, size_t len)
{
       for (uint16_t i = 0; i < len; i++) {
          *(target++) = eeprom.readByte(i);
  }
}

Vorher:
19
8
17
Nachher:
19
19
19

[du brauchst immer speicher (Gast)]

Christian J. schrieb:
> und dabei wenn es
> geht die Funktion selbst als Rückgabewert benutzen

Hast du deine Anfrage vergessen? Wo sind die Rückgabewerte?

Christian J. schrieb:
> Lässt sich der Hilfszeiger aus dem Cast
>
> char *p = (char*)target;
>
> noch mit dem
>
> *p++ = eeprom.read(target++);
>
> irgendwie verschmelzen?

Ja, typisiere source und target und lass p einfach weg.

Christian J. schrieb:
> char *p = (char*)target;
...
>       *p++ = eeprom.read(target++);

Überlege einmal genau was da passiert und welcher Wert in den Variablen 
steckt. :-<<<

Und gib bitte die Deklarationen der beiden eeprom. Funktionen an.

[Christian J. (Gast)]

du brauchst immer speicher schrieb:
> Überlege einmal genau was da passiert und welcher Wert in den Variablen
> steckt. :-<<<

Habe die beiden schon umgeschrieben auf allgemein gültig, also struct 
unabhägig. Gibt immer noch murks. Sehe das Brett vor dem Kopf leider 
nicht.

[du brauchst immer speicher (Gast)]

du brauchst immer speicher schrieb:
> Christian J. schrieb:
>> char *p = (char*)target;

was passiert hier?

[x^y (Gast)]

Christian J. schrieb:
> ich kriege trotzdem noch die Flöhe, weil das falsche drin steht :-(((
> Mann, so schwer ist das doch nicht. Das EE lässt sich einwandfrei
> beschreiben in for Schleifen. Das ist also schon mal ok. Aber der Rest
> ist Murks.

Also mich würde schonmal wundern, warum du "eesrc" gar nicht brauchst 
;-)

[Christian J. (Gast)]

x^y schrieb:
> Also mich würde schonmal wundern, warum du "eesrc" gar nicht brauchst
> ;-)

Das Brett vorm Kopf.... :-) Wenn man zu lange davor sitzt....

/* Schreibt einen undefinierten Struct weg */
void EE_Ext_WriteData(uint16_t target, uint8_t *source, size_t len)
{
    for (uint16_t i = 0; i < len; i++) 
        eeprom.writeByte(target + i, *(source++));
}

/* Liest einen Struct mit EE Daten zurueck*/
void EE_Ext_ReadData(uint16_t eesrc, uint8_t *target, size_t len)
{
    for (uint16_t i = 0; i < len; i++)
       *(target++) = eeprom.readByte(eesrc + i);
}

[x^y (Gast)]

PS: Mal die Warnungen einschalten?