" Risolto" Non riesco a salvare i dati del sensore GSR sulla 24LC256

[eziogi]

Salve,

sto usando un sensore GSR e vorrei salvare i dati ricevuti su una EEPROM 24LC256.

Utilizzo un Arduino uno che dialoga con la EEPROM in i2C.

Se vado a verificare cosa ho salvato sulle EEPROM mi fa vedere dei dati non corretti.

Lo sketch è il seguente:

/***************************************
 *  12 gennaio 2026
 * 
 *  Arduino UNO
 *  EEPROM 24LC256
 *  
 ***************************************/
#include <Wire.h>

// +++++++++++++ variabili globali ++++++++
int massimo = 0;
int numeroProgressivo = 0; 
const int GSR = A2; // ingresso sensore
int abilitazione = 3;
int media = 0; 
int sensorValue = 0;
byte uno = 0;   // byte HIGH
byte due = 0;   // byte LOW 
int indirizzoArray = 0; // indirizzo celle Array
const int maxArray = 30; // massimo valore array 
int myArray[maxArray];
int indirizzoEEPROM = 0; // indirizzo celle EEPROM 
int ciclo = 0;  // cicli di salvataggio dati

// +++++++++++++ funzioni ++++++++++++++++
void salvanumeroProgressivo();
void leggeSensoreGSR();
void visualizzaDatiArray();
void salvaDatiEEPROM();

void setup(){
  Serial.println(" ");
  long sumMedia = 0;
   Serial.begin(9600);
   pinMode(abilitazione,INPUT_PULLUP);
   //digitalWrite(abilitazione,LOW);
    for(int i = 0; i < 100; i++){
      sensorValue = analogRead(GSR);
      sumMedia += sensorValue;
      delay(5);
      }
     media = sumMedia/100;
     Serial.print("Valore medio = ");
     Serial.println(media);
     Serial.println(" ");
     sensorValue = 0;
     Wire.begin();
}

void loop(){
 while(digitalRead(abilitazione) == LOW){  //con LOW abilitazione GSR  
    salvanumeroProgressivo();
    leggeSensoreGSR();
    visualizzaDatiArray();
    salvaDatiEEPROM();
    }
  //while(1);
}

/********************************************************
                    Funzioni
 ********************************************************/
void salvanumeroProgressivo(){  
    indirizzoArray = 0;
    myArray[indirizzoArray] = numeroProgressivo;
    //while(1);
}

void leggeSensoreGSR(){ 
  Serial.println(" ");
  Serial.println("Entra in GSR");
  ciclo = 0;
 while(digitalRead(abilitazione) == LOW){
   sensorValue = analogRead(GSR);
   // salva il dato nella cella corrente
    myArray[indirizzoArray] = sensorValue;
    delay(100);
    Serial.print("\t dato GRS = ");
    Serial.println(sensorValue);
    indirizzoArray++; 
    massimo = indirizzoArray;
    ciclo++;
  }
  numeroProgressivo++;
  ciclo = massimo;
  Serial.println("Esce da GSR");
  //while (1);
}

void visualizzaDatiArray(){
   salvanumeroProgressivo();
   Serial.println(" ");
   Serial.println("Entra in Array");
  for(indirizzoArray = 0; indirizzoArray < massimo; indirizzoArray++){
    int dato = myArray[indirizzoArray]; 
    Serial.print("\t indirizzo Array ");
    Serial.print(indirizzoArray);
    Serial.print("\t dato ");
    Serial.println(dato);
    delay(100);
    }
   Serial.print("ciclo scrittura EEprom ");
   Serial.println(ciclo);
   Serial.println("Esce da Array");
    //while (1);
}

void salvaDatiEEPROM(){ 
  Serial.println(" ");
  Serial.println("Inizia Scrittura");
  for(indirizzoArray = 0; indirizzoArray < maxArray; indirizzoArray++){
    int x = myArray[indirizzoArray];  
    uno = ((x >> 8) & 0xFF);
    due = (x & 0xFF);
    //uno = highByte(x);
    //due = lowByte(x);
    
    Wire.beginTransmission(0x50);
    Wire.write(highByte(indirizzoEEPROM));
    Wire.write(lowByte(indirizzoEEPROM));
    Wire.write(byte(uno));
    Wire.endTransmission();
    indirizzoEEPROM++; 
    delay(5); 
    
    Wire.beginTransmission(0x50);
    Wire.write(highByte(indirizzoEEPROM));
    Wire.write(lowByte(indirizzoEEPROM));
    Wire.write(byte(due));
    Wire.endTransmission();
    indirizzoEEPROM++; 
    delay(5);
    
    Serial.print("indindirizzo EEPROM ");
    Serial.print(indirizzoEEPROM);
    Serial.print("\t byte uno ");
    Serial.print(uno);
    Serial.print("\t byte due ");
    Serial.print(due);
    int dato1W = ((due << 0) & 0xFF) + ((uno << 8) & 0xFFFF);
    Serial.print("\t dato1W scritto ");
    Serial.print(dato1W);
    Serial.println(" ");
    indirizzoEEPROM++;
   }
    Serial.print("Fine scrittura");
    Serial.print("\t nuovo indindirizzo EEPROM ");
    Serial.println(indirizzoEEPROM);
    //while (1);
}

Leggo i dati del sensore GSR, li salvo momentaneamente in un Array,  poi leggo l'array e li salvo sulla eeprom.
Questa operazione si può ripetere anche per diverse volte.

EzioGi

[speedyant]

Io mi approccerei cercando di “capire” come scrivere nella eeprom, tanto per togliere il problema delle letture del sensore.

Una volta che sulla eeprom scrivo e leggo quello che voglio, penserei al sensore.

[eziogi]

Lo spunto per salvare su EEPROM l’ho preso da questo sketch, che mi funziona regolarmente.

/******************    Funziona!   *****************************
 * test_R/W_interi in 2byte 
 * SDA (A4), SCL (A5)
 * 12 gennaio 2026
 * Scrive e legge un intero in 2 celle consecutive della 24LC256
 ***************************************************************/
#include <Wire.h>

int indirizzo = 0;
int ciclo = 0;
int dato1 = 456;
int dato2 = 789;
int dato1W = 0;
int dato2W = 0;
int dato1R = 0;
int dato2R = 0;
byte uno = 0;
byte due = 0;

void setup(){
  Serial.begin(9600);
  Wire.begin();
  delay(1000);
  }

void loop(){
/*********************************** scrittura **************************************************/
  Serial.println(" ");
  Serial.println("Inizio Scrittura");
  //Serial.println(" ");
//-------------------- Primo dato scritto ------------------------------------- 
  uno = ((dato1 >> 8) & 0xFF);
  due = (dato1 & 0xFF);

    //invio il control byte specificando
    //una richiesta di scrittura del primo byte nella cella 0
    Wire.beginTransmission(0x50);    
    //invio due byte contenenti l'indirizzo della
    //locazione di memoria che voglio scrivere un byte
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));    
    //scrivo il primo byte nella locazione di memoria
    //precedentemente selezionata
    Wire.write(byte(uno));    
    //fine trasmissione
    Wire.endTransmission();    
    //incrementa il valore dell'indirizzo
    indirizzo++;
    //attendi 5ms per poter terminare le operazioni di
    //scrittura sulla memoria
    delay(5);

 //invio il control byte specificando
    //una richiesta di scrittura del secondo byte nella cella 1
    Wire.beginTransmission(0x50); 
    //invio due byte contenenti l'indirizzo della
    //locazione di memoria che voglio scrivere un byte
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));   
    //scrivo il secondo byte nella locazione di memoria
    //precedentemente selezionata
    Wire.write(byte(due));   
    //fine trasmissione
    Wire.endTransmission();  
    //incrementa il valore dell'indirizzo
    indirizzo++;
    //attendi 5ms per poter terminare le operazioni di
    //scrittura sulla memoria
    delay(5);
    
    Serial.print("uno ");
    Serial.print(uno);
    Serial.print(" due ");
    Serial.print(due);
    dato1W = ((due << 0) & 0xFF) + ((uno << 8) & 0xFFFF);
     Serial.print("\t dato1 scritto ");
     Serial.print(dato1W);
     Serial.print("   nuova cella ");
     Serial.println(indirizzo);

//-------------------- Secondo dato scritto -------------------------------------  
  uno = ((dato2 >> 8) & 0xFF);
  due = (dato2 & 0xFF);

    //invio il control byte specificando
    //una richiesta di scrittura del primo byte nella cella 2
    Wire.beginTransmission(0x50);    
    //invio due byte contenenti l'indirizzo della
    //locazione di memoria che voglio scrivere un byte
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));    
    //scrivo il primo byte nella locazione di memoria
    //precedentemente selezionata
    Wire.write(byte(uno));    
    //fine trasmissione
    Wire.endTransmission();    
    //incrementa il valore dell'indirizzo
    indirizzo++;
    //attendi 5ms per poter terminare le operazioni di
    //scrittura sulla memoria
    delay(5);

 //invio il control byte specificando
    //una richiesta di scrittura del secondo byte nella cella 3
    Wire.beginTransmission(0x50); 
    //invio due byte contenenti l'indirizzo della
    //locazione di memoria che voglio scrivere un byte
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));   
    //scrivo il secondo byte nella locazione di memoria
    //precedentemente selezionata
    Wire.write(byte(due));   
    //fine trasmissione
    Wire.endTransmission();  
    //incrementa il valore dell'indirizzo
    indirizzo++;
    //attendi 5ms per poter terminare le operazioni di
    //scrittura sulla memoria
    delay(5);
   Serial.print("uno ");
    Serial.print(uno);
    Serial.print(" due ");
    Serial.print(due);
    dato2W = ((due << 0) & 0xFF) + ((uno << 8) & 0xFFFF);
     Serial.print("\t dato2 scritto ");
     Serial.print(dato2W);
     Serial.print("   nuova cella ");
     Serial.println(indirizzo);
    delay(1000);
    
/*********************************** Lettura **************************************************/
//------------------- primo dato letto -------------------
  Serial.println(" ");
  Serial.println("Inizio lettura");
  //Serial.println(" ");
  indirizzo = 0;
  dato1 = 0;
  dato2 = 0;
   //invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte per selezionare la locazione
    //di memoria da leggere
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    Wire.endTransmission();
    //incremento la variabile indirizzo
    indirizzo++;
    //richiedo un byte al 24LC256
    Wire.requestFrom(0x50, 1);
    //attendo la disponibilità di dati sul bus i2c
    while (Wire.available())
    {
      //leggo dal bus il dato relativo alla
      //locazione di memoria precedentemente specificata
      uno = Wire.read();
    }
    
    //invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte per selezionare la locazione
    //di memoria da leggere
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    Wire.endTransmission();
    //incremento la variabile indirizzo
    indirizzo++;
    //richiedo un byte al 24LC256
    Wire.requestFrom(0x50, 1);
    //attendo la disponibilità di dati sul bus i2c
    while (Wire.available())
    {
      //leggo dal bus il dato relativo alla
      //locazione di memoria precedentemente specificata
      due = Wire.read();
     //invio il dato al serial monitor
      Serial.print("uno ");
      Serial.print(uno);
      Serial.print(" due ");
      Serial.print(due);
      dato1R = ((due << 0) & 0xFF) + ((uno << 8) & 0xFFFF);
      Serial.print("\t dato1 letto ");
      Serial.print(dato1R);
      Serial.print("  nuova cella ");
      Serial.println(indirizzo);
    }

//-------------------- secondo dato letto ---------------------------
//invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte per selezionare la locazione
    //di memoria da leggere
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    Wire.endTransmission();
    //incremento la variabile indirizzo
    indirizzo++;
    //richiedo un byte al 24LC256
    Wire.requestFrom(0x50, 1);
    //attendo la disponibilità di dati sul bus i2c
    while (Wire.available())
    {
      //leggo dal bus il dato relativo alla
      //locazione di memoria precedentemente specificata
      uno = Wire.read();
    }
    //invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte per selezionare la locazione
    //di memoria da leggere
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    Wire.endTransmission();
    //incremento la variabile indirizzo
    indirizzo++;
    //richiedo un byte al 24LC256
    Wire.requestFrom(0x50, 1);
    //attendo la disponibilità di dati sul bus i2c
    while (Wire.available())
    {
      //leggo dal bus il dato relativo alla
      //locazione di memoria precedentemente specificata
      due = Wire.read();
     //invio il dato al serial monitor
      Serial.print("uno ");
      Serial.print(uno);
      Serial.print(" due ");
      Serial.print(due);
      dato2R = ((due << 0) & 0xFF) + ((uno << 8) & 0xFFFF);
      Serial.print("\t dato2 letto ");
      Serial.print(dato2R);
      Serial.print("  nuova cella ");
      Serial.println(indirizzo);
    }
    while(1);        
  }

Non ho fatto altro che copiare la parte del salvataggio dei dati.

EzioGi

[eziogi]

Ho risolto togliendo:

 int dato1W = ((due << 0) & 0xFF) + ((uno << 8) & 0xFFFF);
    Serial.print("\t dato1W scritto ");
    Serial.print(dato1W);
    Serial.println(" ");
    //indirizzoEEPROM++;

l’istruziine //indirizzoEEPROM++;

EzioGi