Problema con almacenamiento de datos en EEPROM

Muy buenas, estoy utilizando un Arduino UNO y estoy almacenando unos datos en la EEPROM utilizando la librería EEPROM.h, todo va perfecto escribiendo y leyendo los datos en la placa del UNO. El detalle viene cuando quito el micro para usarlo en otra tarjeta que yo desarrollé y es que si le subo un código que escriba y luego lea los datos, los lee perfectamente, pero cuando le subo un código donde sólo lea lo que contiene en la EEPROM, lee datos que no son entonces no sé qué está pasando.

El código que estoy implementando es el siguiente:

#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
SoftwareSerial serial2(12, 13); // RX, TX

String num1, ContraAnt;
int unidad, contraEscr, Gal = 0, Contra = 1234;
float factor_conversion, num1Float, Vol = 2.5, Fac = 11.5;

void setup() {
  Serial.begin(9600);
  serial2.begin(9600);
  lcd.begin(20,4);
  //EEPROMWriteInt(0,Gal);      //Galones
  //EEPROMWriteFloat(2,Fac);  //Factor de conversion
  //EEPROMWriteFloat(6,Vol);   //Volumen
  //EEPROMWriteInt(10,Contra);   //Contraseña
  
  unidad = EEPROMReadInt(0);
  factor_conversion = EEPROMReadFloat(2);
  num1Float = EEPROMReadFloat(6);
  num1 = String(num1Float);
  contraEscr = EEPROMReadInt(10);
  ContraAnt = String(contraEscr);

  Serial.print("Unidad: ");
  Serial.println(unidad);
  Serial.print("Factor de Conversion: ");
  Serial.println(factor_conversion);
  Serial.print("Volumen: ");
  Serial.println(num1Float);
  Serial.print("Volumen String: ");
  Serial.println(num1);
  Serial.print("Contrasena: ");
  Serial.println(contraEscr);
  Serial.print("Contrasena String: ");
  Serial.println(ContraAnt);

  serial2.print("Unidad: ");
  serial2.println(unidad);
  serial2.print("Factor de Conversion: ");
  serial2.println(factor_conversion);
  serial2.print("Volumen: ");
  serial2.println(num1Float);
  serial2.print("Volumen String: ");
  serial2.println(num1);
  serial2.print("Contrasena: ");
  serial2.println(contraEscr);
  serial2.print("Contrasena String: ");
  serial2.println(ContraAnt);

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("unidad: ");
  lcd.print(unidad);
  lcd.setCursor(0,1);
  lcd.print("FactorConv: ");
  lcd.print(factor_conversion);
  lcd.setCursor(0,2);
  lcd.print("Volumen: ");
  lcd.print(num1);
  lcd.setCursor(0,3);
  lcd.print("Contrasena: ");
  lcd.print(ContraAnt);

}

//================================ UNIONES ========================================
union Float_Byte {
  float datoF;
  byte  datoB[4];
} unionFB;

union Integer_Byte {
  int  datoI;
  byte datoB[2];
} unionIB;

void loop() {
  serial2.print("Unidad: ");
  serial2.println(unidad);
  serial2.print("Factor de Conversion: ");
  serial2.println(factor_conversion);
  serial2.print("Volumen: ");
  serial2.println(num1Float);
  serial2.print("Volumen String: ");
  serial2.println(num1);
  serial2.print("Contrasena: ");
  serial2.println(contraEscr);
  serial2.print("Contrasena String: ");
  serial2.println(ContraAnt);
  delay(1500);
  
}

//========================== ESCRIBIR ENTERO EN EEPROM ===========================

void EEPROMWriteInt(int direccion, int dato) {

  unionIB.datoI = dato;

  // guardar un float en la EEPROM en las posiciones 0-3
  EEPROM.update(direccion     , unionIB.datoB[0]);
  EEPROM.update(direccion + 1 , unionIB.datoB[1]);
}

//========================== ESCRIBIR FLOAT EN EEPROM =============================

void EEPROMWriteFloat(int direccion, float dato) {

  unionFB.datoF = dato ;

  // guardar un float en la EEPROM en las posiciones 0-3
  EEPROM.update(direccion     , unionFB.datoB[0]);
  EEPROM.update(direccion + 1 , unionFB.datoB[1]);
  EEPROM.update(direccion + 2 , unionFB.datoB[2]);
  EEPROM.update(direccion + 3 , unionFB.datoB[3]);
}

//============================ LEER ENTERO EN EEPROM ==============================

int EEPROMReadInt(int direccion) {

  unionIB.datoI = 0;

  unionIB.datoB[0] = EEPROM.read(direccion);
  unionIB.datoB[1] = EEPROM.read(direccion + 1);

  return unionIB.datoI;
}

//============================ LEER FLOAT EN EEPROM ===============================

float EEPROMReadFloat(int direccion) {

  unionFB.datoF = 0.0 ;

  unionFB.datoB[0] = EEPROM.read(direccion);
  unionFB.datoB[1] = EEPROM.read(direccion + 1);
  unionFB.datoB[2] = EEPROM.read(direccion + 2);
  unionFB.datoB[3] = EEPROM.read(direccion + 3);

  return unionFB.datoF;
}

La visualización de los datos los hago por 3 partes diferentes sólo por lo que dije de que lo estoy utilizando por fuera de la placa Arduino.

Te quedaste en el tiempo con tu implementación de EEPROMread y EEPROMwrite.

Lee esto EEPROM.get y EEPROM.put

Estas dos funciones hacen con mucha facilidad lo que has implementado. Se cuidadoso y funcionarán correctamente.

Hola surbyte he hecho el cambio a get y put y sigo teniendo el mismo problema. Cuando lo pruebo en la placa de arduino funciona bien el leer los datos de la EEPROM, pero cuando lo coloco por fuera de la placa de Arduino, lee valores erróneos, así que no sé si sea un problema en el hardware, mis conexiones con el microcontrolador son estas:

Yo programo el microcontrolador por SPI.

Las pruebas que estoy haciendo son:

  1. Descomento las funciones EEPROMWrite para escribir los datos en la EEPROM y luego leerlas y visualizarlas (esto funciona perfecto). Lee los datos correctamente.
  2. Comento nuevamente las funciones de EEPROMWrite para confirmar que los datos quedaron debidamente guardados como son. (Esto sólo me funciona si lo hago con la placa Arduino).

El código con el get y put quedó así:

#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
SoftwareSerial serial2(12, 13); // RX, TX

String num1, ContraAnt;
int unidad, contraEscr, Gal = 0, Contra = 1234;
float factor_conversion, num1Float, Vol = 2.5, Fac = 11.5;

void setup() {
  Serial.begin(9600);
  serial2.begin(9600);
  lcd.begin(20,4);
  //EEPROMWriteInt(0,Gal);      //Galones
  //EEPROMWriteFloat(2,Fac);  //Factor de conversion
  //EEPROMWriteFloat(6,Vol);   //Volumen
  //EEPROMWriteInt(10,Contra);   //Contraseña
  
  unidad = EEPROMReadInt(0);
  factor_conversion = EEPROMReadFloat(2);
  num1Float = EEPROMReadFloat(6);
  num1 = String(num1Float);
  contraEscr = EEPROMReadInt(10);
  ContraAnt = String(contraEscr);

  Serial.print("Unidad: ");
  Serial.println(unidad);
  Serial.print("Factor de Conversion: ");
  Serial.println(factor_conversion);
  Serial.print("Volumen: ");
  Serial.println(num1Float);
  Serial.print("Volumen String: ");
  Serial.println(num1);
  Serial.print("Contrasena: ");
  Serial.println(contraEscr);
  Serial.print("Contrasena String: ");
  Serial.println(ContraAnt);

  serial2.print("Unidad: ");
  serial2.println(unidad);
  serial2.print("Factor de Conversion: ");
  serial2.println(factor_conversion);
  serial2.print("Volumen: ");
  serial2.println(num1Float);
  serial2.print("Volumen String: ");
  serial2.println(num1);
  serial2.print("Contrasena: ");
  serial2.println(contraEscr);
  serial2.print("Contrasena String: ");
  serial2.println(ContraAnt);

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("unidad: ");
  lcd.print(unidad);
  lcd.setCursor(0,1);
  lcd.print("FactorConv: ");
  lcd.print(factor_conversion);
  lcd.setCursor(0,2);
  lcd.print("Volumen: ");
  lcd.print(num1);
  lcd.setCursor(0,3);
  lcd.print("Contrasena: ");
  lcd.print(ContraAnt);

}

//================================ UNIONES ========================================
union Float_Byte {
  float datoF;
  byte  datoB[4];
} unionFB;

union Integer_Byte {
  int  datoI;
  byte datoB[2];
} unionIB;

void loop() {
  serial2.print("Unidad: ");
  serial2.println(unidad);
  serial2.print("Factor de Conversion: ");
  serial2.println(factor_conversion);
  serial2.print("Volumen: ");
  serial2.println(num1Float);
  serial2.print("Volumen String: ");
  serial2.println(num1);
  serial2.print("Contrasena: ");
  serial2.println(contraEscr);
  serial2.print("Contrasena String: ");
  serial2.println(ContraAnt);
  delay(1500);
  
}

//========================== ESCRIBIR ENTERO EN EEPROM ===========================

void EEPROMWriteInt(int direccion, int dato) {

  unionIB.datoI = dato;

  // guardar un float en la EEPROM en las posiciones 0-3
  EEPROM.put(direccion     , unionIB.datoB[0]);
  EEPROM.put(direccion + 1 , unionIB.datoB[1]);
}

//========================== ESCRIBIR FLOAT EN EEPROM =============================

void EEPROMWriteFloat(int direccion, float dato) {

  unionFB.datoF = dato ;

  // guardar un float en la EEPROM en las posiciones 0-3
  EEPROM.put(direccion     , unionFB.datoB[0]);
  EEPROM.put(direccion + 1 , unionFB.datoB[1]);
  EEPROM.put(direccion + 2 , unionFB.datoB[2]);
  EEPROM.put(direccion + 3 , unionFB.datoB[3]);
}

//============================ LEER ENTERO EN EEPROM ==============================

int EEPROMReadInt(int direccion) {

  unionIB.datoI = 0;

  EEPROM.get(direccion, unionIB.datoB[0]);
  EEPROM.get(direccion + 1, unionIB.datoB[1]);

  return unionIB.datoI;
}

//============================ LEER FLOAT EN EEPROM ===============================

float EEPROMReadFloat(int direccion) {

  unionFB.datoF = 0.0 ;

  EEPROM.get(direccion, unionFB.datoB[0]);
  EEPROM.get(direccion + 1, unionFB.datoB[1]);
  EEPROM.get(direccion + 2, unionFB.datoB[2]);
  EEPROM.get(direccion + 3, unionFB.datoB[3]);

  return unionFB.datoF;
}

Nooooo noooo como vas a usar tus rutinas con .get o .put

EEPROM.get y EEPROM.put hacen lo que tus rutinas EEPROMWriteInt con uino float, etc hacen..

Viste los ejemplos?
Crea una estructura con todo menos String dentro de ella
Y luego lo salvas en EEPROM con EEPROM.put y lo lees con EEPROM.get

Esto es lo que debes usar y verifica las direcciones

//========================== ESCRIBIR ENTERO EN EEPROM ===========================

void EEPROMWriteInt(int direccion, int dato) {

    EEPROM.put(direccion, dato);
}

//========================== ESCRIBIR FLOAT EN EEPROM =============================

void EEPROMWriteFloat(int direccion, float dato) {

  // guardar un float en la EEPROM en las posiciones 0-3
  EEPROM.put(direccion     , dato);
}

//============================ LEER ENTERO EN EEPROM ==============================

int EEPROMReadInt(int direccion) {
  int tmp;

  return EEPROM.get(direccion, tmp);
}

//============================ LEER FLOAT EN EEPROM ===============================

float EEPROMReadFloat(int direccion) {

  float tmp;

  return EEPROM.get(direccion, tmp);
}

Ohh que bruto soy jaja lo siento, ya lo he colocado como me dices. Me quedó el código así:

#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
SoftwareSerial serial2(12, 13); // RX, TX

String num1, ContraAnt;
int unidad, contraEscr, Gal = 0, Contra = 1234;
float factor_conversion, num1Float, Vol = 2.5, Fac = 11.5;

void setup() {
  Serial.begin(9600);
  serial2.begin(9600);
  lcd.begin(20,4);
  //EEPROMWriteInt(0,Gal);      //Galones
  //EEPROMWriteFloat(2,Fac);  //Factor de conversion
  //EEPROMWriteFloat(6,Vol);   //Volumen
  //EEPROMWriteInt(10,Contra);   //Contraseña
  
  unidad = EEPROMReadInt(0);
  factor_conversion = EEPROMReadFloat(2);
  num1Float = EEPROMReadFloat(6);
  num1 = String(num1Float);
  contraEscr = EEPROMReadInt(10);
  ContraAnt = String(contraEscr);

  Serial.print("Unidad: ");
  Serial.println(unidad);
  Serial.print("Factor de Conversion: ");
  Serial.println(factor_conversion);
  Serial.print("Volumen: ");
  Serial.println(num1Float);
  Serial.print("Volumen String: ");
  Serial.println(num1);
  Serial.print("Contrasena: ");
  Serial.println(contraEscr);
  Serial.print("Contrasena String: ");
  Serial.println(ContraAnt);

  serial2.print("Unidad: ");
  serial2.println(unidad);
  serial2.print("Factor de Conversion: ");
  serial2.println(factor_conversion);
  serial2.print("Volumen: ");
  serial2.println(num1Float);
  serial2.print("Volumen String: ");
  serial2.println(num1);
  serial2.print("Contrasena: ");
  serial2.println(contraEscr);
  serial2.print("Contrasena String: ");
  serial2.println(ContraAnt);

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("unidad: ");
  lcd.print(unidad);
  lcd.setCursor(0,1);
  lcd.print("FactorConv: ");
  lcd.print(factor_conversion);
  lcd.setCursor(0,2);
  lcd.print("Volumen: ");
  lcd.print(num1);
  lcd.setCursor(0,3);
  lcd.print("Contrasena: ");
  lcd.print(ContraAnt);

}

void loop() {
  serial2.print("Unidad: ");
  serial2.println(unidad);
  serial2.print("Factor de Conversion: ");
  serial2.println(factor_conversion);
  serial2.print("Volumen: ");
  serial2.println(num1Float);
  serial2.print("Volumen String: ");
  serial2.println(num1);
  serial2.print("Contrasena: ");
  serial2.println(contraEscr);
  serial2.print("Contrasena String: ");
  serial2.println(ContraAnt);
  delay(1500);
  
}

//========================== ESCRIBIR ENTERO EN EEPROM ===========================

void EEPROMWriteInt(int direccion, int dato) {

    EEPROM.put(direccion, dato);
}

//========================== ESCRIBIR FLOAT EN EEPROM =============================

void EEPROMWriteFloat(int direccion, float dato) {

  // guardar un float en la EEPROM en las posiciones 0-3
  EEPROM.put(direccion     , dato);
}

//============================ LEER ENTERO EN EEPROM ==============================

int EEPROMReadInt(int direccion) {
  int tmp;

  return EEPROM.get(direccion, tmp);
}

//============================ LEER FLOAT EN EEPROM ===============================

float EEPROMReadFloat(int direccion) {

  float tmp;

  return EEPROM.get(direccion, tmp);
}

Sin embargo, sigue teniendo el mismo fallo.

Me pude dar cuenta de una cosa y es que cuando le subo el código por medio de la placa arduino me funciona correctamente, pero cuando lo hago por SPI el código no funciona como debe. No sé qué tendrá que ver esto.

Ojo.. yo no analice las direcciones, porque debes ver ahora el tamaño del tipo de datos que uses y eso condiciona la posición de memoria.

Prueba los ejemplos .get y .put con tu placa a ver si lee bien o no.

Esto devuelve bien los datos, seguilo después de lo que hice.

#include <EEPROM.h>

String num1, ContraAnt;
int unidad;
int contraEscr;
int Gal = 0;
int Contra = 1234;

float factor_conversion, num1Float; 
float Vol = 2.5;
float Fac = 11.5;
int eeAddress = 0;

void setup() {
  Serial.begin(9600);

  EEPROM.put(0, Gal);      	//Galones int
  eeAddress += sizeof(int);
  Serial.print("Gal Address: "+String(eeAddress));
  EEPROM.put(eeAddress, Fac);  //Factor de conversion float
  eeAddress += sizeof(float);
  Serial.print("Fac Address: "+String(eeAddress));
  EEPROM.put(eeAddress, Vol);   //Volumen
  eeAddress += sizeof(float);
  Serial.print("Vol Address: "+String(eeAddress));
  EEPROM.put(10, Contra);   //Contraseña
  eeAddress += sizeof(int);
  Serial.print("Contra Address: "+String(eeAddress));

  eeAddress = 0;
  EEPROM.get(0, unidad);
  eeAddress += sizeof(int);
  
  EEPROM.get(eeAddress, factor_conversion);
  Serial.print("Address: "+String(eeAddress));
  eeAddress += sizeof(float);

  EEPROM.get(eeAddress, num1Float);
  Serial.print("Address: "+String(eeAddress));
  eeAddress += sizeof(float);
  
  EEPROM.get(eeAddress, contraEscr);
  Serial.print("Address: "+String(eeAddress));
  eeAddress += sizeof(int);

  Serial.print("Unidad: ");
  Serial.println(unidad);
  Serial.print("Factor de Conversion: ");
  Serial.println(factor_conversion);
  Serial.print("Volumen: ");
  Serial.println(num1Float);
  Serial.print("Volumen String: ");
  Serial.println(num1);
  Serial.print("Contrasena: ");
  Serial.println(contraEscr);
}


void loop() {
  Serial.print("Unidad: ");
  Serial.println(unidad);
  Serial.print("Factor de Conversion: ");
  Serial.println(factor_conversion);
  Serial.print("Volumen: ");
  Serial.println(num1Float);
  Serial.print("Volumen String: ");
  Serial.println(num1);
  Serial.print("Contrasena: ");
  Serial.println(contraEscr);

  delay(1500);
  
}