Eine Integer Zahl in das Arduino EEPROM schreiben und wieder lesen

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

10 Gedanken zu „Eine Integer Zahl in das Arduino EEPROM schreiben und wieder lesen

  1. Pingback: 3 Tasten: Einen Wert einstellen und im EEPROM ablegen | Shelvin – Elektronik ausprobiert und erläutert

  2. Manfred

    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?

    Antworten
      1. Jochen

        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);}
        }

        Antworten
  3. Lemar

    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?

    Antworten
  4. Hanspeter

    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

    Antworten
  5. Moes

    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

    Antworten

Schreibe einen Kommentar zu Hanspeter Antworten abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.