Leer memoria EEPROM con Arduino

#1
Hola, estoy trabajando con una memoria 24c32 por protocolo i2c cuyo master es una placa arduino uno.

Tengo que guardar el valor de una variable, la cual debo leer al encender el arduino, para esto uso la eeprom serial.

La variable es de tipo entero, entonces aquí viene mi problema y mi pregunta:

¿Se debe convertir siempre a formato byte, el dato a guardar en la eeprom?, si es así, ¿Cómo se hace esto?

Como referencia dejo este ejemplo del autor de la librería que estoy usando.

Código:
/**************************************************************************//**
 * \brief EEPROM 24C32 / 24C64 library for Arduino - Demonstration program
 * \author Copyright (C) 2012  Julien Le Sech - www.idreammicro.com
 * \version 1.0
 * \date 20120218
 *
 * This file is part of the EEPROM 24C32 / 24C64 library for Arduino.
 *
 * This library is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option) any
 * later version.
 * 
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see http://www.gnu.org/licenses/
 ******************************************************************************/

/**************************************************************************//**
 * \file WriteReadByte.ino
 ******************************************************************************/
 
/******************************************************************************
 * Header file inclusions.
 ******************************************************************************/

#include <Wire.h>

#include <Eeprom24C32_64.h>

/******************************************************************************
 * Private macro definitions.
 ******************************************************************************/

/**************************************************************************//**
 * \def EEPROM_ADDRESS
 * \brief Address of EEPROM memory on TWI bus.
 ******************************************************************************/
#define EEPROM_ADDRESS  0x50

/******************************************************************************
 * Private variable definitions.
 ******************************************************************************/

static Eeprom24C32_64 eeprom(EEPROM_ADDRESS);

/******************************************************************************
 * Public function definitions.
 ******************************************************************************/

/**************************************************************************//**
 * \fn void setup()
 *
 * \brief
 ******************************************************************************/
void setup()
{
    // Initialize serial communication.
    Serial.begin(9600);
        
    // Initialize EEPROM library.
    eeprom.initialize();

    const word address = 0;
    
    // Write a byte at address 0 in EEPROM memory.
    Serial.println("Write byte to EEPROM memory...");
    eeprom.writeByte(address, 0xAA);
    
    // Write cycle time (tWR). See EEPROM memory datasheet for more details.
    delay(10);
    
    // Read a byte at address 0 in EEPROM memory.
    Serial.println("Read byte from EEPROM memory...");
    byte data = eeprom.readByte(address);
    
    // Print read byte.
    Serial.print("Read byte = 0x");
    Serial.print(data, HEX);
    Serial.println("");
}

/**************************************************************************//**
 * \fn void loop()
 *
 * \brief
 ******************************************************************************/
void loop()
{

}
 
#2
Si lo conviertes pierdes precisión. Guarda los dos o cuatro bytes que ocupa la variable.
Otra cosa es que con un byte o char te sirva

 
#3
asi es yo no se como se hace eso en arduino

pero depende que tipo de entero estas trabajando, 16 o 32 bits

en caso de 16 bits debes guardar los 2 bytes pero para eso debes dividir el entero en 2 bytes o 3 unsigned char.

en el caso de 32 bits debes hacer lo mismo pero dividiendolo 4 veces
 
#4
Las variables a guardar en la eeprom son de tipo entero, pues son números de horas (hh:mm).

hh puede tomar valores de 0 hasta 23 y mm puede tomar valores de 0 hasta 59.

por ejemplo, digamos que en cierto momento sea: int hh = 21;

como guardo dicho valor en la eeprom 24c32? si no saben como se hace en arduino, por favor den una idea para pic en ccs, y yo tomo el concepto y lo paso al respectivo código para arduino.

Gracias.
 
#5
Si los valores no sobrepasan el Byte (255) los puedes guardar sin ningún problema.
Cada valor en una locación de memoria.
No sé como sean las variables en arduino, pero necesitas una variable del tipo Byte
 
#7
El identificador de las memorias EEPROM I2C 24LCXXX es 0xA0 para la primera del bus. (Pines A0, A1 y A2 a nivel 0.)
Con esos pines se configura la selección de cada memoria en el bus.
 
#8
El identificador de las memorias EEPROM I2C 24LCXXX es 0xA0 para la primera del bus. (Pines A0, A1 y A2 a nivel 0.)
Con esos pines se configura la selección de cada memoria en el bus.
Hola D@rkbytes tuve que coloque el identificador 0x50 para que funcionara la 24c32 (si la que trae el modulo tiny rtc)

Ademas leí los datos de la memoria así:
eeprom.readByte(direccion_de_la_memoria_donde_esta_el_dato);

y los escribí así:
eeprom.writeByte(direccion_de_la_memoria_donde_va_quedar_el_dato, variable_a_guardar); ojo: variable_a_guardar <=255 en el caso de un numero entero.

Gracias.
 
Arriba