¿¿¿ write_program_memory() mas complejo de lo que parece ??? *SOLUCIONADO*

[RedPic]

"Con la iglesia hemos topado, amigo Sancho" Miguel de Cervantes Saavedra en El Quijote.

Os pongo en antecedentes: PIC 24FJ256GA110, Memoria Flash 256K, Memoria EEPROM 0K. Compilando con CCS C v.5.015.

Según reza el adagio castellano "a falta de pan, buenas son tortas", así que al no tener EEPROM decidí usar un trozo de la Flash de Programa a modo de EEPROM y escribir y leer bytes de ella pero o el PIC o el CCS o mi desconocimiento me están amargando la experiencia.  

Si intento hacer simplemente esto:

Código: CSS

1. char buffer[]="1234567890"
2.          int32 address=0x0AE0;
3.  
4.          write_program_memory(address,buffer,10);
5.          delay_ms(15);
6.          fprintf(DEBUG,">WRITE FLASH=[%s]>\r\n",buffer);
7.          read_program_memory(address,buffer,10);
8.          fprintf(DEBUG,">READ FLASH=[%s]>\r\n",buffer);

Obtengo  :

Código: CSS

1. >WRITE FLASH=[1234567890]
2. >READ FLASH=[]

O sea nada de nada, no escribe ni por vergüenza, y mi gozo en un pozo  

He estado buscando y me he encontrado con tamaños de página para erase y para write ... y no se muy bien cómo meterle mano a este tema. Yo lo que necesito es escribir una docena de bytes y leerlos, no más.

¿Tenéis idea de cómo hacerlo o por donde puedo mirar/buscar?  

[RedPic]

Lo mas cercano que he encontrado es esto en el foro del CCS, veré si es esta la solución.

http://www.ccsinfo.com/forum/viewtopic.php?t=49089&highlight=writeprogrammemory

[Picuino]

¿Cual es el tamaño de página para escritura en flash de ese microcontrolador?

En otros micros la escritura se produce en bloques de 32bytes. Prueba con un buffer de 32 o 64 bytes a ver si funciona.

Saludos.

[MGLSOFT]

Diego, en el ejemplo del foro de CCS, el autor crea un buffer para leer aparte del que luego lee para escribir.
En tu caso solo declaras un buffer, solo para escribir, y luego lees lo escrito sobre el mismo buffer.

Estas seguro que ese buffer no se crea con valores estáticos??

Así encuentra el autor el origen de la memoria flash:

Código: C

1. #define CK_FLASH_END       (getenv("PROGRAM_MEMORY")-1)      
2. #define CK_FLASH_PAGE_SIZE (getenv("FLASH_ERASE_SIZE")/2)
3. #define CK_NUM_PAGES (CK_FLASH_END/CK_FLASH_PAGE_SIZE)
4.  
5. #define CK_USER_PAGE (CK_FLASH_PAGE_SIZE*(CK_NUM_PAGES-1))
6.  
7. #org CK_USER_PAGE,CK_FLASH_END {}

O sea que efectivamente, como dice Picuino, esta paginada.

Y así resuelve la escritura en el main() , negus el dice le funciona.

Código: C

1. unsigned int8 read_data[8];
2. unsigned int8 write_data[] = {12,34,56,0,25,42,1,0};
3.  
4. write_program_memory(CK_USER_PAGE,write_data,8);
5. delay_ms(1);              
6. read_program_memory(CK_USER_PAGE,read_data,8);

[RedPic]

Con getenv() veo que el 24FJ256GA110 tiene estos valores:


PROGRAM_MEMORY ................... 0x0002ABF8
FLASH_ERASE_SIZE ................. 0x0800
FLASH_WRITE_SIZE ................. 0x0100


Lo que voy a hacer es montar los 2Kbytes, como dice MGLSOFT, al final de la ROM de Programa, usando el #ORG Start, End {} y con un Buffer de 2Kb sobre RAM haré una pseudo-eeprom

- Leo con read_program_memory() sobre el buffer
- Actualizo el contenido del buffer con unas funciones similares a las de la EEPROM
- Hago el erase_program_memory() que aconseja el Datasheet del micro
- Escribo  el buffer con el write_program_memory()

Ya os pongo los resultados.

[BrunoF]

Con getenv() veo que el 24FJ256GA110 tiene estos valores:


PROGRAM_MEMORY ................... 0x0002ABF8
FLASH_ERASE_SIZE ................. 0x0800
FLASH_WRITE_SIZE ................. 0x0100


Lo que voy a hacer es montar los 2Kbytes, como dice MGLSOFT, al final de la ROM de Programa, usando el #ORG Start, End {} y con un Buffer de 2Kb sobre RAM haré una pseudo-eeprom

- Leo con read_program_memory() sobre el buffer
- Actualizo el contenido del buffer con unas funciones similares a las de la EEPROM
- Hago el erase_program_memory() que aconseja el Datasheet del micro
- Escribo  el buffer con el write_program_memory()

Ya os pongo los resultados.

Es así como se hace Diego, aunque puedes usar un buffer menor al tamaño de la página de 2kB. Si quieres ver un caso extremo, en una empresa donde trabajé, usaban la FLASH como RAM en un 18F...

 

[RedPic]

Con getenv() veo que el 24FJ256GA110 tiene estos valores:


PROGRAM_MEMORY ................... 0x0002ABF8
FLASH_ERASE_SIZE ................. 0x0800
FLASH_WRITE_SIZE ................. 0x0100


Lo que voy a hacer es montar los 2Kbytes, como dice MGLSOFT, al final de la ROM de Programa, usando el #ORG Start, End {} y con un Buffer de 2Kb sobre RAM haré una pseudo-eeprom

- Leo con read_program_memory() sobre el buffer
- Actualizo el contenido del buffer con unas funciones similares a las de la EEPROM
- Hago el erase_program_memory() que aconseja el Datasheet del micro
- Escribo  el buffer con el write_program_memory()

Ya os pongo los resultados.

Es así como se hace Diego, aunque puedes usar un buffer menor al tamaño de la página de 2kB. Si quieres ver un caso extremo, en una empresa donde trabajé, usaban la FLASH como RAM en un 18F...
 

Si, Bruno, pero para mantener la integridad de la Flash dicen que es necesario hacer un erase antes de cada write, por ello el área reservada debe ser del tamaño del FLASH_ERASE_SIZE aunque el buffer lo construya con un tamaña que sea múltiplo del FLASH_WRITE_SIZE para optimizar el acceso ¿no?

[RedPic]

Lo único que no entiendo del ejemplo del tipo este del foro de CCS es:

Código: CSS

1. #define CK_FLASH_PAGE_SIZE (getenv("FLASH_ERASE_SIZE")/2)

¿Por qué hace su Flash Page Size igual a la mitad del Flash Erase Size? 

[MerLiNz]

porque quizas el erase sea en words, osea 16bits.

[RedPic]

Cierto.

Pero además es un poco mas complejo. Ya casi lo tengo pero ... me escribe 3 de cada 4 bytes del buffer original.

Parece ser que cada dato es de 24 bits (16+8) por lo que un buffer continuo de datos de 8 bits debo escribirlo físicamente separando el 4º byte y desplazándolo todo uno más adelante: 3 bytes de datos, 1 byte de separación, 3 bytes de datos, 1 byte de separación, etc. etc. etc.

Voy a modificar mis funciones de lectura/escritura teniendo esto en cuenta y a ver que pasa. 

[RedPic]

¡¡¡Efectivamente!!! Todo solucionado. 

Al final he montado un buffer "lógico" perfectamente contínuo sobre el que leo o escribo como si fuese la EEPROM. Pero cuando accedo a la ROM lo proceso creando un buffer "físico" metiéndole un 0x00 cada 3 bytes que es el que uso para la función write_program_memory(). Por otra parte leo sobre ese buffer "físico" con la función read_program_memory() y lo proceso al revés, comprendiéndolo y eliminando ese byte de 4 para generar el buffer "lógico".

Así tengo dos funciones lógicas de escritura/lectura donde la dirección es relativa a su posición dentro del buffer "lógico" que son las que se usan dentro de mi programa como si fuesen para escribir/leer una EEPROM "normal"

Código: CSS

1. void pseudo_eeprom_write(int16 offset_Address,int8 *pData, int16 dataLen);
2. void pseudo_eeprom_read(int16 offset_Address,int8 *pData, int16 dataLen);

Y éstas a su vez llaman a otras dos que o prepara el buffer para escribir en la ROM o lo preparan después de haber leído de ella:

Código: CSS

1. void pseudo_eeprom_write_physical_buffer(void);
2. void pseudo_eeprom_read_physical_buffer(void);

Obviamente un buffer de n bytes de tamaño solo puede leerse/escribirse en sus 3/4 partes debido a ese "corrimiento" que se necesita de los bytes "fantasmas", así un buffer de 512 bytes solo contendrá 384 bytes reales. 

[RICHI777]

Con getenv() veo que el 24FJ256GA110 tiene estos valores:


PROGRAM_MEMORY ................... 0x0002ABF8
FLASH_ERASE_SIZE ................. 0x0800
FLASH_WRITE_SIZE ................. 0x0100


Lo que voy a hacer es montar los 2Kbytes, como dice MGLSOFT, al final de la ROM de Programa, usando el #ORG Start, End {} y con un Buffer de 2Kb sobre RAM haré una pseudo-eeprom

- Leo con read_program_memory() sobre el buffer
- Actualizo el contenido del buffer con unas funciones similares a las de la EEPROM
- Hago el erase_program_memory() que aconseja el Datasheet del micro
- Escribo  el buffer con el write_program_memory()

Ya os pongo los resultados.

Es así como se hace Diego, aunque puedes usar un buffer menor al tamaño de la página de 2kB. Si quieres ver un caso extremo, en una empresa donde trabajé, usaban la FLASH como RAM en un 18F...

 

     Pero la flash tiene un tiempo de vida limitado ...

[RedPic]

     Pero la flash tiene un tiempo de vida limitado ...

Si, unas 10 veces menos que la EEPROM. Pero yo solo la quiero para unos datos muy estables y con muy pocos cambios en función del tiempo, como el ID del micro (o número de serie) por ejemplo, que esta familia de los 24FJ256GA110 no lo tiene implementado.

[RICHI777]

Si Diego se entiende tu concepto, yo me refería al comentario que hizo Bruno acerca de la empresa donde trabajo ...

[BrunoF]

Si Diego se entiende tu concepto, yo me refería al comentario que hizo Bruno acerca de la empresa donde trabajo ...

Si. Era para una fábrica de autos de Argentina. El tiempo estimado de vida era entre 9 y 12 meses, debido al uso de la FLASH como RAM...