PDF de programación - Grabación de memoria FLASH en el MC908GP32

COMENTARIO TECNICO

Grabación de memoria FLASH en el MC908GP32

Por el Ing. Gabriel Dubatti
Adaptación Ing. Daniel Di Lella Dto. Técnico EduDevices – www.edudevices.com.ar

Primera parte.

Introducción:
Como hemos visto en un artículo anterior es posible utilizar la memoria FLASH de los microcontroladores HC908
de Freescale para almacenar datos temporales No - Volátiles como si usaramos la típica configuración de EEPROM
externa del tipo 93Cxx o 24LCxx.
En ese artículo, se mostró en detalle el uso de la memoria FLASH en los dispositivos de menos de 8Kbytes
de memoria de programa flash., tales como los 908JL3 / JK3 / JK1 o 908KX8 / KX2, etc. , pero el principio de
trabajo es aplicable a casi todos los HC908 disponibles hoy en día, solo con pequeñas modificaciones en cuanto a la
dirección de salto de las distintas subrutinas contenidas en la ROM de los mismos.

En el presente artículo, trataremos en detalle la grabación y borrado de la memoria FLASH de MCUs HC908xx con
memorias superiores a 8Kbytes como los 908GP32, 908MR32 / MR16, 908SR12, etc., que pertenecen a la “vieja
guardia” de los MCUs HC908 y que no poseen rutinas en ROM que permitan modificar la misma como si lo
permiten el resto de los HC908.

En particular se eligió el HC908GP32 como ejemplo de uso de la memoria FLASH como EEPROM.

El MC908GP32 es un poderoso microcontrolador de FreescaleTM basado en la tecnología FLASH.
Entre sus características más importantes figuran:

32 KBytes de memoria FLASH (con un ciclo mínimo de 100.000 grabaciones a 20°C .)
512 Bytes de RAM

•
•
• SPI, SCI, 2 timers muy completos, etc.
• Protección contra lectura del código.

El procesador tiene dos modos de trabajo básicos: monitor y usuario.
Para ingresar en modo monitor el procesador debe tener el vector de reset borrado ($FFFF) o se debe
aplicar una tensión elevada en el PIN de IRQ y poner algunos ports en un valor determinado.
Luego se deben enviar los 8 bytes de seguridad, que si coinciden con los últimos 4 vectores grabados,
permite la lectura y modificación de la FLASH y si no coinciden sólo permite un borrado masivo.
Los utilitarios de grabación trabajan en este modo. Si no se ingresa en modo monitor, se está en modo usuario.
Este artículo muestra como utilizar la memoria FLASH para grabar datos modificables durante la ejecución
(modo usuario) como si fuera una memoria EEPROM.

Organización de la memoria FLASH:
La memoria FLASH está organizada en páginas de 128 bytes, permitiéndose la grabación mínima de 1 byte,
el borrado mínimo de 1 página y el borrado completo (o masivo) en una sola operación.
Se pueden grabar hasta 64 bytes (un row) por operación pero el algoritmo presentado aquí lo hace de a un
byte por vez para utilizar el mínimo posible de RAM.
Cuando un byte de la memoria está borrado se lee como $FF y sólo se le pueden grabar bits en 0.
Para pasar un solo bit de 0 a 1, deben borrarse los 128 bytes de la página.
Mientras se modifica la FLASH esta no puede ser utilizada. Esto obliga a ejecutar el código de grabación
desde RAM (o ROM como ocurre en los otros micros de la familia como el JL3) y no pueden
atenderse las interrupciones. El algoritmo presentado graba 1 byte en 100 microsegundos y borra una
página (128 bytes) en 1 milisegundo.
Los siguientes address están implementados en memoria FLASH:

•
•
•

$8000 - $FDFF (32256 bytes, páginas 0..251)
$FF7E (FLBPR, página 254)
$FFDC - $FFFF (36 bytes, página 255)

El registro FLBPR (FLash Block Protect) permite indicar hasta que página se puede modificar en modo
usuario (255 = toda la memoria, 0 = nada), para impedir sobregrabar o borrar por accidente el
programa. Este registro sólo puede modificarse desde modo monitor.
Esto obliga a poner los datos que se deseen modificar en $8000 (y bytes siguientes) y el código a
continuación (hasta $FFFF, cuidando de no usar una misma página para código y datos).

Mediante el siguiente código se puede programar el valor correcto del registro:
;===================================================================
ORG $8000 ;Comienzo de la memoria FLASH
Datos: ;
..... ; COLOQUE AQUI LOS DATOS A MODIFICAR
..... ;
;===================================================================
ORG {($+!127) & $FF80} ;Alinea a la siguiente pagina de
;128 bytes
CodigoStart: ;Aqui comienza el codigo protegido
..... ;
..... ; COLOQUE AQUI SU CODIGO
..... ;
;===================================================================
ORG FLBPR ;FLash Block PRotect
DB {(CodigoStart & $7FFF)/!128} ;donde empieza el CODIGO
;a PROTEGER
;===================================================================

Nota: El código que fuerza la alineación puede reemplazarse por una dirección fija.

Algoritmo de grabación:
Para modificar un byte deben seguirse los siguientes pasos:

1. Tapar las interrupciones
2. Subir en el registro FLCR (FLash Control Register) el bit PGM ($01)
3. Leer el registro FLBPR (FLash Block Protect)
4. Grabar cualquier valor en el byte a modificar (esto selecciona el row)
5. Delay TNVS = 10 microsegundos (PGM to HVEN setup time)

6. Subir en el registro FLCR (FLash Control Register) el bit HVEN ($08)
7. Delay TPGS = 5 microsegundos (Program Hold Time)
8. Grabar el valor correcto en el byte a modificar
9. Delay TPROG = 30 microsegundos (Byte Program Time)
10. Bajar en el registro FLCR (FLash Control Register) el bit PGM ($01)
11. Delay TNVH = 5 microsegundos (High-Voltage Hold Time)
12. Bajar en el registro FLCR (FLash Control Register) el bit HVEN ($08)
13. Delay TRCV = 1 microsegundos (Return to read mode)
14. Recuperar estado de las interrupciones

Algoritmo de borrado:
Para borrar una página deben seguirse los siguientes pasos:

1. Tapar las interrupciones
2. Subir en el registro FLCR (FLash Control Register) el bit ERASE ($02)
3. Leer el registro FLBPR (FLash Block Protect)
4. Grabar cualquier valor en la página a borrar (esto selecciona la página)
5. Delay TNVS = 10 microsegundos (ERASE to HVEN setup time)
6. Delay TERASE = 1 milisegundo (Erase block time)
7. Bajar en el registro FLCR (FLash Control Register) el bit ERASE ($02)
8. Delay TNVH = 5 microsegundos (High-Voltage Hold Time)
9. Bajar en el registro FLCR (FLash Control Register) el bit HVEN ($08)
10. Delay TRCV = 1 microsegundos (Return to read mode)
11. Recuperar estado de las interrupciones

Implementación:
Las rutinas presentadas realizan estos dos algoritmos manteniendo al mínimo la cantidad de RAM
necesaria. Para ello realizan la mayor cantidad posible de inicializaciones antes de grabar o borrar y
no tocan la máscara de interrupciones, por lo que requieren llamarlas con las interrupciones tapadas.
Los delays están calculados para una frecuencia de bus de 8 MHz (lo que equivale a
1 microsegundo = 8 ciclos). Si decide utilizar otra frecuencia de bus DEBERA ajustar las constantes
asegurándose que se mantengan los tiempos mínimos.

Por ejemplo: delay TERASE= 1 milisegundo

• Para 8MHz son 8000 ciclos y como cada loop tiene 33 ciclos, son 242.42.. iteraciones.

La constante para el borrado debe ser 243 o sea: 8019 ciclos o 1.002 miliseg.

• Para 4MHz son 4000 ciclos y como cada loop tiene 33 ciclos, son 121.21.. iteraciones.

La constante para el borrado debe ser 122 o sea: 4026 ciclos o 1.006 miliseg.

La rutina de grabación tiene un delay total de 101 microsegundos, dado que la copia de los
35 bytes a RAM requiere 350 ciclos que a 8MHz son 45 microsegundos (45% del tiempo total,
que aumenta si se baja la frecuencia del bus). Si su aplicación no tiene problemas de RAM y sí de
tiempo, puede modificar el código para que realice la copia a RAM una sola vez al inicializar
y la ejecute directamente desde esa dirección (tenga cuidado en cargar los valores que requieren las
rutinas en los registros antes de llamarlas).
Por su parte, la rutina de borrado tiene un delay total de 1,068 milisegundos. Aquí el tiempo de copia
(igual que en la grabación) sólo representa el 4% del total, pero valen las mismas observaciones que
en el caso anterior.

Como utilizar las rutinas:
Para grabar: indique el address a modificar en FlashAddress y el dato en FlashData y llame a la rutina:
FlashWRITE (estas variables mantienen su valor al salir).
Para borrar: indique un address dentro de la página a borrar (por ejemplo el 1er byte de la
página) en FlashAddress y llame a la rutina: FlashERASE (Atención: FlashData es usado de temporal
y retorna con valor 0, en cambio FlashAddress mantiene su valor al salir).
Tenga en cuenta que cada vez que desee borrar un byte, deberá borrar 128 (la página completa).
Por lo tanto, según la cantidad de datos que desee grabar deberá implementar una rutina que se encargue
de salvar los datos de la página que no cambian, la borre, regrabe los datos salvados y agregue los
nuevos. Aquí tiene algunas opciones:

• Usar 1 byte por página (contra: desperdicia 127 bytes por página).
•

Idem anterior, pero grabar en el 1er lugar vacío ($FF) de la página. Esto disminuye el número de
operaciones de borrado (ver el ejemplo) (contra: no se puede usar el valor $FF como dato y al

leer hay que buscar el último valor grabado).
• Usando RAM de backup. Copiar los datos a RAM, modificarlos, borrar la página y grabarla.
(contra: requiere RAM de backup)
• Usar 2 paginas. Usando el valor $FF como indicador de vacío, puede intentar grabar en una
página, si ese byte esta ocupado grabar en la siguiente página. Si ésta también esta ocupada,
salvar los datos que estén en la 1era y no en la 2da. Borrar la 1era y grabar ahí los valores nuevos.
Hace falta agregar en la 1er página un flag que indique que página es la considerada 1era.
(contra: algoritmo más complejo y n