Struct mit Schleife durch zählen

Schau dir zum Thema "Welches element einer struct bekommt welchen Teil 
des Speichers" nochmal ein paar Tuts an.
Ansonsten kann ich mich meinen Vorredner nur anschließen.

Hallo!

@Wolfgang

Vielen Dank für die Hinweise. Dann werde ich es so lassen wie ich es 
jetzt habe, da schreibe ich jede Variable einzeln. Ich dachte man könnte 
es so ein wenig vereinfachen und schneller machen. Gerade weil in der 
Struktur noch ein paar Arrays sind.

Danke

Denny

Und wenn deine Struktur wirklich so aussieht und da nicht auch noch was 
dazukommt, solltest du die Idee mit den union noch einmal überdenken. 
Diese 3 union bringen nichts ausser Konfusion.

Hallo!

@ Karl heinz Buchegger

Wie kann man dann soetwas lösen mit den Unions?


Gruß Denny

Also ich weise dem Double in der Union meine gemessene Temperatur zu und 
dann schreibe ich aus dem Array die einzelnen Bytes in ein I2C Epprom.

Kann man das auch anders lösen?


Gruß Denny

Über den double solltest du aich noch einmal nachdenken.

Ist es wirklich notwenidig, dir Temperatur auf 5 Nachkommastellen zu 
halten. Ist es wirklich notwendig Temperaturen in der Größenordnung von 
ein paar Millionen halten zu können?

Oder ist es nicht eher so, dass 1 Nachkommastelle mehr als ausreichend 
ist? Kannst du überhaupt so genau messen?

Du könntest zb mit dir vereinbaren, dass dein Pgm die Temperatur in 
Zehntelgrad speichert. Ein Wert von 231 wären dann 23.1 Grad. Dann ist 
ein int völlig ausreichend.

> Oder ist es nicht eher so, dass 1 Nachkommastelle mehr als ausreichend
> ist? Kannst du überhaupt so genau messen?
>
> Du könntest zb mit dir vereinbaren, dass dein Pgm die Temperatur in
> Zehntelgrad speichert. Ein Wert von 231 wären dann 23.1 Grad. Dann ist
> ein int völlig ausreichend.

Ja eine stelle nach dem Komma ist völlig ausreichend.

1

unsigned int temp1;

2

3

temp1 = (unsigned int)(temperatur * 10);

Wäre das so richtig?

Hat einer mal ne Seite wo das mit dem Casten genau steht? Habe ich noch 
nicht ganz verstanden.

Danke
Gruß Denny

Dem Compiler ist nach C-Standard nicht erlaubt, struct-Mitglieder 
umzusortieren.  Sie müssen in der vorgegebenen Reihenfolge angeordnet 
sein.  Das Padding kann verhindert werden, indem das Attribut 'packed' 
mitgegeben wird (bei WinAVR sind structs bereits implizit gepackt, wer 
ganz sicher gehen will gegen zukünftige Änderungen, schreibt das 
Attribut noch dazu).  Somit ist es völlig OK, die struct byteweise 
einzulesen und rauszuschreiben, solange man innerhalb derselben 
Architektur bleibt.

Die Warnungen gegen ein Umordnen sind gut gemeint, aber nicht 
zutreffend.

Hazeh Zimmerer schrieb:
> Dem Compiler ist nach C-Standard nicht erlaubt, struct-Mitglieder
> umzusortieren.  Sie müssen in der vorgegebenen Reihenfolge angeordnet
> sein.  Das Padding kann verhindert werden, indem das Attribut 'packed'

Kannst du mir das mit dem "packed" erklären und wo muss das hin?

> mitgegeben wird (bei WinAVR sind structs bereits implizit gepackt, wer
> ganz sicher gehen will gegen zukünftige Änderungen, schreibt das
> Attribut noch dazu).  Somit ist es völlig OK, die struct byteweise
> einzulesen und rauszuschreiben, solange man innerhalb derselben
> Architektur bleibt.

Hättest du da mal ein Beispiel wie sowas gemacht wird?

Gruß Denny

> Kannst du mir das mit dem "packed" erklären und wo muss das hin?

1

typedef struct a {char x, ...} __attribute__ ((packed)) DingsBums;

In der Praxis kannst Du aber davon ausgehen, dass bei einer 
8-Bit-Architektur Packen keinen Sinn hat, weil nie ein Padding gemacht 
wird, und Dir dies sparen.

>>  Somit ist es völlig OK, die struct byteweise
>> einzulesen und rauszuschreiben, solange man innerhalb derselben
>> Architektur bleibt.
>
> Hättest du da mal ein Beispiel wie sowas gemacht wird?

1

uint8_t *writepointer = (uint8_t *) &DeineStruct;

2

for (uint8_t i = 0; i < sizeof(DeineStruct); i++, writepointer++)

3

  eeprom_write_byte(writepointer, *writepointer);

um eine struct ins EEProm zu schreiben.

Edit: Fehler in der structure-Definition

>

1

> uint8_t *writepointer = (uint8_t *) &DeineStruct;

2

> for (uint8_t i = 0; i < sizeof(DeineStruct); i++, writepointer++)

3

>   eeprom_write_byte(writepointer, *writepointer);

4

>

Korrektur:  das schreibts an die Stelle ins EEProm, an der's auch im 
SRAM steht, was natürlich sinnlos ist.  Bei eeprom_write_byte gehört als 
erstes Argument die EEProm-Adresse mit Postinkrement hin.

Man kann natürlich auch ganz einfach die

eeprom_write_block und eeprom_read_block benutzen.

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Block_lesen.2Fschreiben

1

...

2

struct heizung MyHeizung;

3

4

...

5

6

  eeprom_read_block( &MyHeizung, eeMyHeizung, sizeof( MyHeizung ) );

7

8

...

9

10

  eeprom_write_block( &MyHeizung, eeMyHeizung, sizeof( MyHeizung ) );

Im gcc-Tutorial gibt es da einen schönen Abschnitt darüber.

Padding ist natürlich grundsätzlich ein Thema. Allerdings ist es auf 
einem AVR müssig darüber nachzudenken, weil es im gcc in diesem Fall 
keines gibt.

Hallo!

Ich will ja nicht ins interne Epprom schreiben sondern in ein I2C Eeprom 
und
da gibs leider solche Funktionen nicht!
Benutze dafür die Lib von Peter Fleury.

1

i2c_write(byte1);

2

i2c_write(byte2);

Mal als Beispiel.

Gruß Denny

Karl heinz Buchegger schrieb:
> Man kann natürlich auch ganz einfach die
>
> eeprom_write_block und eeprom_read_block benutzen.

Klar. Allerdings wollte der Threadersteller ins FRAM schreiben, weshalb 
ich ein anderes Beispiel gewählt habe.

Oh, da war der Ersteller schneller.  Mift.

Denny S. schrieb:
> Hallo!
>
> Ich will ja nicht ins interne Epprom schreiben sondern in ein I2C Eeprom
> und
> da gibs leider solche Funktionen nicht!
> Benutze dafür die Lib von Peter Fleury.
>
>

1

> i2c_write(byte1);

2

> i2c_write(byte2);

3

>

>
> Mal als Beispiel.

Ah. Entschuldigung. Der Thread ist schon etwas zu lang.
Also doch: Eine Schleife drüber.

Aber verpack dir die Block-Schreiberei/Leserei in eine eigene Funktion. 
Kannst ja die eeprom_read_block als Vorbild dafür nehmen, wie die 
Funktionssignatur aussehen könnte.

Hallo!

Ich habe das mit den Schleifen nun gemacht und geht auch FAST gut.
Ich benutze mehrere Structuren die ich nach ein ander einlese, aber bei 
2 funktioniert es nicht richtig. Obwohl immer wieder die gleiche 
Funktion aufgerufen wird.
Dort liest er falsche Werte ein!

Hier mal die Funktionen:

1

//#########################################################################################################

2

void lesen_heizung_2(unsigned char z)

3

{

4

  LED4_ON;

5

6

  uint8_t dummy;

7

  uint8_t *writepointer = (uint8_t *) &ZIMMER[z];

8

9

  i2c_start_wait(pgm_read_word(&chip_select[z])+I2C_WRITE);

10

  i2c_write(pgm_read_byte(&adresse[z]));

11

  i2c_rep_start(pgm_read_word(&chip_select[z])+I2C_READ);

12

13

  for (uint8_t i = 0; i < sizeof(ZIMMER[z]); i++, writepointer++)

14

  {

15

    *writepointer = i2c_readAck();

16

  }

17

  dummy = i2c_readNak();

18

19

  i2c_stop();

20

  LED4_OFF;

21

}

22

//#########################################################################################################

23

void schreiben_heizung_2(unsigned char z)

24

{

25

  LED4_ON;

26

27

  uint8_t *writepointer = (uint8_t *) &ZIMMER[z];

28

29

  i2c_start_wait(pgm_read_word(&chip_select[z])+I2C_WRITE);

30

  i2c_write(pgm_read_byte(&adresse[z]));

31

32

  for (uint8_t i = 0; i < sizeof(ZIMMER[z]); i++, writepointer++)

33

  {

34

    i2c_write(*writepointer);

35

  }

36

37

  i2c_stop();

38

  LED4_OFF;

39

}

Ich habe das ja nach dem Beispiel oben im Thread gemacht.

Könnte es sein das es an der falschen Größe der Variablen liegt?
Sind Adressen immer uint8_t oder sollten sie nicht uint16_t sein?
Benutze ja ein Atmega2561 und der sollte mehr als 255 Adressen haben!

Gruß Denny

> Könnte es sein das es an der falschen Größe der Variablen liegt?
> Sind Adressen immer uint8_t oder sollten sie nicht uint16_t sein?

In Deinem geposteten Code sehe ich nur eine Variable, die eine Adresse 
beinhaltet:

1

>   uint8_t *writepointer = (uint8_t *) &ZIMMER[z];

Die ist 16 Bit.

Dass sizeof(ZIMMER[z]) nie größer als 256 werden kann, hast Du schon 
abgeklopft, nehme ich an.  Hast Du auch abgeklopft, ob die Gesamtlänge 
ins EEProm passt?