Problem: Rechnen mit Werten aus EEPROM

[Sven (Gast)]

Hallo.

Vorne weg: Ich nutze einen ATmega32 und AVRStudio 4.18

Ich habe folgendes Problem:

Mit einer Matrizenrechnung berechne ich Sensorwerte. Dazu verwende ich 
ein mehrdimensionales Array

 double matrix[4][3];

Wenn ich matrix[4][3] bereits mit Werten vorbelege und compiliere 
funktioniert auch alles einwandfrei.

Nun möchte ich aber über HTerm mittels RS-232 die einzelnen matrix-Werte 
an matrix[4][3] übergeben.Diese sollen im EEPROM abgelegt werden.

Der Ablauf ist dabei folgender:

 double eeprom_array[12] EEMEM; // ist mein Eeprom-Array

- alle 12 Werte werden über UART RX Interrupt empfangen und in

 double copy_array[12]

 abgelegt.
- sind alle übermittelt wurden, dann

eeprom_write_block(&copy_array[i++],&eeprom_array[i++],sizeof(copy_array));

Dann hole ich mir die Werte mittels

eeprom_read_block(&matrix[s][t],&eeprom_array[i++],sizeof(matrix));

(s,t,i werden natürlich entsprechend hochgezählt)

In matrix[4][3] stehen dann auch die Werte genauso drin, wie ich sie 
über HTerm übergeben habe.Das Problem ist nur, wenn ich nun meine 
Berechnungen mit der Matrix durchführe, kommen total irrsinnige Werte 
bzw. auch -1.#QNAN raus.
Ich muss dazu aber noch erwähnen, dass es sich bei den Matrixwerten um 
Gleitkommawerte mit teilweise Potenz 1E-7 handelt.
Eine Berechnung sieht dann z.B. so aus:

 sensorX = x * matrix[0][0] + y * matrix[0][1] + z * matrix[0][2];

Muss ich etwa den Datentyp der arrays auf float ändern??Wäre jetzt eine 
Vermutung von mir.

Vielen Dank schonmal,Sven

[Peter D. (peda)]

Du mußt sicherstellen, daß double auf Quell- und Ziel-CPU das gleiche 
Format (z.B. IEEE 754), die gleiche Länge und die gleiche Byte-Order 
haben.


Peter

[Sascha W. (sascha-w)]

Sven schrieb:
> ...
> Der Ablauf ist dabei folgender:
>
>

 double eeprom_array[12] EEMEM; // ist mein Eeprom-Array

>
> - alle 12 Werte werden über UART RX Interrupt empfangen und in
>

 double copy_array[12]

 abgelegt.
> - sind alle übermittelt wurden, dann
>

eeprom_write_block(&copy_array[i++],&eeprom_array[i++],sizeof(copy_array));

i wird hier 2x hochgezählt

> Dann hole ich mir die Werte mittels
>

eeprom_read_block(&matrix[s][t],&eeprom_array[i++],sizeof(matrix));
>

>
> (s,t,i werden natürlich entsprechend hochgezählt)
>
> In matrix[4][3] stehen dann auch die Werte genauso drin, wie ich sie
> über HTerm übergeben habe.
sicher? - woher weißt du das?
lass doch die Werte mal ausgeben (Display vorhanden?)

Sascha

[Jens (Gast)]

Hallo Sven,

eines kommt mir komisch vor:

Du verwendest zum Kopieren offensichtlich eine Schleife, die die 
einzelnen Element der Matrix kopiert - als Größe gibst Du aber 
sizeof(array) an.

Ohne ganz sicher zu sein - das wird in die Hose gehen, weil der 
Copy-Bereich viel größer ist als ein Element. Und das könnte zu 
seltsamen Randeffekten führen, weil Du im Speicher rumgeisterst.

Gruß
Jens

[Sven (Gast)]

Jens wrote:

>Du verwendest zum Kopieren offensichtlich eine Schleife, die die
>einzelnen Element der Matrix kopiert - als Größe gibst Du aber
>sizeof(array) an.

Versteh ich grad nicht ganz: beide Array´s (copy_array und eeprom_array) 
bestehen aus [12] Feldern.

Sascha Weber wrote:
>i wird hier 2x hochgezählt
sorry,war falsch abgeschrieben worden.

Aber danke für den Tipp mit dem ausgeben lassen. Ich werde dies mal 
tun.Wenn dann Mist heraus kommt, deckt sich das mit der Annahme von 
Peter Dannegger, dass double unterschiedliche Formate hat,oder?

Nur als kleiner Nachtrag: Ich hatte vor einer Weile schonmal ein 
Programm geschrieben und eeprom_write/read_block verwendet. Dabei hatte 
ich eindimensionale Arrays verwendet und es lief problemlos.Deswegen 
macht mich das alles hier etwas stutzig.

[Jens (Gast)]

Hallo Sven,

nach meiner Kenntnis liefert sizeof(array) die Größe des gesamten Arrays 
in Bytes. Hier also Double*12. Du brauchst aber an der Stelle eigentlich 
sizeof(double) oder wie man manchmal nutzt sizeof(array[0]).

Alternativ geht auch

eeprom_write_block(copy_array,eeprom_array,sizeof(copy_array));

ganz ohne Schleife.

Die unterschiedlichen Float-Formate machen nur ein Problem, wenn Du die 
Zahlen im Binar-Format austauscht. Per HTerm hast Du sie ja vermutlich 
als ganz normale Zahl 42.0815 eingetippt.

Gruß
Jens

[Sven (Gast)]

Sascha Weber wrote:

> lass doch die Werte mal ausgeben (Display vorhanden?)

hab die Werte nachdem ich sie über HTerm eingegeben, mit 
eeprom_write_block abgelegt und eeprom_read_block in matrix[4][3] 
geschrieben habe wieder auf dem HTerm ausgeben lassen und die stimmen 
genau mit den eingegebenen überein. Daran liegt es also nicht.

Jens wrote:

> Du brauchst aber an der Stelle eigentlich
>sizeof(double) oder wie man manchmal nutzt sizeof(array[0]).

Danke.Das werde ich mal probieren.

[Sven (Gast)]

edit: muss ich dann in eeprom_read_block auch sizeof(double) schreiben?

[Sven (Gast)]

ich habe mal sizeof(double) in der eeprom_write/read_block()-Fkt. 
geschrieben und dabei hat es nur die ersten 4 Werte in das Array 
geschrieben, obwohl ich von HTerm 12 übergeben habe?!?

[Sven (Gast)]

Letzten Post von mir bitte als nichtig ansehen,es hatte sich ein 
falscher Variablenwert eingeschlichen ;-)