AVR- enviando el programa de aplicación al cargador de arranque

Esto necesitará un trabajo adicional de su parte para integrarlo en su código, pero debería darle algunas ideas. El primer paso en el gestor de arranque será incluir encabezados relacionados con la programación del FLASH:

#include <avr/boot.h>
#include <avr/pgmspace.h>

Algunas otras definiciones que ayudan a definir las cosas más adelante y definen algunos códigos de respuesta al final del procesamiento de cada línea son:

#define HEX2DEC(x)  (((x < 'A') ? ((x) - 48) : ((x) - 55)))
#define SPM_PAGEMASK ((uint32_t) ~(SPM_PAGESIZE - 1))
enum response_t {RSP_OK, RSP_CHECKSUM_FAIL, RSP_INVALID, RSP_FINISHED};

Luego, se puede usar una rutina como la siguiente para procesar el formato hexadecimal de Intel y escribir en FLASH. Está escrito para un dispositivo más grande, de modo que maneja las direcciones extendidas en los archivos hexadecimales para que pueda eliminar eso en su dispositivo más pequeño para reducir el tamaño del código, pero no hará ningún daño dejarlo en su lugar. También deberá agregar su propio código de inicio / recepción de UART y determinar qué hacer si las cosas se agotan, en este caso usé un temporizador de vigilancia.

enum response_t process_line()
{
    char c, line_buffer[128], data_buffer[64];
    uint8_t line_len = 0, data_len = 0, data_count, line_type, line_pos, data;
    uint8_t addrh, addrl, checksum, recv_checksum;
    uint16_t addr, extended_addr = 0, i;
    static uint32_t full_addr, last_addr = 0xFFFFFFFF;

    c = uart_getc();
    while (c != '\r')
    {
        if (c == ':')
            line_len = 0;
        else if (c == '\n')
            ;
        else if (c == '
void enter_loader()
{
    enum response_t response = RSP_OK;

    uart_puts("+OK/\r\n");
    while (response != RSP_FINISHED)
    {
        response = process_line();
        if (response == RSP_OK)
            uart_puts("+OK/");
        else if (response != RSP_FINISHED)
            uart_puts("+FAIL/");
        wdt_reset();
    }   
    boot_rww_enable ();
    while (1) // Use watchdog to reboot
        ;
}
')
            ;
        else if (line_len < sizeof(line_buffer))
            line_buffer[line_len++] = c;
        c = uart_getc();
    }
    if (line_len < 2)
        return RSP_INVALID;
    data_count = (HEX2DEC(line_buffer[0]) << 4) + HEX2DEC(line_buffer[1]);
    if (line_len != data_count * 2 + 10)
        return RSP_INVALID;
    addrh =  (HEX2DEC(line_buffer[2]) << 4) + HEX2DEC(line_buffer[3]);
    addrl =  (HEX2DEC(line_buffer[4]) << 4) + HEX2DEC(line_buffer[5]);
    addr = (addrh << 8) + addrl;
    line_type = (HEX2DEC(line_buffer[6]) << 4) + HEX2DEC(line_buffer[7]);
    line_pos = 8;
    checksum = data_count + addrh + addrl + line_type;
    for (i=0; i < data_count; i++)
    {
        data = (HEX2DEC(line_buffer[line_pos]) << 4) + HEX2DEC(line_buffer[line_pos + 1]);
        line_pos += 2;
        data_buffer[data_len++] = data;
        checksum += data;
    }
    checksum = 0xFF - checksum + 1;
    recv_checksum = (HEX2DEC(line_buffer[line_pos]) << 4) + HEX2DEC(line_buffer[line_pos + 1]);
    if (checksum != recv_checksum)
        return RSP_CHECKSUM_FAIL;
    if (line_type == 1)
    {
        if (last_addr != 0xFFFFFFFF)
        {
            boot_page_write (last_addr & SPM_PAGEMASK);
            boot_spm_busy_wait();
        }
        return RSP_FINISHED;
    }
    else if ((line_type == 2) || (line_type == 4))
        extended_addr = (data_buffer[0] << 8) + data_buffer[1];
    else if (line_type == 0)
    {
        full_addr = ((uint32_t) extended_addr << 16) + addr;
        if ((full_addr & SPM_PAGEMASK) != (last_addr & SPM_PAGEMASK))
        {
            if (last_addr != 0xFFFFFFFF)
            {
                boot_page_write (last_addr & SPM_PAGEMASK);
                boot_spm_busy_wait();
            }
            boot_page_erase (full_addr);
            boot_spm_busy_wait ();
        }
        for (i=0; i < data_len; i+=2)
        {
            uint16_t w = data_buffer[i] + ((uint16_t) data_buffer[i + 1] << 8);
            boot_page_fill (full_addr + i, w);
        }
        last_addr = full_addr;
    }
    return RSP_OK;
}

Lee una línea hexadecimal completa y verifica la suma de comprobación, por lo tanto, coteje el formato hexadecimal de Intel para ver cómo funciona en detalle antes de usarlo. A partir de ahí, la idea general es que cuando alcanza un nuevo límite de página de FLASH realiza un borrado, pero de lo contrario sigue adelante y escribe los datos.

Cuando se ingresa al gestor de arranque, este es el código principal que estaba usando para llamarlo, pero una vez más, tendrá que averiguar qué hacer cuando ocurre una falla. En mi caso, estaba usando algún software de PC personalizado, así que le envié algunas cadenas para indicar el estado, pero para una carga de terminal, es posible que solo desee establecer un indicador EEPROM en función de si tuvo éxito y debería iniciarlo o mostrarlo. un mensaje amigable para los humanos y vuelva a llamar al gestor de arranque:

#include <avr/boot.h>
#include <avr/pgmspace.h>

De todos modos, eso debería darle un buen comienzo y el código anterior se ha probado bastante bien con un firmware bastante complejo. Solo necesitará un poco de trabajo para escribir el UART que falta y otro código de inicialización para determinar cuándo se debe llamar al gestor de arranque para su aplicación. También puede necesitar algunos ajustes para un ATmega32A, pero creo que el enfoque debería funcionar bastante bien en todos los dispositivos AVR.

Con respecto al formato HEX:

Como se sugiere en el comentario, lea acerca del formato Intel HEX. enlace

Básicamente, lo que dice es que cada línea corresponde a un bloque de datos. El formato de la línea es el siguiente:

:XYZC

Donde:

• X es 1 byte que especifica la longitud de la carga útil
• Y es 1 byte que especifica el tipo de carga útil *
• Z es la carga útil de longitud X bytes
• C es 1 byte de la suma de comprobación de la línea

*

  

’00’ Registro de datos
  ’01’ Fin del registro de archivo
  ’02’ Dirección del segmento extendido
  ’03’ Iniciar registro de dirección de segmento
  ’04’ Registro de dirección lineal extendido
  ’05’ Iniciar registro de dirección lineal

Consulte enlace para ver la especificación completa.

Sobre el método de transmisión:

También se menciona en el comentario: está mucho mejor enviando el archivo completo como está. De esa manera, no necesita un programa especializado en el lado de la PC, solo un terminal que se comunique con su dispositivo. Luego analice el texto en chip.

Cómo escribirlo:

El método más sencillo es comenzar a leer las notas de aplicación de Atmel:

  

Todas las operaciones de programación automática se realizan utilizando la instrucción SPM

Esto se puede encontrar aquí: enlace

El AVR109 es un famoso gestor de arranque para dispositivos Mega. Puede encontrar mucha información aquí.

Hay herramientas para tales cosas. Lo primero y más importante: realmente no desea dejar que el controlador descubra dónde colocar qué, ya que eso requeriría analizar el archivo en el controlador.

En su lugar, convierta el archivo en un archivo binario (que puede escribirse 1: 1 en modo flash), luego deje que el controlador lo transfiera a la dirección de la aplicación (debe averiguarlo antes). Un posible programa que veo: su aplicación está vinculada a la dirección 0x0; esto significa que si el cargador de arranque se encuentra en esa dirección específica, no funcionará (deberá vincularla a otra dirección diferente). Si el gestor de arranque reside en alguna otra dirección (preferiblemente al final del flash), está listo para comenzar.

Encuentre un script que se convierta en binario y haga todo lo demás aquí: enlace

Está diseñado para otra familia Atmel (AVR32) pero debes tener la idea. Si tiene preguntas, hágamelo saber.