Schrijven en lezen Eeprom

[DeDraak Profiel Privébericht]

Hallo,

ik zou graag willen weten hoe ik het Setpoint kan schrijven en lezen naar en van mijn Eeprom.

Ik heb allerlei code's geprobeerd en gezocht maar ik krijg het niet voor elkaar.
Bijgevoegd mijn code:

Code: Alles selecteren

const int downButtonPin = 7;                 
const int upButtonPin = 6;                   
int downButtonState = LOW;                   
int downReading;                             
int upButtonState = LOW;                     
int upReading;                               
int Setpoint;

void setup()
{
  Serial.begin( 9600);
  pinMode(downButtonPin, INPUT);// assign pins to the buttons
  pinMode(upButtonPin, INPUT);// assign pins to the buttons
  Serial.print("Setpoint:" );

}

void loop()
{
          // Check states of pushbuttons, if pressed change setpoint up or down
          upButtonState = digitalRead(upButtonPin);
          if (upButtonState == 0)
            Setpoint++;
          downButtonState = digitalRead(downButtonPin);
          if (downButtonState == 0)
            Setpoint--;
          Serial.println(Setpoint);
          delay(100);
}

[shooter Profiel Privébericht]

kijk naar hoe het moet in arduino.cc referentie.
dan heb je dus setpoint, en Ki,Kd,Kp en eigenlijk ook nog de tijden.
https://www.arduino.cc/en/Reference/EEPROM

[DeDraak Profiel Privébericht]

Ik heb het gezien maar krijg het niet werkend..

[shooter Profiel Privébericht]

wat gaat er dan fout volgens jou en welk programma gebruik je.

[DeDraak Profiel Privébericht]

Ik heb nu Eeprom get en Eeprom put, dat is me een stuk duidelijker en daarmee gaat het wel lukken verwacht ik..

[DeDraak Profiel Privébericht]

Ik heb het voor elkaar gekregen om het setpoint naar mijn Eeprom te schrijven middels deze code:

Code: Alles selecteren

#include <EEPROM.h>
const int downButtonPin = 7;
const int upButtonPin = 6;
int downButtonState = LOW;
int downReading;
int upButtonState = LOW;
int upReading;
int Setpoint;

struct MyObject {
  float field1; // Setpoint Eeprom
};


void setup()
{
  Serial.begin( 9600);
  pinMode(downButtonPin, INPUT);// assign pins to the buttons
  pinMode(upButtonPin, INPUT);// assign pins to the buttons
  Serial.print("Setpoint:" );

}

void loop()
{
  float f = 0.00f;   //Variable to store data read from EEPROM.
  int eeAddress = 0;   //Location we want the data to be put.

  //One simple call, with the address first and the object second.
  EEPROM.put(eeAddress, Setpoint);

  //Data to store.
  MyObject customVar = {
    Setpoint,
  };

  eeAddress += sizeof(float); //Move address to the next byte after float 'f'.

  EEPROM.put(eeAddress, customVar);


  // Check states of pushbuttons, if pressed change setpoint up or down
  upButtonState = digitalRead(upButtonPin);
  if (upButtonState == 0)
    Setpoint++;
  downButtonState = digitalRead(downButtonPin);
  if (downButtonState == 0)
    Setpoint--;
  Serial.println(Setpoint);
  delay(100);
}

Met deze "get" code kan ik het aangepaste setpoint ook uitlezen.

Code: Alles selecteren

#include <EEPROM.h>

void setup() {

  float f = 0.00f;   //Variable to store data read from EEPROM.
  int eeAddress = 0; //EEPROM address to start reading from

  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.print("Read float from EEPROM: ");

  //Get the float data from the EEPROM at position 'eeAddress'
  EEPROM.get(eeAddress, f);
  Serial.println(f, 3);    //This may print 'ovf, nan' if the data inside the EEPROM is not a valid float.

  /***
    As get also returns a reference to 'f', you can use it inline.
    E.g: Serial.print( EEPROM.get( eeAddress, f ) );
  ***/

  /***
    Get can be used with custom structures too.
    I have separated this into an extra function.
  ***/

  secondTest(); //Run the next test.
}

struct MyObject {
  float field1;

};

void secondTest() {
  int eeAddress = sizeof(float); //Move address to the next byte after float 'f'.

  MyObject customVar; //Variable to store custom object read from EEPROM.
  EEPROM.get(eeAddress, customVar);

  Serial.println("Read custom object from EEPROM: ");
  Serial.println(customVar.field1);
}

void loop() {
  /* Empty loop */
}

Maar nu wil ik dus dat ik in mijn code de "get" krijg. En daar loop ik nu op vast..
Ik wil in mijn code dus het setpoint wegschrijven en weer ophalen als ik mijn Uno opnieuw opstart.

[Koepel Profiel Privébericht]

Het kan eenvoudiger.

De EEPROM.read() en EEPROM.write() lezen en schrijven een byte.
De EEPROM.get() en EEPROM.put() kunnen iedere variabele lezen en schrijven, maar je moet zelf bijhouden hoeveel byte die variabele in beslag neemt.

Je zou een lijstje kunnen maken van de indeling van het EEPROM:
byte 0...3 : setpoint als floating point getal
byte 4...? : struct ?

Je mag "sizeof()" gebruiken, maar je mag er ook van uit gaan dat een 'float' 4 byte is.
Wil je echt een struct naar de EEPROM schrijven ? Het is eenvoudiger om te kiezen tussen losse variabelen of een struct voor alles. Nu heb je beide.

De meest eenvoudige manier is om in setup() de waarden uit de EEPROM lezen, en in de loop() kijken of er op een knop wordt gedrukt. Als iemand op een knop drukt, dan wijzig je de setPoint variabele en kun je die ook meteen naar EEPROM schrijven.

Het lijkt me beter om eenvoudig te beginnen. Je "Setpoint" in je eerste sketch is een integer van 2 bytes, die komen in de EEPROM op positie 0 en 1. Zal ik de positie het "eeprom-address" noemen ?

EEPROM indeling
eeprom-adress 0...2 : setpoint als 2-byte integer

In de setup() functie:

Code: Alles selecteren

int Setpoint;

void setup()
{
  ...
  EEPROM.get(0, Setpoint);      // read two bytes from eeprom-address 0 and 1
  ...
}


In de loop() kijk je naar de knop, en dan eventueel de nieuwe waarde schrijven naar EEPROM.

Code: Alles selecteren

void loop()
{
  ...
  if (upButtonState == 0)
  {
    Setpoint++;
    EEPROM.put( 0, Setpoint);  // schrijf integer Setpoint naar eeprom-address 0 en 1
  }
  ...
  if (downButtonState == 0)
  {
    Setpoint--;
    EEPROM.put( 0, Setpoint);  // schrijf integer Setpoint naar eeprom-address 0 en 1
  }
  ...
}

Wist je dat een gangbare manier van het EEPROM gebruik veel uitgebreider is ? De EEPROM zou leeg kunnen zijn, dus hoort er een checksum bij. De volgorde of de data van de EEPROM zou kunnen wijzigen, dus hoort er een versie-nummer bij. De Arduino zou uitgezet kunnen worden terwijl het EEPROM wordt geschreven, dat kan opgelost worden door de data twee keer in de EEPROM te zetten, die om-en-om geschreven wordt. De hele EEPROM zou ongeldig kunnen zijn, dus in flash (bij de code) van de Arduino horen de default waarden van de data te staan, zodat er iets is om op terug te vallen.
Deze uitgebreide manier wordt in consumenten-producten vaak niet gedaan. Ik zie regelmatig problemen met verkeerde instellingen die voorkomen hadden kunnen worden. Ik had eens een Philips televisie die alleen nog groen beeld gaf. Die stond al klaar om weg te doen, maar toen las ik dat via de service-mode de EEPROM opnieuw gevuld kon worden. Daarna was het beeld weer normaal.

[DeDraak Profiel Privébericht]

Ja dit werkt perfect!

Ik moest het lezen inderdaad in de setup doen, daar ging het mis.

In totaal ga ik 4 float's schrijven naar de Eeprom, kan dat gewoon op deze manier?

EEPROM.get(0, Setpoint);
EEPROM.get(4, Kp);
EEPROM.get(12, Ki);
EEPROM.get(16, Kd);

Of welke adressen moet ik hier gaan gebruiken?

[Koepel Profiel Privébericht]

Moeite met de tafel van 4 ?
Als je vier float getallen wilt schrijven, dan kun je plaatsen op 0, 4, 8, 12. Vervolgens is 16 is eerstvolgende vrije.