Guten Tag,
ich möchte mit meinem Mikrocontroller (Atmega644) eine Messreihe
aufnehmen, um ein paar Sensoren abstimmen zu können.
Das Problem ist, dass meine einzige Schnittstelle nach außen die
Programmierschnittstelle ist.
Nun dachte ich, die aufgenommenen Messdaten in den EEPROM zu legen und
nachher am PC auszulesen.
Oder gibt es da noch andere Möglichkeiten?
Jede Messreihe wird als uint16_t-Array mit etwa 150 Werten gespeichert.
Wie müsste dann der Code aussehen?
Ich frage lieber mal nach, bevor ich meinen EEPROM mit Datenmüll fülle,
weil ich irgendetwas falsch verstanden habe. ;)
Würde es so in etwa funktionieren oder hab ich was falsch verstanden?
Vorschlag (Vorlage aus AVG-GCC Tutorial dieser Seite):
#include <stdint.h>
#include <avr/eeprom.h>
int main(void)
{
uint16_t messreihe[150];
uint16_t eeFooWordArray1[150] EEMEM;
//Nehme zwischendurch eine Messreihe auf
eeFooWordArray1 EEMEM = messreihe;
//zum lesen
messreihe = eeprom_read_byte (&eeFooWordArray1);
while(1){};
Brian schrieb:
das hier...
>> eeFooWordArray1 EEMEM = messreihe;
... lässt du weg, wozu soll das gut sein? Zwischen den Variablen
'messreihe' und 'eeFooWordArray1' gibt es sowieso keinen Zusammenhang,
ausser das beide zufällig vom gleichen Datentyp und von gleicher
Arraylänge sind.
und hier....
> messreihe = eeprom_read_byte (&eeFooWordArray1);
benutzt du eeprom_read_block (bzw. machst dir eines, wenn es diese
Funktion noch nicht gibt), denn ein Array ist ja wohl eher ein
Speicher-Block und kein einzelnes Byte. (Und auch einen uint16_t kann
man wohl schwerlich als einzelnes Byte titulieren)
Aber abgesehen davon ist es perfekt.
Karl Heinz Buchegger schrieb:> Brian schrieb:>>> das hier...>>>>> eeFooWordArray1 EEMEM = messreihe;>> ... lässt du weg, wozu soll das gut sein? Zwischen den Variablen> 'messreihe' und 'eeFooWordArray1' gibt es sowieso keinen Zusammenhang,> ausser das beide zufällig vom gleichen Datentyp und von gleicher> Arraylänge sind.
Ich dachte mir, dass eeFooWordArray1 im EEPROM liegt und ich darein nun
meine Messreihe speicher.
Irgendwie müssen die Daten doch in den EEPROM kommen, wie du ja selbst
bemerkt hast, gibt es zwischen den beiden Arrays ja sonst keinerlei
Zusammenhang.
> und hier....>>> messreihe = eeprom_read_byte (&eeFooWordArray1);>> benutzt du eeprom_read_block (bzw. machst dir eines, wenn es diese> Funktion noch nicht gibt), denn ein Array ist ja wohl eher ein> Speicher-Block und kein einzelnes Byte. (Und auch einen uint16_t kann> man wohl schwerlich als einzelnes Byte titulieren)
Ok, da hast du natürlich recht.
Passender währen da wohl die Funktionen:
eeprom_read_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer));
und
eeprom_write_block (myWordBuffer, eeFooWordArray1,
sizeof(myWordBuffer));
> Aber abgesehen davon ist es perfekt.
Da abgesehen davon kaum etwas stand, verbuche ich das mal unter
Sarkasmus.
Brian schrieb:> Ich dachte mir, dass eeFooWordArray1 im EEPROM liegt und ich darein nun> meine Messreihe speicher.
Ja, ist auch ok
> Irgendwie müssen die Daten doch in den EEPROM kommen,
Genau.
Die Daten kommen ins EEPROM bzw aus dem EEPROM heraus, indem
eeprom_read_block bzw. eeprom_write_block sie umkopiert.
Auf der einen Seite hast du ein Array im SRAM
messreihe
+------+
| |
+------+
| |
+------+
| |
+------+
| |
. .
. .
. .
| |
+------+
| |
+------+
und auf der anderen Seite hast du ein Array im EEPROM
messreihe (SRAM)
+------+
| | eeFooWordArray1 (EEPROM)
+------+ +-------+
| | | |
+------+ +-------+
| | | |
+------+ +-------+
| | | |
. . . .
. . . .
. . | |
| | +-------+
+------+ | |
| | +-------+
+------+ | |
+-------+
Das sind 2 voneinander getrennte Arrays, die nichts miteinander zu tun
haben.
Und jetzt kommt die Funktion eeprom_read_block ins Spiel, die einen
Speicherbereich aus dem EEPROM umkopiert in einen Speicherbereich im
SRAM
messreihe (SRAM)
+------+ --+
| | | eeFooWordArray1 (EEPROM)
+------+ | +-- +-------+
| | | | | |
+------+ | <------------------ | +-------+
| | | eeprom_read_block | | |
+------+ | | +-------+
| | | | | |
. . | | . .
. . | | . .
. . | | | |
| | | | +-------+
+------+ | | | |
| | | | +-------+
+------+ --+ | | |
+-- +-------+
damit hast du die Daten an einer Stelle, an der du sie wie jede anderen
Daten auch verändern kannst.
Und wenn du fertig bist, kommt eeprom_write_block zum Zug, welches die
Daten wieder zurück ins EEPROM kopiert
messreihe (SRAM)
+------+ --+
| | | eeFooWordArray1 (EEPROM)
+------+ | +-- +-------+
| | | | | |
+------+ | ------------------> | +-------+
| | | eeprom_write_block | | |
+------+ | | +-------+
| | | | | |
. . | | . .
. . | | . .
. . | | | |
| | | | +-------+
+------+ | | | |
| | | | +-------+
+------+ --+ | | |
+-- +-------+
wo sie den nächsten Stromausfall überleben.
Anstelle das komplette Array umzukopieren, kann man natürlich auch die
einzelnen Elemente des Arrays kopieren, die sich auch tatsächlich
verändert haben. Aber das ist dann eine reine Frage der Programmierung,
wie man das genau macht.
PS: Und anstelle von eeFooWordArray1 nimmst du natürlich einen
vernünftigen Variablennamen :-)
Brian schrieb:>> Aber abgesehen davon ist es perfekt.> Da abgesehen davon kaum etwas stand, verbuche ich das mal unter> Sarkasmus.
Nicht ganz. Denn du hast immerhin erkannt, dass du eeprom_read_xxxx
brauchst, welches Daten umkopiert. Und das ist schon mal die halbe Miete
und nimmt dem ganzen den Nimbus des 'da passiert irgendwas Magisches im
Hintergrund'.
Die Sache ist wirklich ganz einfach:
Auf der einen Seite stehen die Daten im EEPROM wo sie einen Stromausfall
überleben aber nicht direkt aus dem Programm heraus wie andere Variablen
angesprochen werden können.
Auf der anderen Seite stehen die Daten im SRAM, wo man sie zwar aus dem
Programm heraus über Variablen ansprechen und verändern kann, wo sie
aber einen Stromausfall nicht überleben.
Den Spaghat zwischen den beiden schafft man, in dem man die Daten
einfach zwischen den Variablen hin und her kopiert. Und genau da kommen
dann die eeprom_read_xxxx bzw. eeprom_write_xxxx Funktionen ins Spiel.
Und schon ist das ganze nicht mehr 'Magisch' sondern einfach nur eine
Kopieraktion von einem Speicherbereich in einen anderen Speicherbereich,
von denen einer eben 'zufällig' im EEPROM liegt. Mehr steckt da nicht
dahinter.
Brian schrieb:> Guten Tag,>> ich möchte mit meinem Mikrocontroller (Atmega644) eine Messreihe> aufnehmen, um ein paar Sensoren abstimmen zu können.> Das Problem ist, dass meine einzige Schnittstelle nach außen die> Programmierschnittstelle ist.> Nun dachte ich, die aufgenommenen Messdaten in den EEPROM zu legen und> nachher am PC auszulesen.> Oder gibt es da noch andere Möglichkeiten?
Die ISP-Programmierschnittstelle ist im laufenden Betrieb eine
SPI-Schnittstelle, die Du benutzen kannst. Du hast leider kein
!CS-Signal, aber das sollte auch ohne gehen.
An diese SPI-Schnittstelle kannst Du irgendetwas anschließen, z.B. einen
anderen Mikrocontroller, der die SPI-Daten per UART zum PC sendet. Oder
DU baust einen Software-UART rein oder zwei Drahtbrücken zu den
UART-Pins, wenn die noch frei sind,oder oder.
fchk
