Escribir y Leer conjunto de numeros en EEPROM

Hola, colegas, saludos.
Tengo una duda. Estoy haciendo unas prácticas y no he podido comprender algunas cosas referentes a la escritura de EEPROM y a la lectura de la misma.
He podido escribir y leer los datos pero el problema es el siguiente:
Si quiero guardar un numero, por ejemplo de 15 dígitos en la EEPROM, no me deja, solo puedo guardar 4 dígitos.
Quisiera saber de qué modo puedo almacenar este dato de 15 dígitos para después leerlo.
No sé si alguno tenga experiencia con este tipo de cosas.
He encontrado información pero no logro comprender bien cómo debe hacerse.

Este es el código:
C++:
#include <EEPROM.h>

int temperatura = 4448;
char cadena[] = "Dato almacenado";

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

  EEPROM.put(0, temperatura);
  EEPROM.put(10, cadena);

  Serial.println("Valor en direccion 0:");
  Serial.println( EEPROM.get(0, temperatura) );
  Serial.println(" ");

  Serial.println("Valor de la cadena en direccion 10:");
  Serial.println( EEPROM.get(10, cadena) );
}

void loop() {
}
 
Claro, lee la documentación y lo verás.
¿Que tamaño tiene int?
¿Que tamaño tiene lo que se mete en la eeprom?
¿Que datos maneja eeprom.xxx?
¿Como es de larga la cadena?

Si quieres guardar en un estante diez paquetes no caben, tendrás que poner un paquete en cada estante. Si solo das la orden de guardar una cosa en un estante, no se llna la estantería entera ni se meten dies cajas porque solo cabe una.

Por cierto:
- ¡Eh! tu ¿que haces ahí?
- He ido a por melones
 
Entiendo el problema, y si suponía que tendría que hacer algo así, la verdad jamas he usado arduino,pero creo que ya me despejaste ciertas dudas, gracias.
 
Es que él no lo dice pero está usando arduino.
Tampoco dice cual de ellos pero debe de ser uno de 8 bits porque el DUE no tiene eeprom
Y en los arduino de 8 bits las eeprom es así. Es de 8 bits y las funciones solo dejan leer y escribir un byte en la dirección que se indique, nada mas.
No sé si hay otros modelos con otra configuración de eeprom.
 
Gracias por sus comentarios,ya logre guardar informacion larga en la eeprom y leerla, pero ahora viene otro problema, estoy intentando leer un teclado 4x4 , configurando de tal modo que yo ingreso datos que se van formando en cadena, y con un switch escribirlos en la eeprom, algo asi como para guardar contraseñas,subo avances en cuanto pueda, he leido tanto estos dias que no se por donde empezar, estoy haciendo practicas del tema en este momento, gracias por las respuestas.
PD: Estoy usando arduino nano
 
Este es el avance que llevo;
Con el keypad ingreso una serie de numeros y estos se muestran en serie en la pantalla(hasta aqui todo bien) pero estoy intentando hacer que al presionar cierto boton, estos datos se guarden en la eeprom, el problema esta en que no se en que punto del codigo meter esta funcion, si con la expresion if etc, bueno sigo en el desarrollo, saludos.
Código:
#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <Keypad.h>
#define ANCHO 128
#define ALTO 32

#define OLED_RESET 4
Adafruit_SSD1306 oled(ANCHO, ALTO, &Wire, OLED_RESET);

String pad;
const byte numRows= 4;
const byte numCols= 4;
char keymap[numRows][numCols]=
{
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
//------------------------------------------------------------
byte rowPins[numRows] = {9,8,7,6};
byte colPins[numCols] = {5,4,3,2};
Keypad myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols); //mapping keypad
void setup() {
  Serial.begin(9600);
  // put your setup code here, to run once:
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
}
void loop() {
  // put your main code here, to run repeatedly:
  bacaKeypad();
  oled.clearDisplay();
  oled.setTextColor(WHITE);
  oled.setCursor(0, 0);
  oled.setTextSize(2);
  oled.print(pad);
  oled.display();
  delay(100);
}
void bacaKeypad() {
  char keypressed = myKeypad.getKey(); //deteksi penekanan keypad
  String konv = String(keypressed);
  pad+=konv;
}
 
Agrego aquí un tema relacionado:
Lectura y grabación de valores de punto flotante en la EEPROM de un PIC

Como resultado de una charla en otro de los foros surgió la duda acerca de cómo proceder cuando se quiere grabar y leer valores de punto flotante en una EEPROM.
La misma dificultad existe si se tiene que transmitir ese dato por un enlace serial que envía de a un BYTE.
Como me puse a probar y encontré algunos problemas me pareció que podría ser de interés para quien trabaja todavía con los
PIC 16F877A y similares.
Estoy programando con MPLAB y el plugin de HI-TECH C. El compilador tiene sus bemoles pero luego rezongar un rato se pueden superar
las dificultades.
Acá dejo un código que hice de prueba para leer y grabar una matriz de 2x3 en la EEPROM.
Los comentarios en el código se explican solos.
La razón de utilizar una matriz es porque en el caso de los coeficientes de una red neuronal (RN) se requieren números de punto flotante.
El archivo es PRUEBA_CON_UNION.TXT y para compilarse se debe cambiar la extensión "TXT" a "C".

También subo el código de una aplicación que hace uso de esa forma de usar la EEPROM.
Aclaro que es una idea en desarrollo. Algunos aspectos no están definidos del todo así que cada uno puede adaptarlo a algo similar
para que le sirva.
Dentro del código se describe la aplicación:

//-----------------------------------------------------------------------------------------------
// Lápiz Optico con PIC y una red neuronal (RN)
//-----------------------------------------------------------------------------------------------
// Recursos empleados:
//
// - PIC16F877A (>= 28 pines)
// - Acceso a EEPROM (<= 24 bytes)
// - Conversión A/D (<= 6 canales)
// - TX-RX serial UART/RS232
//
// Funcionamiento:
//
// Calibración:
// El mirco dibuja un punto en coordenadas (x,y) en una pantalla y envía las coordenadas
// por el puerto serial a una PC. Un puntero LED emisor se coloca sobre el punto dibujado
// y a medida que se leen las entradas analógicas también se las va envíando por el puerto
// serial hacia la PC donde se entrenará la red neuronal. Este proceso no puede hacerse el
// el pic por falta de memoria para almacenar el conjunto de datos de entrenamiento.
//
// Inicialización:
// Terminado el entrenamiento en la PC, ésta envía los pesos de la red al PIC, que los
// recibe y guarda en EEPROM.
//
// Uso como lápiz lector:
// Al bootear, el PIC lee de la EEPROM los pesos y los copia en la/las matrices de la RN.
// Hecho esto lee los valores de las entradas, calcula la posición del punto en la pantalla
// y lo dibuja. La pantalla usada puede ser un display o un monitor de la misma PC
// empleada para el entrenamiento.
//-----------------------------------------------------------------------------------------------

Los archivos de esta aplicación se muestran en la imagen del proyecto de MPLAB.
El código de "calibración.c" se los debo porque todavía no pasó la etapa de pruebas.

Proyecto.png PIC16F877A.png
 

Adjuntos

  • PRUEBA_CON_UNION.txt
    2.3 KB · Visitas: 5
  • rutinas_h.txt
    2.6 KB · Visitas: 0
  • ppal_c.txt
    3 KB · Visitas: 0
  • rutinas_c.txt
    3.8 KB · Visitas: 1
  • uart_c.txt
    696 bytes · Visitas: 0
Última edición:
Este sería una aproximación al esquemático. Los resistores de los fototransistores están sujetos a cambios luego de las pruebas.
esquematico.png
 
Arriba