Como usar SPM para programação de Flash para Flash – (Parte 33/46)

Cómo utilizar SPM para la programación de Flash a Flash – (Parte 33/46)

9 de junio de 2024 Roberto Magalhães

El modo de autoprogramación ( SPM ) es una característica que permite a un microcontrolador programar su propia memoria flash. Usando SPM, un microcontrolador puede programarse a sí mismo con un código SPM. SPM se usa comúnmente con códigos de cargador de arranque de microcontroladores que ayudan a programar el microcontrolador en serie. En el microcontrolador AVR, el SPM solo está disponible para el código que se ejecuta en el BLS de la memoria flash. Con la ayuda de SPM, un código en BLS puede reescribir la memoria flash de la aplicación en su totalidad o en parte. Incluso puedes reescribir tu propio código en la sección BLS.

SPM es un factor clave del código de Boot-Loader, ya que la función principal de Boot-Loader es cargar un código de aplicación en la sección flash de la aplicación. El Boot-Loader puede recibir código binario de otros chips de memoria, tarjetas SD o mediante el puerto serie del microcontrolador en caso de programación serie. Luego, con la ayuda del SPM, el microcontrolador escribe el código binario en la sección flash de la aplicación. Este proyecto demuestra cómo funciona SPM al reescribir el código de una región de la memoria flash a otra región y luego intentar ejecutar el mismo código en esa región. El hardware utilizado en este proyecto incluye ATMEGA16 como microcontrolador, USBASP como programador y el software utilizado es AVR STUDIO 4 como IDE y AVR-BURNO-MAT como software de grabación.

El modo de autoprogramación (SPM) es una característica del microcontrolador AVR que le permite programar su propia memoria flash. Sólo el código que se ejecuta en BLS puede hacer uso de esta función SPM. Se puede hacer que el microcontrolador inicie la ejecución desde el BLS, desde allí el código puede acceder al área flash de la aplicación. El BLS puede leer o escribir el contenido de todas las memorias flash, incluido el propio BLS.

Fig. 2: Diagrama de bloques SPM con BLS en AVR

La tarea de escribir código BLS con SPM se ha simplificado gracias a las API disponibles en el archivo de encabezado. . A continuación se muestran las API importantes disponibles en el archivo de encabezado que ayudan en SPM.

FUNCIÓN	DESCRIPCIÓN	PARÁMETRO
boot_is_spm_interrupt	Compruebe si la interrupción SPM está habilitada.
boot_lock_bits_set (bloque_bits)	Configure los bits de bloqueo del cargador de arranque	Una máscara de qué bits de bloqueo del gestor de arranque configurar
boot_lock_bits_set_safe (bloqueo_bits)	Espera a que se completen las operaciones de EEPROM y SPM antes de configurar los bits de bloqueo	Una máscara de qué bits de bloqueo del gestor de arranque configurar
boot_lock_fuse_bits_get (dirección)	Lea los bits de cerradura o fusible en la dirección indicada. Devuelve 0 o 1 dependiendo de si el bit del fusible está programado o no	La dirección para leer
boot_page_erase (dirección)	Eliminar la página flash a la que hace referencia la dirección	Una dirección de byte en flash
boot_page_erase_safe (dirección)	espera a que se completen las operaciones de EEPROM y SPM antes de borrar la página	Una dirección de byte en flash
boot_page_fill (dirección, datos)	Llene el búfer de página temporal de Boot-Loader para la dirección flash con palabra de datos	La dirección es una dirección de bytes. Los datos son una palabra.
boot_page_fill_safe (dirección, datos)	espera a que se completen las operaciones EEPROM y SPM antes de llenar la página	La dirección es una dirección de bytes. Los datos son una palabra.
boot_page_write (dirección)	Escriba el búfer de la página temporal del Boot-Loader en la página flash que contiene la dirección	Dirección de bytes flash
boot_page_write_safe (dirección)	espera a que se completen las operaciones EEPROM y SPM antes de escribir la página	Dirección de bytes flash
arranque_rww_busy	Compruebe si la sección RWW está ocupada
boot_rww_enable	Habilite la sección de memoria de lectura mientras se escribe.
boot_rww_enable_safe	espera a que se completen las operaciones EEPROM y SPM antes de activar la memoria RWW
boot_signature_byte_get (dirección)	Devuelve el byte de la línea de firma en la dirección dada.	La dirección del parámetro puede ser de 0 a 0x1F.
arranque_spm_busy	Compruebe si la instrucción SPM está ocupada
arranque_spm_busy_wait	Espere mientras la instrucción SPM esté ocupada
boot_spm_interrupt_disable	Deshabilitar la interrupción SPM
boot_spm_interrupt_enable	Habilitar interrupción SPM

Figura 3: API importantes en el archivo de encabezado AVR para SPM

Con las API anteriores, se puede escribir código para SPM en un microcontrolador AVR, siempre que el código siga ciertos pasos en orden. En este proyecto el código que fue programado desde el inicio de la memoria flash se reprograma en otra región de la memoria flash como tal. La tarea de programar una región de la memoria flash con el binario obtenido de la otra región se puede realizar en los siguientes tres pasos principales.

Paso: 1 Elimina la página flash que estás a punto de escribir

El primer paso es borrar la página flash que está a punto de escribirse con los nuevos valores. La API que ayuda a ejecutar este paso es;

Boot_page_erase (dirección)

Esta API puede eliminar una página completa en flash a la que se dirige el parámetro. En el código, la dirección de la página borrada es 256. La siguiente imagen muestra el estado del búfer de página temporal y la memoria flash en el paso 1. El búfer de página temporal es un búfer en el que se puede almacenar una página completa antes de flashearla. en una página de la memoria flash.

Fig. 4: La figura representa el estado del buffer de página temporal y la memoria flash en el AVR SPM

Paso: 2 Almacene los valores en un búfer temporal antes de escribir en una página flash

Este es el segundo paso en el que debe almacenar el binario requerido en un búfer temporal antes de escribir en cualquier página de memoria flash. La API que se puede utilizar para este fin es;

boot_page_fill (dirección, datos)

Esta API llena el búfer de página temporal del Boot-Loader byte a byte antes de actualizar los datos en el búfer de página temporal en una página como tal. Los datos del parámetro representan cada byte en el búfer y la dirección del parámetro representa la dirección de la página + desplazamiento de la ubicación del búfer donde se debe almacenar el byte de datos.

La siguiente figura representa la operación en la que el búfer de página temporal se llena byte a byte utilizando la API boot_page_fill(dirección, datos).

Fig. 5: Operación de transferencia de datos al búfer de página temporal usando la API AVR boot_page_fill

Los datos de los parámetros en la API boot_page_fill (dirección, datos) en realidad se leen desde la primera ubicación de la memoria flash con la ayuda de otra API que está disponible en el archivo de encabezado. .

pgm_read_byte (dirección)

FUNCIÓN	DESCRIPCIÓN	PARÁMETRO
pgm_read_byte (dirección)	Esta función devuelve el byte que se lee de la memoria flash al que hace referencia el parámetro 'dirección'	Se refiere a la ubicación de la memoria flash desde la cual se debe leer el byte.

Paso:3 Programe el buffer temporal llenado en la página flash ya borrada

Este es el paso final en el que el búfer temporal lleno se actualiza utilizando una API en la página ya borrada de la memoria flash. La API que ayuda en este paso es;

boot_page_write (dirección)

Fig. 6: Datos del búfer temporal transferidos a la memoria Flash del AVR mediante API

El código de este proyecto que se escribió para BLS puede copiar 300 bytes de la memoria flash al búfer temporal a partir de la dirección 0x0000. Luego, estos bytes se transfieren a la página de la memoria flash comenzando en la dirección 0x0100. Después de hacer esto, el código BLS saltará a la dirección 0x0100 para que el binario reescrito pueda ejecutarse a continuación. Con este código del cargador de arranque, cualquier programa que ingresemos en la dirección que comienza en 0x0000 se reescribirá en x 0x0100 y se ejecutará. Se puede escribir una aplicación de prueba de LED parpadeante simple en la memoria flash a partir de 0x0000 para probar el funcionamiento. Actualice primero el código BLS y luego el código de la aplicación LED siguiendo los pasos explicados en el proyecto anterior sobre LED parpadeante AVR BLS . Cuando el LED parpadea, significa que el código se ha reescrito de una sección de la memoria flash a otra y se está ejecutando desde allí.

Fig. 7: LED parpadeando usando SPM del circuito AVR configurado en la placa de pruebas

Código fuente del proyecto

###

#definir F_CPU 8000000

#incluir

#incluir #incluir #incluir #incluir #incluir #incluir int principal (nulo) { uint16_ti; uint8_tA(300); registro uint8_t; página uint32_t = 256; carácter sin firmar *buf = A; //------------------------------------------------ ------------------------------- DDRD = 0x80; PUERTO = 0x7F; //continuado. gestor de arranque bien. _delay_ms (2000); PUERTO = 0x80; //apaga el LED ahora. Esperamos a que la aplicación vuelva a encender el LED _delay_ms (2000); //------------------------------------------------ -------------------------------- // almacenando los bytes desde la iésima ubicación de la memoria flash en la iésima variable de la matriz A // para (yo = 0; yo <300; yo++) A(i)=pgm_read_byte(i); // almacenando los bytes desde la iésima ubicación de la memoria flash en la iésima variable de la matriz A // //================================ SPM ================ ============= ======================================= =====// reg = SREG; // almacena el estado actual de la interrupción en sreg cli; //borrar interrupciones eeprom_busy_wait; // espera hasta que la eeprom esté libre. boot_page_erase (página); //eliminar la página flash en la que estamos a punto de escribir boot_spm_busy_wait; //Espera hasta que se borre la memoria. //---- llena los bytes de la página en el buffer de página temporal antes de pasar a flash ----// para (l = 0; l

{ //convierte bytes a palabras little-endian// uint16_t w = *buf++; w += (*buf++) << 8; //convierte bytes a palabras little-endian// boot_page_fill(página + i, w); //llena el buffer de página templado byte a byte } //---- llena los bytes de la página en el buffer de página temporal antes de pasar a flash ----// //------------------------------------------------ --------------------// boot_page_write (página); // Almacenar el búfer en la página flash. //------------------------------------------------ --------------------// boot_spm_busy_wait; //Espera hasta que se escriba la memoria. boot_rww_enable; //Reactivar nuevamente la sección RWW SREG = sreg; //Reactivar interrupciones //================================ SPM ================ ============= ======================================= =====// asm("jmp 0x0100"); // salta a la aplicación programada en 0x0100 }

###