Eine Integer Zahl soll im Arduino EEPROM abgelegt und wieder ausgelesen werden.
Der EEPROM.write Befehl schreibt jeweils ein Byte an die Adresse.
Integer sind aber 2 Byte, sodass die Zahl zerlegt wird und beide Teile einzeln an zwei aufeinander folgende Adressen geschrieben werden.
void eepromWriteInt(int adr, int wert) {
byte low, high;
low=wert&0xFF;
high=(wert>>8)&0xFF;
EEPROM.write(adr, low); // dauert 3,3ms
EEPROM.write(adr+1, high);
return;
} //eepromWriteInt
Danach werden beide Bytes gelesen und wieder zu der Integer Zahl zusammen gefügt.
int eepromReadInt(int adr) {
byte low, high;
low=EEPROM.read(adr);
high=EEPROM.read(adr+1);
return low + ((high << 8)&0xFF00);
} //eepromReadInt
Hier das fertige Programm
// Integer in das EEPROM schreiben und auslesen
//
// Matthias Busse 22.5.2014 Version 1.0
#include < EEPROM.h>
int adresse=103;
int k=-29101;
void setup() {
Serial.begin(38400); // start serial
Serial.println("Int in EEPROM schreiben");
}
void loop() {
k += 1;
eepromWriteInt(adresse,k);
Serial.println(eepromReadInt(adresse));
delay(3000);
}
void eepromWriteInt(int adr, int wert) {
// 2 Byte Integer Zahl im EEPROM ablegen an der Adresse
// Eingabe:
// adr: Adresse +0 und +1 wird geschrieben
// wert: möglicher Wertebereich -32,768 bis 32,767
// Ausgabe:
// -
// 2 Byte Platz werden belegt.
//
// Matthias Busse 5.2014 V 1.0
byte low, high;
low=wert&0xFF;
high=(wert>>8)&0xFF;
EEPROM.write(adr, low); // dauert 3,3ms
EEPROM.write(adr+1, high);
return;
} //eepromWriteInt
int eepromReadInt(int adr) {
// 2 Byte Integer Zahl aus dem EEPROM lesen an der Adresse
// Eingabe:
// adr: Adresse +0 und +1 wird gelesen
// Ausgabe: int Wert
//
// Matthias Busse 5.2014 V 1.0
byte low, high;
low=EEPROM.read(adr);
high=EEPROM.read(adr+1);
return low + ((high << 8)&0xFF00);
} //eepromReadInt
> Eine long int Zahl im Arduino EEPROM ablegen und auslesen
von Matthias Busse
Pingback: 3 Tasten: Einen Wert einstellen und im EEPROM ablegen | Shelvin – Elektronik ausprobiert und erläutert
Vielen Dank!
Ich habe die beiden Routinen „eepromWriteInt“ und „eepromReadInt“ gerade auf mein Testboard gepackt, das ist fertige Arbeit für mein echtes Projekt.
Die Adressierung ist mir nicht ganz klar: Kann ich mich drauf verlassen, dass die Arduino-IDE die absoluten Adressen des EEProms selbst kennt, ich also nur 0 / 2 / 3 übergeben muß, um drei Werte abzulegen?
Hallo,
ein INT Wert braucht 2 Byte Speicherplatz.
Verwende also 0 / 2 / 4 usw.
Matthias
Hallo Matthias,
deinen Beitrag zum Schreiben von int Werten ins EEPROM fand ich sehr gut.
Gibt es eine Möglichkeit dieses mit meinem Skript zu verbinden?
Es geht darum, den Wert „buttonPresses“ in den Speicher zu schreiben für den Fall, dass Stromausfall wäre. Dieser kann durch Tastendruck immer um 1 hochgezählt werden.
Vielen Dank, Gruß Jochen
/* * Tastendrücke zählen */
int switchPin = 2; // Schalter ist mit Pin 2 verbunden
int val; // Variable für den Pin Zustand
int buttonState; // Variable für den letzten Schalterzustand
int buttonPresses = 0; // Wie oft ist der Schalter gedrückt
const int LED = 12;
//int zstS1=1;
void setup()
{
pinMode(LED, OUTPUT);
digitalWrite(LED, HIGH);
pinMode(switchPin, INPUT); // Schalter-Pin ist Input
Serial.begin(19200); // Start der seriellen Kommunikation mit 9600bps
buttonState = digitalRead(switchPin); // Anfangszustand lesen
}
void loop()
{
val = digitalRead(switchPin); // Eingabewert lesen und in val speichern
if (val != buttonState)
{ // Der Zustand des Schalters hat sich verändert
if (val == HIGH)
{ // Ist der Schalter gedrückt?
buttonPresses++; // Inkrementieren der Variablen buttonPresses
Serial.print(„Schalter wurde „);
Serial.print(buttonPresses);
Serial.println(“ gedrueckt“); }
} buttonState = val; // Den Zustand merken
if (buttonPresses == 2)
{digitalWrite(LED, LOW);}
if (buttonPresses == 4)
{digitalWrite(LED, HIGH);}
}
Hallo,
ich habe die Befehle EEPROM.put und EEPROM.get gefunden, die jede Art von Variabeln speichern können. Wo ist der Vorteil zu diesen Routinen?
Diese Befehle kannte ich letztes Jahr noch nicht.
Sind die neu dazu gekommen oder hatte ich die übersehen?
Scheinen neu zu sein – zumindest mit meiner Arduino-IDE 1.7.4 (05/2015) laufen sie nicht.
Hallo Matthias
der Beitrag ist zwar bereits 2Jahr alt, aber er hat trotzdem meinen Tag gerettet. Vielen Dank für das Teilen deines Wissen mit anderen. Perfekte Arbeit
Link wurde gespeichert
Wieviele Adressen hat man bei einem Arduino Uno?
Wenn der EEPROM des Arduino Uno eine Speicherkapazität von 1024 Bytes besitzt, beginnen die Adressen der Speicherzellen (ATmega328) bei 0 und enden bei 1023 also kann man ca. 500 Int Werte ablegen oder?
Reicht dicke für etwas Bastelspass
http://www.netzmafia.de/skripten/hardware/Arduino/EEPROM.html
Die neuen Funktionen sehen ganz nett aus..