Versuche grade nen INT wert ins EEPROM zu Schaufeln jedoch geht da was schief..
long minlvl = 0;
long maxlvl = 0;
...
long eemin;
long eemax;
...
eemin=eepromReadLong(1); //minlvl
eemax=eepromReadLong(10); //maxlvl
...
long total = liquidLevel.capacitiveSensorRaw(50);
...
minlvl = total;
eepromWriteLong(1, minlvl);
...
maxlvl = total;
eepromWriteLong(10, maxlvl);
...
void writeData(unsigned int addr, byte data)
{
Wire.beginTransmission(i2caddr);
// set the pointer position
Wire.write((int)(addr >> 8));
Wire.write((int)(addr & 0xFF));
Wire.write(data);
Wire.endTransmission();
delay(10);
}
// reads a byte of data from memory location addr
byte readData(unsigned int addr)
{
byte result;
Wire.beginTransmission(i2caddr);
// set the pointer position
Wire.write((int)(addr >> 8));
Wire.write((int)(addr & 0xFF));
Wire.endTransmission();
Wire.requestFrom(i2caddr,1); // get the byte of data
result = Wire.read();
return result;
}
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;
writeData(adr, low); // dauert 3,3ms
writeData(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=readData(adr);
high=readData(adr+1);
return low + ((high << 8)&0xFF00);
} //eepromReadInt
void eepromWriteLong(long lo, int adr) {
// long Wert in das EEPROM schreiben
// Eingabe : adr Speicherplatz
// Eingabe : lo Zahl, Wertebereich -2.147.483.648 bis 2.147.483.647
//
// Matthias Busse 23.5.2014 Version 1.0
byte by;
for(int i=0;i< 4;i++) {
by = (lo >> ((3-i)*8)) & 0x000000ff;
writeData(adr+i, by);
}
} // eepromWriteLong
long eepromReadLong(int adr) {
// long int Wert aus 4 Byte EEPROM lesen
// Eingabe : adr bis adr+3
// Ausgabe : long Wert
//
// Matthias Busse 23.5.2014 Version 1.0
long lo=0;
for(int i=0;i< 3;i++){
lo += readData(adr+i);
lo = lo << 8;
}
lo += readData(adr+3);
return lo;
} // eepromReadLong
minwert: MIN WERT GESETZT auf: 50024
maxwert: MAX WERT GESETZT auf: 786261
Da Templates typ-sicher ist, ist nun der Typ in der Funktion bekannt und man kann einfach sizeof(T) machen. So muss man die Größe nicht mehr übergeben
Du kannst dir auch mal die EEPROM Klasse in neueren Arduino Versionen ansehen. Da gibt es z.B. eine update() Funktion wo der Wert nur geschrieben wird wenn er sich geändert hat. Das ist natürlich für das interne EEPROM gedacht, aber den Code kann man auch kopieren und für externe EEPROM anpassen.
danke für deine mühe jedoch bin ich nicht in der lage das so anzupassen das es auf meinem arduino DUE läuft ich werde das einfach weglassen und den wert bei jedem neustart des arduinos neu einlesen. Ich hock schon den ganzen tag dadran und bin keinen schritt weiter gekommen
Dann nimm halt meinen Code (am besten die Template Version). Da muss du nur zwei Zeilen ändern
Byte schreiben:
eeprom[adr + i] = *ptr;
Byte lesen:
*ptr = eeprom[adr + i];
Da ersetzt du den Array Zugriff durch deine I2C Funktion und es sollte gehen. Wobei dann der I2C Kram ebenfalls in den Header muss.
*ptr ist einfach das aktuelle Byte. Entweder in der Quell- oder der Ziel-Variable.
Und eben das Array entfernen. Wobei du die 100 Byte auf dem Due nicht vermissen wirst
Oh je, Oh je Das solltest du nicht so wörtlich nehmen
1.) Inkludiere im Header Wire.h. Sonst sind die Wire Funktionen wahrscheinlich nicht bekannt. Im Haupt-Sketch musst du es dann wahrscheinlich trotzdem nochmal inkludieren (da spinnt die IDE etwas)
2.) Dann verwende deine Funktion so wie du sie geschrieben hast!
so habs versucht aber irgendwie scheine ich da was falsch zu machen bzw nicht ganz verstehen...
unsigned long minlvl = 10000; // sensor auswertung dauert mir beim testen zulange, werte zwischen 0-10000 zu erwarten
unsigned long maxlvl = 90000; // sensor auswertung dauert mir beim testen zulange, werte zwischen 0-10000 zu erwarten
unsigned long eemin;
unsigned long eemax;
unsigned int adr = 0;
Caste da mal auf byte statt int. Du willst die write() Methode die ein einzelnes Byte schreibt! Nicht int
Oder versuche mal Wire.write(addr). Dann wird die unsigned int Methode aufgerufen
Wire hat nämlich Methoden für 1 Byte, 2 Bytes und 4 Bytes. Da muss man dann schon die richtige aufrufen
Das EEPPROM kann übrigens Page Read/Write. Also man kann einmal adressieren und dann x Bytes lesen und schreiben. So hat man jetzt etwas mehr Datenverkehr, weil jedes Byte einzeln adressiert wird. Aber wenn man nur ein paar Werte hier und da überträgt ist das vollkommen egal.
Klar sollte so das sein. Der Fehler liegt wahrscheinlich auf der untersten Ebene. Für mich sieht für mich so aus dass was bei der Adressierung der Speicherzellen im EEPROM schief geht.
Wenn du genau weißt was du machst kannst das mit sizeof() natürlich auch weglassen und die Adressen per Hand setzen. Also einmal auf 0 und einmal auf 4. Aber so muss man sich nicht um die Größe der Datentypen kümmern. Das ist vor allem dann praktisch wenn man einige verschiedene Datentypen hat. Oder wenn man komplexe Datentypen wie structs ins EEPROM schreibt. Oder auch wenn Code sowohl auf dem Due und UNO/Mega laufen soll, da int und double da unterschiedlich groß sind.
