Ich hab wieder ein Problem, dessen Lösung ich einfach nicht finde.
#include <Wire.h> // Comes with Arduino IDE
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
#include <SoftwareSerial.h>
int X1Speichern = 8;
int y = analogRead(A0);
int x = analogRead(y);
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address
//This function will write a 2 byte integer to the eeprom at the specified address and address + 1
void EEPROMWriteInt(int X1Speichern, int x)
{
byte lowByte = ((x >> 0) & 0xFF);
byte highByte = ((x >> 8) & 0xFF);
EEPROM.write(X1Speichern, lowByte);
EEPROM.write(X1Speichern + 1, highByte);
}
//This function will read a 2 byte integer from the eeprom at the specified address and address + 1
unsigned int EEPROMReadInt(int X1Speichern)
{
byte lowByte = EEPROM.read(X1Speichern);
byte highByte = EEPROM.read(X1Speichern + 1);
return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00);
}
void setup()
{
int sensor = analogRead(y);
lcd.begin(20, 4);
Serial.begin(9600);
EEPROMWriteInt(0, 0xABCD);
Serial.print("Read the following int at the eeprom address 0: ");
Serial.println(EEPROMReadInt(0), HEX);
}
void loop()
{int sensor = analogRead(y);
lcd.setCursor(0,0);
lcd.print(" ");
lcd.print(x);
lcd.setCursor(0,1);
lcd.print(sensor);
}
Ich versuche meinen AnalogRead als "ganzen" Wert zu speichern. Natürlich muss dieser geteilt werden.
Als Wert erwarte ich ca 350.
Wenn ich "X" durch die Zahl 350 ersetze, klappt alles.
Aber ich kriege es nicht hin ein analogRead einzubauen....
Ich versteh einfach nicht was ich falsch mache...
Hinterher muss ich auch noch hinbekommen, dass ich lediglich auf "IF" Anweisung das ganze ausführe...
Kahzia:
... ein Problem, dessen Lösung ich einfach nicht finde. ...
Mein Top-Tipp zur Lösungsfindung: Formatiere Deinen Code so, dass man sich schnell darin zurecht findet. Wenn Du die Struktur(en) Deines Codes schnell erfassbar machst, findest Du die Lösung evtl. sogar ohne die Hilfe anderer.
Naja der Code besteht ja aus nichts weiterem als X und X1Speicher..
Das war die Anleitung aus dem Forum hier...
Ich finde ihn übersichtlich wenn man diesen in das Arduino Programm kopiert.
Ich komme mit put und get leider auch nicht wirklich weiter.
Da fehlt mir komplett die Übersicht was da überhaupt geschieht.
Der vorgefertigte Code von Arduino hilft mir da leider auch nicht.
Ich würde nach wie vor den Wert einfach aufteilen in low und high byte.
Das funktioniert ja auch mit Statischen Werten. Ich bräuchte nur Hilfe wie ich da ein analogRead integriere.
Hmmm wenn ich X1Speichern durch Ausgabe ersetze, komme ich aufs gleicher Ergebniss.
Ich erhalte immer den Wert 128
Obwohl dieser 367 sein müsste.
Mit dem EEPROM.read auf der anderen Variable klappt das.
Es ist natürlich ziemlich schwierig aus den Code-Fragmenten etwas zu erkennen.
Bitte poste immer den kompletten Code in dem der Fehler auftritt. In den meisten Fällen liegt der Fehler nämlich in jenem Teil des Codes, der nicht gepostet wurde!
Ich rate also mal einfach vor mich hin...
Wie wäre es, wenn du zum Beispiel statt
if (Button == HIGH) {
...
folgendes verwendest:
if (digitalRead(Button) == HIGH) {
...
Vielleicht ist das mal ein Anfang.
Und noch einmal die Bitte:
Poste Code der kompiliert, sonst ist es sehr schwierig Fehler zu finden.
Vielleicht liegt es ja daran, das du in den EEPROM-Funktionen als Variablen-Typ int angibts.
Probier es doch mal mit unsigned int, da wird das MSb auf jedenfall nicht verändert.
Ansonsten kannst du es gerne mit folgendem Code-Schnipsel aus einem AVR-PDF probieren:
unsigned int EEPROMReadWord(unsigned int uiAddress){
return (EEPROMRead(uiAddress++)<<8)|EEPROMRead(uiAddress);
}
unsigned char EEPROMRead(unsigned int uiAddress){
while(EECR & (1<<EEPE)); // Wait for completion of previous write
EEAR = uiAddress; // Set up address register
EECR |= (1<<EERE); // Start eeprom read by writing EERE
return EEDR; // Return data from Data Register
}
unsigned int EEPROMWriteWord(unsigned int uiAddress, unsigned int ucData){
uiAddress=EEPROMWrite (uiAddress,ucData>>8);
uiAddress=EEPROMWrite (uiAddress,ucData&255);
return uiAddress;
}
unsigned int EEPROMWrite(unsigned int uiAddress, unsigned char ucData){
// yellowLEDPort^=yellowLED;
while(EECR & (1<<EEPE)); // Wait for completion of previous write
noInterrupts();
EEAR = uiAddress++; // Set up address and Data Registers
EEDR = ucData;
EECR |= (1<<EEMPE); // Write logical one to EEMPE
EECR |= (1<<EEPE); // Start eeprom write by setting EEPE
interrupts();
// yellowLEDPort^=yellowLED;
return uiAddress;
}
Nicht wundern über die EEPROMWrite(Word)-Funktionen das diese die nächste Adresse zurück geben.
Wenn man z. B. Adresse=EEPROMWriteWord(Adresse,Wert) aufruft und dann wieder und wieder um einen größeren Block zu schreiben erspaart man sich das ständige Adresse++ oder Adresse+=2.
Ansonsten einfach mit EEPROMWriteWord(Adresse,Wert) aufrufen.
yellowLEDPort^=yellowLED toggelt beim schreiben eine LED auf dem AVR-Board, zur Kontrolle.
Wenn erwünscht vorher die richtigen Definitionen für den Port dieser setzen und dann aktivieren.
Ach ja, diese EEPROM-Routinen kommen ohne Librarie zurecht.
Die EEPROM....Word-Funktionen schreiben/lesen zuerst das MSB dann das LSB, wenn lieber anders herum, glaube Intel-Norm war das, dann einfach die Reihenfolge vertauschen.
Bitte poste immer den kompletten Code in dem der Fehler auftritt.
Naja wie krieg ich hier 300 Zeilen hoch ?
Ich glaube das wird unübersichtlich
Wie Handhabe ich das am besten ?
Ich lad den Code jetzt einfach mal hoch.
Da könnt Ihr den über den Link downloaden
Es geht ab 174 los. bis 205
Ziel ist eine Kalibrierung. Der Sensor wird mit der Sonde in eine Lösung gehalten und dann per Button der Wert gespeichert zur errechung der Steigung.
wert = analogRead
EEPROM.put(eeprom-adresse, wert)
2 Byte werden gespeichert.
EEPROM.get(eeprom-adresse, wert)
Serial.print(wert, DEC);
Was passiert da?
Mit deiner Variante steh ich kurz vor einer Lösung.
Solche Links machen auf mich den Eindruck von gefundenen gebrauchten Kaugummis.
Die stecke ich mir nicht in den Mund.
Tipp:
Wir haben hier im Forum eine Code Formatierung. Das ist schon übersichtlich, dann.
Auch kann man Dateien anhängen. Das ist für die Nachwelt besser. Denn die Daten bleiben erhalten. Bei deiner Methode ist irgendwann der Thread wertlos, weil Datei weg.
Sowas unterstütze ich nicht.
Ich hab mich an write gehalten, ich dachte man definiert die Addr. oben einfach.
z.B mit 0 oder 15
Oder lieg ich da falsch ?
Was würde ein Postbote von dir halten, wenn du ihm sowas erzählst?
Adressen unterliegen einem Ordnungssystem.
Zumindest sollte man eins darauf anwenden, um erfolgreich zu sein.
Chaos und würfeln, sind da bedenkliche Strategien.
Die Variable ramWert liegt im RAM
Die Variable eepWert liegt im EEPROM
Der Kompiler kennt die Speicherorte!
Überlasse ihm die Speicherortverwaltung.
Er kann das besser, als du, denn er wurde, unter Anderem, dafür geschaffen.
Jetzt möchte ich den, im EEPROM gespeicherten, Wert um 1 erhöhen:
// in einer Funktion
EEPROM.get((int)&eepWert,ramWert); // Wert aus dem EEPROM ins RAM lesen
ramWert += 1; // Wert um 1 erhöhen
EEPROM.put((int)&eepWert,ramWert); // Wert aus dem RAM ins EEPROM schreiben
Würfeln?