LEER UN CHAR DE LA EEPROM

[mgonzy]

Hola buenas tardes, quisiera ver si me pueden ayudar en un problema que tengo al leer un char de la eeprom.
El tema es el siguiente, Recibo desde un modulo gsm al  puerto serie del PIC (18f4550)un valor de 24 elementos por ejemplo 55cf91e97625425c93a9e3c1 a este valor lo guardo en un char llamado Id0 quedando de esta manera:
 
                   Id0[0]=   USART_buffer[50];
                   Id0[1]=   USART_buffer[51];
                   Id0[2]=   USART_buffer[52];
                   Id0[3]=   USART_buffer[53];
                   Id0[4]=   USART_buffer[54];
                   Id0[5]=   USART_buffer[55];
                   Id0[6]=   USART_buffer[56];
                   Id0[7]=   USART_buffer[57];
                   Id0[8]=   USART_buffer[58];
                   Id0[9]=   USART_buffer[59];
                   Id0[10]=  USART_buffer[60];
                   Id0[11]=  USART_buffer[61];
                   Id0[12]=  USART_buffer[62];
                   Id0[13]=  USART_buffer[63];
                   Id0[14]=  USART_buffer[64];
                   Id0[15]=  USART_buffer[65];
                   Id0[16]=  USART_buffer[66];
                   Id0[17]=  USART_buffer[67];
                   Id0[18]=  USART_buffer[68];
                   Id0[19]=  USART_buffer[69];
                   Id0[20]=  USART_buffer[70];
                   Id0[21]=  USART_buffer[71];
                   Id0[22]=  USART_buffer[72];
                   Id0[23]=  USART_buffer[73];

luego hago el sig codigo :

char sms[25];

printf("id sin guardar: %s",id0);
printf("\n");
write_eeprom(0,id0); // guardo el valor en la eeprom
delay_ms(1000);

strcpy(sms,read_eeprom(0));
imprimir (sms);


////////////////////
void imprimir (char *cad)
{
printf ("id guardado: %s",cad);
}


///////////////////////////////Compilado con css
la salida es :

id sin guardar: 55cf91e97625425c93a9e3c1
                                                               id guardado: 55cf91e97625425c93a9e3

////////////////////////

Se observa que faltan los 2 últimos valores, no se por q pasa eso, probé con longitudes mas pequeñas y siempre es lo mismo, faltan los 2 ultimos.
La verdad es q tampoco se como hace la eeprom para guardad semejante valor en una sola posicion de memoria. Quisiera saber que estoy haciendo mal, o si hay alguna manera mejor de hacerlo. Desde ya muchas gracias


Agrego un poco mas de info para interpretar mejor el escenario: salida que obtuve es lo que me sale por el hiperterminal de la pc.
El vector USART_BUFFER se llena cada ves que ocurre una interrupcion por el puerto serie, es un vector de 120 elementos.

[mgonzy]

Agrego un poco mas de info para interpretar mejor el escenario: salida que obtuve es lo que me sale por el hiperterminal de la pc.
El vector USART_BUFFER se llena cada ves que ocurre una interrupcion por el puerto serie, es un vector de 120 elementos.

[KILLERJC]

El vector USART_BUFFER se llena cada ves que ocurre una interrupcion por el puerto serie, es un vector de 120 elementos.

Creo que tenes un error, la interrupcion de la UART es por caracter, a pesar que tengas una FIFO de 2 char.
Lamentablemente vos no agregaste nada de como es que se guardan los datos en la eeprom. Lo cual puede ser ese el problema.

Tampoco entiendo por que usarias la eeprom para guardar el buffer de la UART, seria quemar la eeprom para eso..
En fin.. No te puedo decir nada por que falta codigo, en especial el que guarda lo de la UART al buffer que sea. Es por interrupcion ?
Esto para asegurarse que sea correcto que se guarda bien en el buffer los datos

No se si es correcto usar strcpy para sacar todos los datos de la eeprom, al menos no me doy cuenta como funcionaria.

[mgonzy]

Hola, quise explicar a modo general lo q hace el codigo, ya que el codigo completo es muy largo, Tratare de explicarlo mejor.
tengo un pic (18f4550)  conectado a un modulo gms, al modulo le llega mediante un mensaje de texto un numero alfanumerico (el Id) cdo el sms llega al modulo gsm lo envia por su puerto serie y este lo envia al puerto serie del pic, el codigo que tengo implementado en el pic toma los valores que le llegan y va guardando caracter por caracter en un vector que llame USART_BUFFER, luego que se guardo todos los datos , yo se que a partir de la posicion 50 del vector USART_BUFFER tengo el cuerpo del mensaje recibido (o sea el ID).

es por eso que luego hago Id[0]= USART_BUFFER [50]
                                       Id[1]= USART_BUFFER [51]
                                        ...
                                        ....


Lo explicado hasta aqui funciona todo bien, el modulo gsm lo diseño yo, puedo configurarlo con una app android que hice yo tambien. Tambien puedo enviar los datos de a una pagina llamada ubidots, en fin todo funciona bien.... salvo que no puedo leer de la  eeprom
esos caracteres alfanumericos que mencione. Espero se entienda jeje

ahhh lo de strcpy  es la unica manera que encontre yo para leer el char que guarde, el compilador me da erros si hago   sms= read_eeprom(0)

desde ya muchas gracias... me falta solo corregir esa falla y terminare mi proyecto de tesis

[KILLERJC]

Imagino que esto es CCS (Sino lo que digo no es valido), Tu mayor problema es que estas guardando la direccion y no todo el contenido en la EEPROM, Si lees el manual, write_eeprom y read-eeprom solo aceptan numeros y no punteros a strings, etc. Si pones el puntero solo vas a enviar la "direccion" de lo que tenias.

Paso de arrays:

Código: C

1. int i;
2. for ( i=0; i<24; i++) Id0[i] = USART_buffer[i+50];
3. id0[24] = '\0';

Guardado en eeprom:

Código: C

1. for ( i=0; i<24; i++) write_eeprom(i,Id0[i]);

Lectura de la eeprom

Código: C

1. char sms[25]
2.  
3. for ( i=0; i<24; i++) sms[i] = read_eeprom(i);
4. sms[24]= '\0';

Ademas le agrego el caracter nulo al final si usas printf, asi sabe cuando se termina el string.

 sms= read_eeprom(0)

Si sms es un array es obvio que te va a dar error, sms es la representacion del puntero al array, es lo mismo que hacer &sms[0] = read_eeprom(0)
Error no te hubiera dado si hacias sms[0] = read_eeprom

[mgonzy]

Muchas gracias por tu ayuda  ... Creo que lo q me mencionas ya lo e intentado, de todas maneras en unos minutos pruebo de nuevo y te dire los resultados .... muchas gracias por tu tiempo

[mgonzy]

Hola.... hice lo q me propusiste y aun tengo el mismo resultado, faltan los 2 ultimos caracteres  ... no entiendo por que pasa eso. Vale aclarar que el proteus sale todo bien, pero al probarlo con hiperterminal de la pc no funciona.
Lo mas gracioso es que a modo de verificacion puse

printf ("%c" "%c", sms[22]sms[23]) // sms [22] y sms[23] son los ultimos 2 caracteres

y no se visualiza nada

[KILLERJC]

entonces  tenes un problema con el grabado de la eeprom, o el guardado, intenta hacer un


int i;
for ( i=0; i<24; i++) Id0 = USART_buffer[i+50];
Id0[24] = '\0';

printf("%s",Id0);

Asi sabemos que en USART_buffer realmente esta ese valor. No creo que este mal la EEPROM del PIC.

[mgonzy]

hola, eso si funciona bien, el codigo q hice yo da como resultado esto

id sin guardar: 55cf91e97625425c93a9e3c1
                                                               id guardado: 55cf91e97625425c93a9e3

esto lo puse al comenzar el tema.

O sea el dato llega bien al usar_buffer y se almacena de manera correcta en la variable id0[25],
el problema ocurre cuando se trata de leer el dato de la eeprom, luego del gravado en la eeprom. Yo creo q se grava bien pero se lee mal (siempre faltan los 2 ultimos caracteres)
es mas si gravo el este valor  55cf91e97625425c93a9e3c100 al leerlo obtengo 55cf91e97625425c93a9e3c1, o sea sin los ceros al ultimo.
Como bien vos decis,  segun el manual write_eeprom graba valores enteros, pero aqui en el foro vi gente q lo usa para gravar char, pero al parecer no funca

[KILLERJC]

char, enteros a vos no te importa, siempre y cuando sean de 8 bits, los cuales un int8 y un char son de 8bits.

Proba ponerlo en otra posicion de memoria

Graba:

Código: C

1. for ( i=0; i<24; i++) write_eeprom(i+50,Id0[i]);

Lee

Código: C

1. char sms[25]
2.  
3. for ( i=0; i<24; i++) sms[i] = read_eeprom(i+50);
4. sms[24]= '\0';

Que comienze de la posicion 50... por si hay un problema en esas direcciones

[mgonzy]

Hola, lo de posiciones de memoria tambien lo itente, ahora no se pero por arte de magia empezo a dar bien los resultados, aun no lo probe en mi placa junto con el modulo gsm se quedo sin credito jaja. Hoy recargare y te comento los resultados. Muchas gracias

[KILLERJC]

Es que no queda otra realmente.

Si se almacena bien en el buffer, queda descarcatado esa parte
Luego tenes la grabacion, que se al menos en codigo es correcta
Por ultimo tenes la lectura, tambien en codigo es correcta.

Como se ve no hay un fallo segun lo que informas, y lo unico que podia ser es la EEPROM o el PIC. Sino el problema esta en algun lado a pesar que quieras admitir que lo que nombre arriba esta bien. Simple y pura logica.

[mgonzy]

Muchas gracias por toda tu ayuda, no se que es lo que pasaba  .
Eso si, me empezó a un funcionar bien cdo empece a probar con char Id0 mas pequeños x ejmplo Char Id0[3], luego de 4 y así hasta los 24 que necesitaba. Muchas pero muchas gracias por tu tiempo.