EEPROM.h su architettura ESP8266

Ciao,

dunque sto facendo delle prove per capire come usare la libreria EEPROM su schedine ESP, a tal proposito ho caricato questo listato di prova. Perchè ottengo come stampa sempre il valore di val2?

Cosa sbaglio?

#include <EEPROM.h>

int addr1 = 0;
int addr2 = 0;
int val1 = 125;
int val2 = 250;
int stampa1;
int stampa2;

void setup() {
  Serial.begin(9600);
  EEPROM.begin(512);
}

void loop() {

  EEPROM.write(addr1, val1);
  EEPROM.commit();
  delay(100);
  EEPROM.write(addr2, val2);
  EEPROM.commit();
  delay(100);

  stampa1 = EEPROM.read(addr1); 
  delay(100);
  stampa2 = EEPROM.read(addr2);
  delay(100);
  Serial.println(stampa1);
  Serial.println(stampa2);
  
}

:) se all'indirizzo addr1 che vale 0 scrivi 125 e poi all'indirizzo addr2 che vale 0 scrivi 250

cosa vorrai leggere nell'indirizzo 0 e nell'indirizzo 0 ? :D

Mh, non ho capito

addr1 e addr2 sono uguali quindi la seconda scrittura sovrascrive la prima.

e in seguito, essendo i due indirizzi uguali leggi e stampi 2 volte lo stesso valore...

Ok forse ho capito, non vi scoccio oltre il dovuto, prima provo e poi se fallisco chiedo.

Intanto grazie 1000

Risolto, grazie a tutti!

#include <EEPROM.h>

// the current address in the EEPROM (i.e. which byte
// we're going to write to next)
byte addr = 0;
int val1 = 125;
int val2 = 250;
int stampa1;
int stampa2;

void setup() {
  Serial.begin(9600);
  EEPROM.begin(512);
}

void loop() {
  // need to divide by 4 because analog inputs range from
  // 0 to 1023 and each byte of the EEPROM can only hold a
  // value from 0 to 255.

  // write the value to the appropriate byte of the EEPROM.
  // these values will remain there when the board is
  // turned off.
  EEPROM.write(addr, val1);
  EEPROM.commit();
  EEPROM.write(addr+1, val2);
  EEPROM.commit();
  // advance to the next address.  there are 512 bytes in
  // the EEPROM, so go back to 0 when we hit 512.
  // save all changes to the flash.


 

  stampa1 = EEPROM.read(addr); 
  delay(100);
  stampa2 = EEPROM.read(addr+1);
  delay(100);
  Serial.println(stampa1);
  Serial.println(stampa2);
  
}

Nota però che stai sovrascrivendo un pezzo del primo valore con il secondo, dato gli int tengono più di 1 byte (su ESP8266 credo 4).

quindi sarebbe meglio dichiarare:

byte val1 = 125; byte val2 = 250;

???

Giusto?

Quello devi saperlo tu, dipende dall’intervallo di valori che devi metterci dentro. Byte va da 0 a 255.

SukkoPera: Nota però che stai sovrascrivendo un pezzo del primo valore con il secondo, dato gli int tengono più di 1 byte (su ESP8266 credo 4).

Rileggevo meglio,

è un caso che la stampa dei valori corrisponda a ciò che mi aspetto?

SukkoPera: Nota però che stai sovrascrivendo un pezzo del primo valore con il secondo, dato gli int tengono più di 1 byte (su ESP8266 credo 4).

Ma la write non scrive comunque un solo byte?

Standardoil:
Ma la write non scrive comunque un solo byte?

Esatto! Da reference infatti dice proprio quello, quindi immagino faccia un cast automatico il che significa che anche se metti un int devi avere un valore tra 0 e 255.

L’esempio presente nello stesso reference infatti usa un int:

#include <EEPROM.h>

void setup()
{
  for (int i = 0; i < 255; i++)
    EEPROM.write(i, i);
}

void loop()
{
}

Giusto. Ma allora il problema è un altro, ovvero che se prova a scrivere numeri > 255 non saranno corretti!

Si, non so come si comporti la write per valori maggiori di 255, se comunque scrive solo il byte meno significativo (voglio sperare che faccia un AND 0xFF) non dovrebbe sovrascrivere nulla ma riportare ovviamente un valore numerico diverso da quello atteso. Per questo è meglio definire la variabile come byte e non int. In ogni caso lui legge i valori corretti perché in questo caso sono minori di 256.

Sono a cena, quindi non provo ma non è questione di cosa fa la write Lei 'riceve' un byte È il cast implicito da int a byte che casomai taglia via informazioni Per togliersi il dubbio basta stampare una variabile byte dopo aver fatto un cast esplicito da una int Se il dopocena non evolve nel senso giusta magari provo....

Buondì, sto gestendo più di 100 posizioni di memoria, tutte poggiate su variabili byte usando questo sistema, e non ho problemi.

int addr = 0;
byte LU1ORAON;
byte LU2ORAON;
byte LU3ORAON;
byte LU4ORAON;

void setup(){
EEPROM.begin(512);
}

void loop(){

EEPROM.write(addr, LU1ORAON);
....
EEPROM.write(addr+3, LU4ORAON);

EEPROM.commit();
}

adesso siccome qualche variabile deve diventare del tipo float, immagino che le cose cambino e di molto. Da quel che ho capito, la eeprom.h scrive e legge un byte alla volta e difatti io nel mio programma non ho problemi proprio perchè tutte le mie variabili sono del tipo byte e anche volendo, non superano mai il valore di 255. Ora siccome una variabile float occupa 4 byte, come la si scrive e come la si legge? Grazie

leggendo 4 posizioni di memoria e combinandole assieme per formare il numero (sapendo qual'è la parte intera e quale la decimale) oppure moltiplicando ad esempio per 1000 il valore iniziale prima di memorizzarlo e dividerlo dopo il recupero....

p.s.

elimina il risolto dal titolo se andiamo avanti :D

droidprova: Ora siccome una variabile float occupa 4 byte, come la si scrive e come la si legge?

... Ma [u]impegnarsi un po'[/u] e studiare la libreria EEPROM proprio no ? ? ? :smiling_imp:

Guarda la EEPROM.put() e la EEPROM.get() e troverai quello che ti serve!

Guglielmo

Guglielmo, stavo leggendo gli esempi su gitub x quel che riguarda l'esp. E il metodo put e get non gli ho visti...

Adesso approfondisco e poi provo e intanto grazie x i link. Ho però un dubbio, essendo su piattaforma esp. dopo il put deve seguire sempre il commit?

E ancora: dall'esempio put:

float f = 123.456f;  //Variable to store in 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, f);

ma se float occupa 4 byte significa che la mia memoria sarà occupata in automatico su eeAddress 0,1,2,3 . Quindi per un eventuale float f2 successivo devo scrivere:

EEPROM.put(eeAddress +4, f2);