Problema con una función que estoy implementando para grabar en la eeprom

[Thulsa Doom]

Buenas a todos, pues estoy trabado en una función que estoy desarrollando para grabar datos en una memoria interna de un pic.
Estoy utilizando C18 + MPLAB
El problema que tengo es que si el código lo implemento en la función principal main me lo ejecuta sin problema y bien.
Código en la función main.c

Código: [Seleccionar]

void main(void){
unsigned int address_eep = 0x0000;
                 char array_write_eep[]= "HOLA";
unsigned int wLeng;
unsigned char i;

    do{
          wLeng = strlen(array_write_eep); //Detecta la longitud del array
           for(i=0;i<wLeng;i++) //Bucle que escribe cada byte del array en una posición consecutiva de memoria
{
Busy_eep();    //Se espera a que el buffer esté libre
Write_b_eep(address_eep++, array_write_eep[i]); //incrementamos la dirección eeprom al mismo tiempo que se incrementa la i
                              }
}
   while(1);
}

pero si ese código lo meto en una función y la llamo desde main.c empiezan los problemas.
Me graba los datos en la memoria interna uno si uno no. Por ejemplo si tenemos la palabra “HOLA” me graba en la posición 0,1,2 de la memoria esto:

OA.

Cómo pueden ver, se ha omitido la H y la L

La verdad es que no sé que estoy haciendo mal, el código es este:

Código: [Seleccionar]

void main(void){
unsigned int address_eep = 0x0000;
char array_write_eep[]= "HOLA";
     do{
Write_Internal_Eeprom(strlen(array_write_eep), address_eep, array_write_eep); //Averiguamos la longitud de la cadena y Guardamos el array en la memoria interna
    While(1);
}
Función que me da los problemas:

Código: [Seleccionar]

//Guardamos el array en la memoria interna del pic
void Write_Internal_Eeprom(unsigned int wLeng, unsigned int address_eep, const char *array_write_eep[])
{
unsigned char i;


                 for(i=0;i<wLeng;i++) //Bucle que escribe cada byte del array en una posición consecutiva
{
Busy_eep();    //Se espera a que el buffer esté libre
Write_b_eep(address_eep++, array_write_eep[i]); //incrementamos la dirección eeprom al mismo tiempo que se incrementa la i
}
}

[AngelGris]

  ¿No tendrás un conflicto entre la variable global "array_write_eep[]" y la variable definida en la función como "const char *array_write_eep[]"? Puedes probar definiendo a la variable de la función con otro nombre.

  En estos momentos estoy probando un rígido y no tengo ni IDE ni compilador instalado, así que no sabría decirte si efectivamente es la solución.

[KALLITOS]

Ten en cuenta que normalmente a la eeprom le toma un tiempo de 5ms para completar la escritura correcta, eso que comentas ya me pasó, usa una pausa entre grabada de cada byte.

saludos.

[Thulsa Doom]

 ¿No tendrás un conflicto entre la variable global "array_write_eep[]" y la variable definida en la función como "const char *array_write_eep[]"? Puedes probar definiendo a la variable de la función con otro nombre.

  En estos momentos estoy probando un rígido y no tengo ni IDE ni compilador instalado, así que no sabría decirte si efectivamente es la solución.

Ya lo he probado y obtengo el mismo resultado

Ten en cuenta que normalmente a la eeprom le toma un tiempo de 5ms para completar la escritura correcta, eso que comentas ya me pasó, usa una pausa entre grabada de cada byte.

saludos.

creo que para eso está la función Busy_eep(); y de todas maneras si fuera ese el problema ¿por que si me funciona si lo implemento en el main.c y no en la función?

[BrunoF]

por qué el const char *array_write_eep?

[Thulsa Doom]

por qué el const char *array_write_eep?

Pues la verdad, estaba probando diferentes tipos ( unsigned char, char, unsigned int, int, static, rom ) a ver con cual me iba, (la verdad es que hay cosillas que se me escapan todabía, lo siento) y se me quedo el const, porque lo vi en una función estandar de C al igual que unsigned char.

Pues he de decir que ya lo he resuelto, la verdad que me deja loco porque no lo entiendo 100%, voy a exponer el código a ver que me dicen y de camino para que alguien lo use si le hace falta.

resulta que para que funcione tengo que poner la función de esta manera:
en el archivo principal main.c

Código: [Seleccionar]

#define __MAIN_C

#include "Include/config.h"

void main(void){
unsigned int direccion = 0x0000;
unsigned char array_write[]= "0123";
unsigned char array_read[5];

do{

Write_Internal_Eeprom(strlen(array_write), direccion, array_write); //Averiguamos la longitud de la cadena y Guardamos el array en la memoria interna

Read_Internal_Eeprom(5u, direccion, array_read); //Leemos los datos guardados en la eeprom del pic
}
while(1);
}


el el archivo de la función que lo he llamado read_write_array_eep.c

Código: [Seleccionar]

#define READ_WRITE_ARRAY_EEP_C


//Guardamos el array en la memoria interna del pic
void Write_Internal_Eeprom(unsigned int wLeng, unsigned int address_eep, unsigned char array_write_eep[])
{
unsigned char i;

for(i=0;i<wLeng;i++) //Bucle que escribe cada byte del array en una posición consecutiva
{
Busy_eep();    //Se espera a que el buffer esté libre
Write_b_eep(address_eep++, array_write_eep[i]); //incrementamos la dirección eeprom al mismo tiempo que se incrementa la posición del array a guardar
}
}

void Read_Internal_Eeprom(unsigned int wLeng, unsigned int address_eep, unsigned char array_read_eep[]) //esta función está en desarrollo
{
unsigned char i;

for(i=0;i<(wLeng-1);i++)  //Bucle para la lectura de la eeporm en su posición correspondiente
{
Busy_eep();    //Se espera a que el buffer esté libre
array_read_eep[i] = Read_b_eep(address_eep++);
}
array_read_eep[i+1] = '\0';
}
la lectura de la eeprom de momento creo que no me funciona, tengo lío con los punteros al array en main.c (no sé muy bien como hacerlo)

pero para que funcione la escritura tengo que definir el puntero en un archivo de cabecera la función que quedaría algo así

Código: [Seleccionar]

/* FUNCTION PROTOTYPES */
#if defined (EEP_V1) || defined (EEP_V2) || defined (EEP_V3)

void Busy_eep ( void );
unsigned char Read_b_eep( unsigned int);
void Write_b_eep( unsigned int, unsigned char);
void Write_Internal_Eeprom(unsigned int, unsigned int, unsigned char *);
void Read_Internal_Eeprom(unsigned int, unsigned int, unsigned char *);

en éste archivo de cabecera es donde definimos el puntero (*), si ponemos el puntero (*) en la función que se encuentra en read_write_array_eep.c me da el error del que hablo,
no tengo ni idea de porque pasa eso ya que hay otras funciones ya estandarizadas donde el puntero se pone en la función que se encuentra en el archivo .c tanto en el de cabecera  y funciona perfecto

[Thulsa Doom]

Hola a todos, pues ahora tengo otro problema con la otra función.

estoy intentando elaborar una función de lectura de la eeprom interna y la he simplificado al máximo para ir luego aumentando el nivel pero me hace una cosa muy rara y no sé a que se puede deber.

El problema es el siguiente:

si el siguiente código lo coloco en el archivo main.c no me da ningún problema.

Código: [Seleccionar]

void main(void){
unsigned int direccion = 0x0000;
unsigned char array_write[]= "Probando";
unsigned char i;
unsigned char array[8];

do{

for(i=0;i<9;i++)  //Bucle para la lectura de la eeporm en su posición correspondiente
{
Busy_eep();    //Se espera a que el buffer esté libre
array[i] = Read_b_eep(direccion++);
}
direccion = 0x0000;

   }
       while(1);
}
Pero si lo que hago es crear una función que contenga eso y llamarla cada vez que me haga falta, de esta manera:

Código: [Seleccionar]

void Read_Internal_Eeprom()
{
unsigned char i;
        unsigned char array[8];
unsigned int direccion = 0x0000;

for(i=0;i<9;i++)  //Bucle para la lectura de la eeporm en su posición correspondiente
{
Busy_eep();    //Se espera a que el buffer esté libre
array[i] = Read_b_eep(direccion++);
}
direccion = 0x0000;
}

 es cuando empiezan los problemas, lo que veo es que el buffer se carga de datos diferentes a los que están guardados y dependiendo de cómo declare el array pues lee los datos de manera consecutiva o de manera aleatoria.
para mi no tiene ningún sentido que colocando la misma función en dos zonas diferentes del programa se comporten de diferente manera.
observando el código en modo debugger veo que el conteo de i y de direccion es correcto, la lectura de la eeprom parece correcta, o eso me parece viendo como se ejecuta el código de la función Read_b_eep, pero a la hora de guardarlo en el array no, y hace cosas raras.

a ver si alguien tiene una idea y me echa una mano.

gracias

[jukinch]

Thulsadoom no he visto el proyecto completo. Pero supongo que el problema esta en que    unsigned char array[8];   esta siendo declarado como local a la función main y como local a la función Read_Internal_Eeprom. Y cuando invocas a la funcion el array al salir de esta ultima muere.
O lo declaras como global o lo pasas como un puntero a la función.
Probá imprimir el contenido del array desde dentro de la función para ver si existe contenido.
Saludos
Jukinch

[Thulsa Doom]

Pues no es nada de eso, ya he solucionado el problema y aunque en el código lo haya puesto como indicas no tiene nada que ver para que no funcionara, resulta que el problema era de librerías, no llame las librerías de cabecera adecuadamente y me daba ese error, ahora mismo ya he montado la función y le paso un puntero donde se graba el array y puede ser posteriormente manipulado en el código principal main.

no sé que me pasa pero me trabo con algún problema y me tiro hasta días y al final ya me doy por vencido y expongo mi problema en el foro e inmediatamente nada más crear el hilo me llega la inspiración y lo resuelvo   , cosas de la vida

si me lo permiten voy a subir el proyecto al completo, el proyecto solo lo he hecho para crear las librerías que luego utilizaré para un proyecto mucho mayor, pero si a alguien le puede ayudar las subo.
en el proyecto están las librerías para grabar y leer datos de una memoria interna de un pic y del manejo del lcd para ver el array que leemos.

lo acompaño con un esquema en proteus para que juguéis y experimentéis

ya me dicen algo, no sé si estará todo bien explicado y eso si pido perdón por las faltas de ortografía que tengo muchas