AVR- Anwendungsprogramm an Bootloader senden

Dies erfordert einige weitere Arbeit Ihrerseits, um es in Ihren Code zu integrieren, sollte Ihnen aber einige Ideen geben. Der erste Schritt im Bootloader besteht darin, Header in Bezug auf die Programmierung des FLASH einzufügen:

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

Ein paar andere Definitionen, die helfen, Dinge später zu definieren und einige Antwortcodes am Ende der Verarbeitung jeder Zeile zu definieren, sind:

#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};

Dann kann eine Routine wie die folgende verwendet werden, um das Intel-Hex-Format zu verarbeiten und in FLASH zu schreiben. Es ist für ein größeres Gerät geschrieben, behandelt also erweiterte Adressen in den Hex-Dateien, sodass Sie diese für Ihr kleineres Gerät entfernen können, um die Codegröße zu reduzieren, aber es schadet nicht, es an Ort und Stelle zu lassen. Sie müssen auch Ihren eigenen UART-Empfangs-/Init-Code hinzufügen und bestimmen, was zu tun ist, wenn die Dinge ablaufen, ich habe in diesem Fall einen Watchdog-Timer verwendet.

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 == '\0')
            ;
        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;
}

Es liest eine ganze Hex-Zeile und verifiziert die Prüfsumme, also vergleichen Sie es mit dem Intel-Hex-Format, um zu sehen, wie es im Detail funktioniert, bevor Sie es verwenden. Von dort ist die allgemeine Idee, dass, wenn es auf eine neue FLASH-Seitengrenze trifft, es löscht, aber ansonsten fortfährt und die Daten schreibt.

Wenn der Bootloader eingegeben wird, ist dies der Hauptcode, den ich verwendet habe, um ihn aufzurufen, aber noch einmal müssen Sie herausfinden, was zu tun ist, wenn ein Fehler auftritt. In meinem Fall habe ich eine benutzerdefinierte PC-Software verwendet, also einige Zeichenfolgen zurückgesendet, um den Status anzuzeigen, aber für einen Terminal-Upload möchten Sie möglicherweise nur ein EEPROM-Flag setzen, je nachdem, ob es erfolgreich war und Sie damit booten oder anzeigen sollten eine benutzerfreundliche Nachricht und rufen Sie den Bootloader erneut auf:

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
        ;
}

Wie auch immer, das sollte Ihnen einen guten Start geben und der obige Code wurde ziemlich gut mit einiger ziemlich komplexer Firmware getestet. Sie brauchen nur ein wenig Arbeit, um den fehlenden UART und anderen Initialisierungscode zu schreiben, um zu bestimmen, wann der Bootloader für Ihre Anwendung aufgerufen werden soll. Für einen ATmega32A sind möglicherweise auch einige Anpassungen erforderlich, aber ich denke, der Ansatz sollte auf allen AVR-Geräten ziemlich gut funktionieren.

Zum HEX-Format:

Lesen Sie, wie im Kommentar vorgeschlagen, das Intel HEX-Format. http://en.wikipedia.org/wiki/Intel_HEX

Was es sagt, ist im Grunde, dass jede Zeile einem Datenblock entspricht. Das Format der Zeile ist wie folgt:

:XYZC

Wo:

• X ist 1 Byte, das die Nutzdatenlänge angibt
• Y ist 1 Byte, das den Payload-Typ angibt *
• Z ist die Nutzlast der Länge X Bytes
• C ist 1 Byte der Prüfsumme der Zeile

*

'00' Datenaufzeichnung
'01' Dateiendeaufzeichnung
'02' Erweiterte Segmentadresse
'03' Startsegmentadressenaufzeichnung
'04' Erweiterte lineare Adressaufzeichnung
'05' Startlineare Adressaufzeichnung

Siehe http://microsym.com/editor/assets/intelhex.pdf für die gesamte Spezifikation.

Zum Übertragungsweg:

Es wird auch im Kommentar erwähnt - Sie sind viel besser dran, die gesamte Datei so zu senden, wie sie ist. Auf diese Weise benötigen Sie kein spezielles Programm auf der PC-Seite, sondern nur ein Terminal, das mit Ihrem Gerät kommuniziert. Analysieren Sie dann den Text auf dem Chip.

So schreiben Sie es:

Die einfachste Methode ist, die Anwendungshinweise von Atmel zu lesen:

Alle Selbstprogrammierungsoperationen werden unter Verwendung des SPM-Befehls ausgeführt

Diese finden Sie hier: http://www.atmel.com/images/doc1644.pdf

Der AVR109 ist ein berühmter Bootloader für Mega-Geräte. Hier finden Sie viele Informationen.

Es gibt Werkzeuge für solche Dinge. Zuallererst: Sie möchten den Controller nicht wirklich herausfinden lassen, wo er was ablegen soll, da dies das Parsen der Datei auf dem Controller erfordern würde.

Konvertieren Sie die Datei stattdessen in eine Binärdatei (die 1:1 in Flash geschrieben werden kann) und lassen Sie sie dann vom Controller auf die Anwendungsadresse flashen (das müssen Sie vorher herausfinden). Ein mögliches Programm, das ich sehe: Ihre Anwendung ist mit der Adresse 0x0 verknüpft - das bedeutet, dass der Bootloader, wenn er sich an dieser bestimmten Adresse befindet, nicht funktioniert (Sie müssen ihn mit einer anderen Adresse verknüpfen). Wenn sich der Bootloader an einer anderen Adresse befindet (vorzugsweise am Ende des Flashs), können Sie loslegen.

Bitte finden Sie hier ein Skript, das in Binärdateien konvertiert und alles andere erledigt: http://1drv.ms/1hj9eU0

Es ist für eine andere Atmel-Familie (AVR32) gedacht, aber Sie sollten die Idee bekommen. Wenn Sie Fragen haben, lassen Sie es mich wissen.