Suche Hilfe bei Optimierung Bootloader

[Jürgen S. (jsachs)]

Hallo,

ich habe mir einen Bootloader geschrieben, der soweit prima 
Funktioniert.
Nur verbraucht er die vollen 2k und ich könnte etwas mehr Flash fürs 
Programm brauchen. Daher mal eine Bitte, ob ihr drüber sehen könntet und 
mir sagen, wo man optimieren könnte.

Plattform ist ein ATmega32 mit avr gcc.

Das Protokoll ist vorgegeben und nicht veränderbar!
Alle Daten werden als ASCII übertragen, eine Zahl 0x01 also als "01" und 
somit 2 char.

Das ganze läuft ohne Interrupts (Deaktiviert)

Der Bootloader kann direkt vom Programm oder beim Start des Controllers 
aufgerufen werden. Die Unterscheidung mache ich über die Reset source.

Ist es ein boot nach einem Normalen Reset, prüfe ich die Programm 
Checksumme (steht im EEPROM) und führe das Programm aus, sofern diese ok 
ist, sonst bleibe ich im Bootloader.

Protokoll ist erstes Zeichen "@", dann Empfänger Adresse, sender Adresse 
und dann Kommando mit ggf. Nutzdaten

"@017FT?\r" Frägt zum Beispiel die Modul Version ab.

Achja, fehlende Defines kommen aus dem Makefile, wie "MODULE_ID", was 
einfach "1001" ist.

Kommandos, des Bootloaders, jeweils ohne "@" und Adressen. Diese kann 
man man hier als Beispiel immer mit "@017f" annehmen.

T? => liefert Modul Typ, zur Erkennung der Firmware
RT => Löst einen Reboot per Watchdog aus
BT => schickt page size (0x80 beim ATMega32)
BP => springt direkt ins Programm
BLnnMMMMMMMOOOO => Daten zum schreiben, nn = Anzahl Bytes (nicht 
Zeichen), MM = Daten, OOOO = CRC Summe der Daten
BSnnnnMMMM => Daten Transfer Start, nnnn = ID der Firmware, muss mit 
modul ID übereinstimmen, MMMM = Anzahl Bytes die kommen

Wäre über Tipps echt Dankbar.

Gruss
Juergen

Linker Zeile

avr-gcc -mmcu=atmega32 -I.  -MD -MP -MF .dep/bootloader.elf.d -D_TYPE_1001_="1001" -D_HAS_I2C_="_HAS_I2C_" -DMODULE_TYPE="1001" -DMODULE_ID=0x1001 -DF_CPU=16000000UL -DBOOTLOADER_ADR=0x7000 -DMODULE_VERSION=\"0.2.1\" -DADDR_PC_DEF=127 -DADDR_TX_LCD_DEF=102 -DADDR_TX_MAIN_DEF=101  -DADDR_RX_MAIN_DEF=1 -DADDR_BROADCAST_DEF=0 -DMY_DEF_ADDR=1 -DADDR_DEBUG_RS232_DEF=99 -DMAX_FUNC_CNT=32 -std=gnu99 obj/bootloader.o obj/addr_list.o --output bootloader.elf -Wl,-Map=bootloader.map,--cref -Ttext=0x7000

Und der Quellcode des Bootloaders

/**
 * The common bootloader for RX and TX
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <avr/boot.h>
#include <stdlib.h>
#include <string.h>
#include <util/crc16.h>
#include <avr/wdt.h>

#include "../global_files/avr_helper.h"

#if defined(_TYPE_1001_) || defined(_TYPE_1002_) || defined(_TYPE_1004_)
#warning "compiling mega32"
#define RESET_SOURCE_MASK (_BV(JTRF)|_BV(WDRF)|_BV(BORF)|_BV(EXTRF)|_BV(PORF))
#elif _TYPE_1003_
#warning "compiling mega328(p)"
#define RESET_SOURCE_MASK (_BV(WDRF)|_BV(BORF)|_BV(EXTRF)|_BV(PORF))
#elif _TYPE_1006_
#warning "compiling mega1284p"
#define RESET_SOURCE_MASK (_BV(WDRF)|_BV(BORF)|_BV(EXTRF)|_BV(PORF))
#else
#error "This code is not yet done for this module type"
#endif

char rxbuffer_boot[SPM_PAGESIZE*2+20]; // This is a hughe array, but we are in the bootloader and have all for us
char txbuffer[40];
uint16_t rxpos_boot = 0;    // anzahl empfangener Zeichen
uint8_t txpos = 0;    // anzahl zu sendender Zeichen
uint8_t txspos =  0;  // nächstes zu senden
uint8_t myAddress = MY_DEF_ADDR;  // unsere Adresse
uint32_t page = 0;
uint16_t crc = 0;
uint16_t shouldCrc = 0;

/**
 * The different states of the bootloader
 */
enum
{
    BOOT_CMD = 1,
    BOOT_DATA,
    BOOT_CHK
};

#define PROGMEM_CRC_ADDR 0x0000

void (*startMainApp)( void ) = 0x0000;        /* Funktionspointer auf 0x0000 */

/*
FUSES =
{
    .low = 0xFF, // 0xff
    .high = ( FUSE_EESAVE & FUSE_SPIEN & FUSE_CKOPT & FUSE_BOOTSZ1 & FUSE_BOOTSZ0 ) // 0xc1
};
*/
#if defined(_TYPE_1001_) || defined(_TYPE_1002_) || defined(_TYPE_1004_)
FUSES =
{
    0xFF,
    ( FUSE_EESAVE & FUSE_SPIEN & FUSE_CKOPT & FUSE_BOOTSZ1 & FUSE_BOOTSZ0 ) // 0xc1
    //EFUSE_DEFAULT
};
#elif defined (_TYPE_1006_) || defined (_TYPE_1003_)
FUSES =
{
    0xFD,
    ( FUSE_EESAVE & FUSE_SPIEN & FUSE_BOOTSZ1 & FUSE_BOOTSZ0 ), // 0xc1
    0xFF
    //EFUSE_DEFAULT
};
#endif
void ( *bootloader ) ( void ) = (void(*)(void))0x3800;


/**
 * converts AH to uint8_t value
 */
uint8_t ahtoUint8 ( uint8_t *data )
{
    uint8_t val = 0;

    for ( uint8_t i = 0 ; i < 2 ; i++ )
    {
        if ( ( data[i] >= '0' ) && ( data[i] <= '9' ) )
            val = ( val * 16 ) + ( data[i] - '0' );
        else if ( ( data[i] >= 'a' ) && ( data[i] <= 'f' ) )
            val = ( val * 16 ) + ( data[i] - 'a' + 0x0a );
        else
            break;
    }

    return val;
}

/**
 * converts AH to uint16_t value
 */
uint16_t ahtoUint16 ( uint8_t *data )
{
    uint16_t val = 0;

    for ( uint8_t i = 0 ; i < 4 ; i++ )
    {
        if ( ( data[i] >= '0' ) && ( data[i] <= '9' ) )
            val = ( val * 16 ) + ( data[i] - '0' );
        else if ( ( data[i] >= 'a' ) && ( data[i] <= 'f' ) )
            val = ( val * 16 ) + ( data[i] - 'a' + 0x0a );
        else
            break;
    }

    return val;
}

/**
 * convert uint16_t to AH. The result is stored in buffer
 */
char* uint16ToAh ( char *buffer, uint16_t val )
{
    uint16_t t = val;
    uint8_t z;

    for ( uint8_t i = 0 ; i < 4 ; i++ )
    {
        z = ( uint8_t ) ( ( t & 0xF000 ) >> 12 );
        t = t << 4;

        if ( ( z >= 0 ) && ( z <= 9 ) )
            buffer[i] = z + '0';
        else if ( ( z >= 0x0a ) && ( z <= 0x0f ) )
            buffer[i] = z + 'a' - 10;
    }

    buffer[4] = 0;

    return buffer;
}

/**
 * convert uint8_t to AH. The result is stored in buffer
 */
char* uint8ToAh ( char *buffer, uint8_t val )
{
    uint8_t t = val;
    uint8_t z;

    for ( uint8_t i = 0 ; i < 2 ; i++ )
    {
        z = ( uint8_t ) ( ( t & 0xF0 ) >> 4 );
        t = t << 4;

        if ( ( z >= 0 ) && ( z <= 9 ) )
            buffer[i] = z + '0';
        else if ( ( z >= 0x0a ) && ( z <= 0x0f ) )
            buffer[i] = z + 'a' - 10;
    }

    buffer[2] = 0;

    return buffer;
}

/**
 * Append Zero terminated string to TX buffer
 */
void uartPuts(const char *sb)
{
    int len = strlen(sb);
    if ((txpos+len) < sizeof(txbuffer))
    {
        strcat(txbuffer, sb);
        txpos+=strlen(sb);
    }
}

#define MSG "BOOT" /*SPM_PAGESIZE "\r\n"*/

/**
 * setup UART comm port
 */
void initUart(uint16_t baud)
{
    uint16_t ubrr = ( uint16_t ) ( ( ( uint32_t ) F_CPU / ( 16UL * baud ) ) - 1 );

#if defined(_TYPE_1001_) || defined(_TYPE_1002_) || defined(_TYPE_1004_)
    UBRRH = ( uint8_t ) ( ubrr << 8 ) & 0x0F;
    UBRRL = ( uint8_t ) ( ubrr & 0xFF );

    UCSRA = _BVC(U2X) | _BVC(MPCM);

    UCSRB = _BV ( RXEN ) | _BV ( TXEN ) | _BVC( RXCIE ) | _BVC(UCSZ2);

    UCSRC = _BV ( URSEL ) | _BVC(UMSEL) | _BV ( UCSZ1 ) | _BV ( UCSZ0 ) | _BVC(USBS) | _BVC(UPM1) | _BVC(UPM0) | _BVC(UCPOL);
#elif defined (_TYPE_1006_) || defined (_TYPE_1003_)
    UBRR0H = ( uint8_t ) ( ubrr << 8 ) & 0x0F;
    UBRR0L = ( uint8_t ) ( ubrr & 0xFF );

    UCSR0A = _BVC(U2X0) | _BVC(MPCM0);

    UCSR0B = _BV ( RXEN0 ) | _BV ( TXEN0 ) | _BVC( RXCIE0 ) | _BVC(UCSZ02);

    UCSR0C = _BVC ( UMSEL01 ) | _BVC(UMSEL00) | _BV ( UCSZ01 ) | _BV ( UCSZ00 ) | _BVC(USBS0) | _BVC(UPM01) | _BVC(UPM00) | _BVC(UCPOL0);
#endif
}



/**
 * write a buffer to flash page.
 * This is 1:1 from the avrlibc documentation
 */
void boot_program_page (uint32_t page, uint8_t *buf)
{
    uint16_t i;
    uint8_t sreg;

    uint8_t z='0'+page;

    // Disable interrupts.

    sreg = SREG;
    cli();

    eeprom_busy_wait ();

    boot_page_erase (page);
    boot_spm_busy_wait ();      // Wait until the memory is erased.

    for (i=0; i<SPM_PAGESIZE; i+=2)
    {
        // Set up little-endian word.

        uint16_t w = *buf++;
        w += (*buf++) << 8;

        boot_page_fill (page + i, w);
    }

    boot_page_write (page);     // Store buffer in flash page.
    boot_spm_busy_wait();       // Wait until the memory is written.

    // Reenable RWW-section again. We need this if we want to jump back
    // to the application after bootloading.

    boot_rww_enable ();

    // Re-enable interrupts (if they were ever enabled).

    SREG = sreg;
}

/**
 * Send the header of a command
 */
void sendHeader(uint8_t toAddr)
{
    char buffer[6];
    uartPuts("@");
    uartPuts(uint8ToAh(buffer, toAddr));
    uartPuts(uint8ToAh(buffer, myAddress));
}

/**
 * send module ID
 */
void sendModuleID(uint8_t toAddr)
{
    char buffer[6];
    sendHeader(toAddr);
    uartPuts("T");
    uartPuts(uint16ToAh(buffer, MODULE_ID));
    uartPuts("\r");
}

/**
 * Send flash page size
 * This is used by the app to adjust data send
 */
void sendPageSize(uint8_t toAddr)
{
    char buffer[6];
    sendHeader(toAddr);
    uartPuts("BT");
    uartPuts(uint16ToAh(buffer, SPM_PAGESIZE));
    uartPuts("\r");
}

/**
 * Send ACK for reboot command
 */
void sendRebootACK(uint8_t toAddr)
{
    char buffer[6];
    sendHeader(toAddr);
    uartPuts("RTA");
    uartPuts("\r");
}

/**
 * Send Bot loader ACK
 */
void sendBootloaderACK(uint8_t toAddr)
{
    char buffer[6];
    sendHeader(toAddr);
    uartPuts("BLA");
    uartPuts(uint16ToAh(buffer, page));
    uartPuts("\r");
}

/**
 * Send bootloader NACK
 */
void sendBootloaderNACKcrc(uint8_t toAddr)
{
    char buffer[6];
    sendHeader(toAddr);
    uartPuts("BLNcrc");
    uartPuts(uint16ToAh(buffer, crc));
    uartPuts(",sh ");
    uartPuts(uint16ToAh(buffer, shouldCrc));
    uartPuts("\r");
}

/**
 * Send Prog CRC
 */
void sendProgCRC(uint8_t toAddr, uint16_t crc)
{
    char buffer[6];
    sendHeader(toAddr);
    uartPuts("CRC");
    uartPuts(uint16ToAh(buffer, crc));
    uartPuts(uint16ToAh(buffer, eeprom_read_word(PROGMEM_CRC_ADDR)));
    uartPuts("\r");
}

void sendBootloaderNACK(uint8_t toAddr)
{
    char buffer[6];
    sendHeader(toAddr);
    uartPuts("BLN");
    uartPuts("\r");
}

/**
 * Send Bootloader start downbload ACK or NACK
 */
void sendBootloaderStartACK(uint8_t toAddr, uint8_t ack)
{
    char buffer[6];
    sendHeader(toAddr);
    if (ack)
        uartPuts("BSA\r");
    else
        uartPuts("BSN\r");
}


uint8_t doTransmitUart(void)
{
    // Handle transmit data
#if defined(_TYPE_1001_) || defined(_TYPE_1002_) || defined(_TYPE_1004_)
    if ((txpos > 0) && (UCSRA & _BV(UDRE)))
#elif defined (_TYPE_1006_) || defined (_TYPE_1003_)
    if ((txpos > 0) && (UCSR0A & _BV(UDRE0)))
#endif
    {
#if defined(_TYPE_1001_) || defined(_TYPE_1002_) || defined(_TYPE_1004_)
        UDR = txbuffer[txspos];
#elif defined (_TYPE_1006_) || defined (_TYPE_1003_)
        UDR0 = txbuffer[txspos];
#endif
        txspos++;

        if (txspos >= txpos)
        {
            txspos = 0;
            txpos = 0;
            txbuffer[0] = 0;
        }
    }
    return txpos;
}

/**
 * Caclulate program CRC
 * This function calculate the CRC over all program space
 */
uint16_t calcProgCRC(void)
{
    crc = 0;
    for (uint16_t i=0; i<(BOOTLOADER_ADR); i++)
    {
        crc = _crc_xmodem_update(crc, pgm_read_byte ( i ));
    }
    return crc;
}



/**
 * Our main loop
 */
int main ( void )
{
#if defined(_TYPE_1001_) || defined(_TYPE_1002_) || defined(_TYPE_1004_)
    uint8_t resetSource = MCUCSR & RESET_SOURCE_MASK;
    MCUCSR &= ~RESET_SOURCE_MASK;
#elif defined (_TYPE_1006_) || defined (_TYPE_1003_)
    uint8_t resetSource = MCUSR & RESET_SOURCE_MASK;
    MCUSR &= ~RESET_SOURCE_MASK;
#endif
    wdt_disable(); // Important or we risk a mess
    cli();


    initUart ( 38400 );  


    uint8_t status = BOOT_CMD;
    uint8_t toAddr = 0x00;
    uint8_t fromAddr = myAddress;
    uint16_t fwsize = 0;  // size of fw to load
    uint16_t rxfwsize = 0;  // size of received size
    char buffer[10];
    uint8_t cmd_rx = 0;

    // we just forced into boot loader
    // aCK this and report page size !
    //sendModuleID(toAddr);
    //while (doTransmitUart());
    uint16_t iscrc = calcProgCRC();
    sendProgCRC(ADDR_BROADCAST_DEF, iscrc);
    while(doTransmitUart());
 
    sendPageSize(ADDR_BROADCAST_DEF);
    while (doTransmitUart());  // Empty TX buffer

    while ( 1 )
    {
        /*
         * IF get this far without any reset source set,
         * we are directly called by the main app
         * So we have to skip the CRC check and directly continue with the bootloader
         */
        if (resetSource != 0)  // not jumped in on purpose (from main app)
        {
            /*
             * We have come here after a reset. We now check the CRC of tzhe program
             * If it is ok, we will start the main app. If not, we will continue
             * with the boot loader
             */
            if (iscrc == eeprom_read_word(PROGMEM_CRC_ADDR))
            {
                static uint16_t delay=0xffff;
        delay--;
                if (delay == 0)
                {
                    sendHeader(ADDR_BROADCAST_DEF);
                    uartPuts("MPCRCOk\r");
                    startMainApp();  // reboot into main prog
                }
            }
            else
            {
                sendHeader(ADDR_BROADCAST_DEF);
                //uartPuts("MPCRCErr\r");
            }
        }
        while (doTransmitUart());  // Empty TX buffer

        // Handle receive data
        char c = 0;
#if defined(_TYPE_1001_) || defined(_TYPE_1002_) || defined(_TYPE_1004_)
        if (UCSRA & _BV(RXC))
        {
            c = UDR;
#elif defined (_TYPE_1006_) || defined (_TYPE_1003_)
        if (UCSR0A & _BV(RXC0))
        {
            c = UDR0;
#endif
            rxbuffer_boot[rxpos_boot] = c;
            rxpos_boot++;
            if (c == '\r')
      {
        resetSource = 0;  // Stay here
                cmd_rx = 1;
      }
            if (rxpos_boot > sizeof(rxbuffer_boot))
            {
                rxpos_boot=0;
            }

        }
        doTransmitUart();
        if (cmd_rx == 1)
        {
            uint8_t error = 0;
            // If the syntax is not correct, we will simply ignore the rest and fall through.
            if ((rxbuffer_boot[0] == '@') || (rxpos_boot >= 7)) // "@" + <adr> + B + <cmd> + <optional data>
            {
                toAddr = ahtoUint8((uint8_t*)&rxbuffer_boot[1]);
                fromAddr = ahtoUint8((uint8_t*)&rxbuffer_boot[3]);
                if ((toAddr == myAddress) || (toAddr == ADDR_BROADCAST_DEF))
                {
                    // Ok, this is a message for us !
                    if ((rxbuffer_boot[5] == 'T') && (rxbuffer_boot[6] == '?'))
                    {
                        sendModuleID(fromAddr);
                    }
                    else if ((rxbuffer_boot[5] == 'R') && (rxbuffer_boot[6] == 'T'))
                    {
                        sendRebootACK(fromAddr);
                        wdt_enable(WDTO_250MS);
                    }
                    else if (0) //(rxbuffer_boot[5] == 'D') && (rxbuffer_boot[6] == 'F'))
                    {
                        for (uint16_t s=0; s<(0x7fff) ; s+=SPM_PAGESIZE)
                        {
                            uartPuts("\r\n");
                            uartPuts(uint16ToAh(buffer, s));
                            uartPuts(">");

                            while (txpos)
                                doTransmitUart();


                            for (uint8_t b=0; b<SPM_PAGESIZE ; b++)
                            {
                                uartPuts(uint8ToAh(buffer, pgm_read_byte((uint8_t*)(b+s)) ));

                                while (txpos)
                                    doTransmitUart();
                            }
                        }
                    }
                    else if ((rxbuffer_boot[5] == 'B') && (rxbuffer_boot[6] == 'T'))
                    {
                        sendPageSize(fromAddr);
                        //startMainApp();
                        //bootloader();  // jump back from bootloader to bootloader, does make sense ? :-)
                    }
                    else if ((rxbuffer_boot[5] == 'B') && (rxbuffer_boot[6] == 'P'))
                    {
                        //sendPageSize(fromAddr);
                        startMainApp();
                        //bootloader();  // jump back from bootloader to bootloader, does make sense ? :-)
                    }
                    else if ((rxbuffer_boot[5] == 'B') && (rxbuffer_boot[6] == 'L') && (rxpos_boot >= 9))
                    {
                        uint8_t bytecnt = ahtoUint8((uint8_t*)&rxbuffer_boot[7]);
                        uint8_t offset = 9;
                        if (rxpos_boot >= ((bytecnt*2)+offset+4))
                        {
                            uint16_t pos;
                            // reformat data to binary
                            // we reuse the rx array, as we are sure no additional data comes in (we are stuck here, right !)
                            // this is save
                            crc = 0;
                            for (uint16_t i = 0 ; i < bytecnt ; i++)
                            {
                                pos = (i*2)+offset;
                                rxbuffer_boot[i] = ahtoUint8((uint8_t*)&rxbuffer_boot[pos]);
                                crc = _crc_xmodem_update(crc, rxbuffer_boot[i]);
                            }

                            rxfwsize+=bytecnt;

                            // get should crc
                            pos = (bytecnt*2)+offset;
                            shouldCrc = ahtoUint16((uint8_t*)&rxbuffer_boot[pos]);

                            // Fill remainder of page
                            if (bytecnt < SPM_PAGESIZE)
                            {
                                for (uint16_t i = bytecnt ; i < SPM_PAGESIZE ; i++)
                                    rxbuffer_boot[i] = 0xFF;  // Will be ignored by CPU !
                            }

                            if (crc == shouldCrc)
                            {
                                // now write flash
                                boot_program_page(page, (uint8_t*)rxbuffer_boot);

                                page+=SPM_PAGESIZE;

                                if (rxfwsize >= fwsize)
                                {
                                    uint16_t iscrc = calcProgCRC();
                                    eeprom_write_word((uint16_t*)PROGMEM_CRC_ADDR, iscrc);
                                    sendProgCRC(ADDR_BROADCAST_DEF, iscrc);
                                }

                                sendBootloaderACK(fromAddr);

                            }
                            else
                            {
                                sendBootloaderNACKcrc(fromAddr);
                            }
                        }
                        else
                        {
                            sendBootloaderNACK(fromAddr);
                        }
                    }
                    else if ((rxbuffer_boot[5] == 'B') && (rxbuffer_boot[6] == 'S') && (rxpos_boot >= 15))
                    {
                        uint16_t id = ahtoUint16((uint8_t*)&rxbuffer_boot[7]);
                        if (id == MODULE_ID)
                        {
                            fwsize = ahtoUint16((uint8_t*)&rxbuffer_boot[11]);
                            if (fwsize > 0)
                            {
                                sendBootloaderStartACK(fromAddr, 1);
                                page = 0;
                            }
                            else
                            {
                                error = 2;
                            }
                        }
                        else
                            error = 1;
                        if (error)
                        {
                            sendBootloaderStartACK(fromAddr, 0);
                        }
                    }
                    else
                    {
                        //sendUnknownCmd(fromAddr);
                    }
                }
            }
            rxpos_boot = 0;
            cmd_rx = 0;
        }
    }
}

[Peter II (Gast)]

Jürgen Sachs schrieb:
> Daher mal eine Bitte, ob ihr drüber sehen könntet und
> mir sagen, wo man optimieren könnte.

du hast zu viel doppelte code

ahtoUint8
ahtoUint16

die 2.Version braucht niemand.

uint16_t x = ahtoUint8(data) << 8 | ahtoUint8(data+2);

auch die ganze Send Funktionen lassen sich bestimmt sparsamer bauen.
Überall ist

    sendHeader(toAddr);
    uartPuts("BLA");
    uartPuts("\r");

drin.

[Jürgen S. (jsachs)]

Peter II schrieb:
> Jürgen Sachs schrieb:
>> Daher mal eine Bitte, ob ihr drüber sehen könntet und
>> mir sagen, wo man optimieren könnte.
>
> du hast zu viel doppelte code
>
> ahtoUint8
> ahtoUint16
>
> die 2.Version braucht niemand.
>
> uint16_t x = ahtoUint8(data) << 8 | ahtoUint8(data+2);
>
> auch die ganze Send Funktionen lassen sich bestimmt sparsamer bauen.
> Überall ist
>

>     sendHeader(toAddr);
>     uartPuts("BLA");
>     uartPuts("\r");
>

> drin.
Das ging ja schnell :-)

Danke, auf die Idee Funktionen zu kombinieren we

uint16_t x = ahtoUint8(data) << 8 | ahtoUint8(data+2);

bin ich gar nicht gekommen.
aber wie ich den zweiten Punkt, den du erwähnt hast, vereinfachen soll, 
fehlt mir die Idee.
Die Funktionen sind ja schon eine Zusammenfassung, damit ich sich 
wiederholenden Code zusammen fasse.
Das einzige was mir auffällt, das die ganzen Zeichen nicht aus dem Flash 
kommen, sondern aus dem RAM. Aber davon habe ich ja im Bootloader die 
ganzen 2k für mich alleine.
Ich denke nicht, dass ich da Code größe sparen kann, zudem ich dann eine 
sendUart_p() Funktion machen müsste.

Aber die ersten 282 Byte Einsparung waren ja schon mal recht einfach.
Danke
Juergen

[Karl H. (kbuchegg)]

Jürgen Sachs schrieb:

> Danke, auf die Idee Funktionen zu kombinieren we
>

uint16_t x = ahtoUint8(data) << 8 | ahtoUint8(data+2);

> bin ich gar nicht gekommen.

Solltest du aber.
Immer dann, wenn du COpy&Paste Programmierung machst und nur ein paar 
Zahlenwerte in der neuen Funktion austauscht, solltest du dir Gedanken 
machen, wie man die Dinge zusammenführen kann.

Das hier

void uartPuts(const char *sb)
{
    int len = strlen(sb);
    if ((txpos+len) < sizeof(txbuffer))
    {
        strcat(txbuffer, sb);
        txpos+=strlen(sb);
    }
}

ist auch viel zu kompliziert

void uartPuts(const char *sb)
{
  while( *sb && txpos < sizeof(txbuffer) )
    txbuffer[txpos++] = *sb++;
}

Nichts gegen die str... Funktionen. Aber oftmals ist es viel einfacher, 
wenn man selber die Dinge in die Hand nimmt.

> Die Funktionen sind ja schon eine Zusammenfassung, damit ich sich
> wiederholenden Code zusammen fasse.

zb ist allen Funktionen gemeinsam, dass zuerst der Header geschickt 
wird, gefolgt von einem String.
Warum muss jetzt in jeder Bearbeitungsfunktion wieder einzeln sendHeader 
und uartPuts aufgerufen werden? Warum gibt es nicht eine Funktion

void uartSendResponse( const char* str )
{
  sendHeader( .. );
  uartPuts( str );
}

die von jeder Funktion als erstes aufgerufen wird?

...
void sendPageSize(uint8_t toAddr)
{
    uartSendRespone( "BT" );
    uartPuts(uint16ToAh(buffer, SPM_PAGESIZE));
    uartPuts("\r");
}
...

und schon ist in jeder deiner Bearbeitungsfunktionen ein Funktionsaufruf 
weniger, der speichertechnisch zu Buche schlägt.

Auch kommt das zb

    uartPuts("\r");

oft vor. So oft, dass es sich ev. schon lohnen würde, dafür eine eigene 
Funktion zu machen, die genau einen \n in den txBuffer stellt.

[Johann L. (gjlayde)]

Müssen die ganzen Fuunktionen wirklich global sein oder tut es auch 
static?

[Karl H. (kbuchegg)]

Deine ganzen ....ToAh Funktionen.
Alles viel zu kompliziert geschrieben.

Du hast genau 1 Funktion, die einen Wert im Bereich 0 bis 0xF übernimmt 
und das entsprechende Zeichen dafür generiert.
Die Funktionen für uint8_t etc. benutzen dann wieder diese kleinere 
Hilfsfunktion um die 2 Zeichen zu erzeugen, die es für 1 Byte braucht. 
Die Funktion für uint16_t greift wieder auf die Funktion zurück, die 1 
Byte konvertieren kann (1 uint16_t besteht ja aus 2 uint8_t)

char hexDigit( uint8_t val )
{
  if( val > 9 )
    return val + 'a' - 10;

  return val + '0';
}

char* uint8ToAh ( char *buffer, uint8_t val )
{
  buffer[0] = hexDigit( val >> 4 );
  buffer[1] = hexDigit( val & 0x0F );

  return buffer;
}

char* uint16ToAh ( char *buffer, uint16_t val )
{
  uint8ToAh( buffer, val >> 8 );
  uint8ToAh( buffer + 2, val );

  return buffer;
}

Du musst noch viel mehr in aufeinander aufbauenden Funktionen denken!

[Karl H. (kbuchegg)]

Solche Konstrukte

    uartPuts(uint16ToAh(buffer, crc));

... also das Senden eines Zahlenwerts ....

scheinen mir auch hinreichend häufig vorzukommen, so dass sich eigene 
Funktionen

  uartPutUint8
bzw.
  uartPutUint16

lohnen würden.
Das könnte man jetzt natürlich auch so machen, dass man um 1 uint16_t zu 
senden, diesen Fall auf das versenden von 2 uint8_t zurückführt. Wodurch 
wiederrum die Konvertierfunktion für einen uin16_t überflüssig werden 
würde, was wiederrum Speicher spart.

Das befreit dich dann auch vom immer gleichen buffer, den du quer durch 
die Bank nur zur Konvertierung der Zahlen in vielen Funktionen brauchst.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Das könnte man jetzt natürlich auch so machen, dass man um 1 uint16_t zu
> senden, diesen Fall auf das versenden von 2 uint8_t zurückführt. Wodurch
> wiederrum die Konvertierfunktion für einen uin16_t überflüssig werden
> würde, was wiederrum Speicher spart.

Wohingegen das Versenden eines uint8_t wiederrum so einfach ist, dass 
man auch die Konvertierfunktion für einen uint8_t gar nicht mehr 
braucht.
Jetzt wäre es natürlich gut, wenn es eine Funktion gäbe, die ein 
einzelnes Zeichen in den Ausgabepuffer stellt. Ich postuliere mal, dass 
es so eine gibt.

void uartPutUint8( uint8_t val )
{
  uartPutC( hexDigit( val >> 4) );
  uartPutC( hexDigit( val & 0x0F );
}

void uartPutUint16( uint16_t val )
{
  uartPutUint8( val >> 8 );
  uartPutUint8( val );
}

und die ganzen Konvertierfunktionen für uint8_t bzw. uint16_t sind damit 
obsolet geworden.
Wohingegen sich die Bearbeitungsfunktionen zb so schreiben

void sendProgCRC(uint8_t toAddr, uint16_t crc)
{
    uartSendResponse( "CRC" );
    uartPutUint16( crc );
    uartPutUint16( eeprom_read_word(PROGMEM_CRC_ADDR) );
    uartPutC('\r');
}

NB: In deinem Bootloader gibt es ein kunterbuntes Mischmasch, ob du eine 
Ausgabe mit \r, mit \n, oder sogar mit \r\n abschliesst. Einige dich mit 
dir selbst auf eine Variante und zieh sie durch!

[Karl H. (kbuchegg)]

Warum heisst es an manchen Stellen in deinem Programm

                            while (txpos)
                                doTransmitUart();

und an manch anderen Stellen

    while (doTransmitUart());  // Empty TX buffer

beides macht offenbar dasselbe: Es gibt alles aus, was zu diesem 
Zeitpunkt im TxBuffer gesammelt wurde.

Aber dann solltest du das auch immer auf die gleiche Art und Weise 
schreiben!

Und am einfachsten geht das, wenn es eine Funktion

void emptyTxBuffer()
{
  while (doTransmitUart())
    ;
}

gibt, und du die überall aufrufst, wo du jetzt die while Schleifen 
explizit drinnen hast.

[Karl H. (kbuchegg)]

uint32_t page = 0;

ich weiss zwar nicht, was es mit 'page' genau auf sich hat.
Aber bist du sicher, dass das ein uint32_t sein muss?

Ist dir klar, welche Auswirkungen dieser Datentyp da hat?

Wenn page das aussagt, was ich vermute das es aussagt, dann kann ich mir 
nicht vorstellen, dass es jemals einen AVR geben wird, der den möglichen 
Wertebereich eines uin32_t auch nur annähernd ausnützt.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:
>

> uint32_t page = 0;
>

>
> ich weiss zwar nicht, was es mit 'page' genau auf sich hat.
> Aber bist du sicher, dass das ein uint32_t sein muss?
>
> Ist dir klar, welche Auswirkungen dieser Datentyp da hat?
>
> Wenn page das aussagt, was ich vermute das es aussagt, dann kann ich mir
> nicht vorstellen, dass es jemals einen AVR geben wird, der den möglichen
> Wertebereich eines uin32_t auch nur annähernd ausnützt.

Ah, ja

void sendBootloaderACK(uint8_t toAddr)
{
...
    uartPuts(uint16ToAh(buffer, page));
...
}

soviel dazu :-)

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Wenn page das aussagt, was ich vermute das es aussagt


Muss ich zurücknehmen.
Die Variable ist einfach nur schlecht benannt.
Das ist die Byte-Startadresse im Flash, ab der geschrieben werden soll. 
Ich dachte das wäre eine Page-Nummer.

In dem Fall ist ein uint32_t ok, da es ja AVR mit mehr als 64K Flash 
gibt.

Aber dann sollte die Rückmeldefunktion auch mit einem uint32_t 
operieren!

[Jürgen S. (jsachs)]

So, ich denke ich habe mal das meiste umgesetzt.
Alles ist doch mit ganz schön arbeit verbunden

das mit der page variable hatte ich damals so übernommen von der 
Funktion aus der avrlibc.

Aktuell ist er schon etwas kleiner geworden
laut avr size
text von 0xf9c auf 0xe60
data von 0x44 auf 0x40
bss von 0x14a auf 0x148
hex von 112a auf fe8

es wird....

Die Optimierung der umwandel Routinen muss ich mir noch mal ansehen

Ich danke euch allen mal für die Hilfe...

Falls ihr noch was findet, immer gerne

Gruss
Juergen

[Peter II (Gast)]

Jürgen Sachs schrieb:
> Falls ihr noch was findet, immer gerne

kannst du mal die aktuelle Version, mit ordentlicher Formatierung 
einfügen?

[Johann L. (gjlayde)]

Jürgen Sachs schrieb:
> Falls ihr noch was findet, immer gerne

Falls eine Funktion (statisch) nur 1x verwendet wird und nicht global 
sein muss, dann kann es günstiger sein, sie als static zu deklarieren. 
Dann kann sie inline eingefügt werden was u.U. deutlich Codegröße spart.


> Falls ihr noch was findet, immer gerne

Viele Funktionen verwenden einen Puffer der Speicherklasse auto wie z.B.

char buffer[6];

Falls die Funktion nicht reentrant sein muss — was bei deinem Bootloader 
vermutlich der Fall ist — kann es günstifer sein, den Puffer statisch zu 
vergeben, d.h. entweder local static oder modul-statisch.  Das spart 
evtl. das Anlegen eines Frames, was sehr teuer ist.


> Falls ihr noch was findet, immer gerne

Mitunter ist es teuer, Variablen wie rxpos_boot global zu haben.  Wenn 
sie wirklich global sein muss und sich die Verwenung an einer Stelle 
häuft, dann kann es günstiger sein, sie in eine lokale Variable zu 
laden.  Grund sind die Aliasing-Rules von C.


> Falls ihr noch was findet, immer gerne

Ist wirklich notwendig, strlen und strcat zu verwenden?  Im Bootloader 
brauch man doch keine Nebenläufigkeit, und die UART-Routinen bzw. puts 
et al. können blockierend arbeiten, d.h. Zeichenketten werden Zeichen 
für Zeichen ausgegeben bis der auszugebende String aufgebraucht ist.


...und noch ein paar Anmerkungen zum Stil:

> Falls ihr noch was findet, immer gerne

An mehreren Stellen lese ich ein CLI bzw. Operationen mit SREG, aber 
nirgends ist ein SEI.  Wozu das alles?


> Falls ihr noch was findet, immer gerne

Um die Anwendung zu starten springst du nach 0x0 (startMainApp) was 
mehrere Nachteile hat:

1) Die Handware wird nicht initialisiert, d.h. es bleiben Einstellungen 
des Bootloaders bestehen.  Geht die Anwendung davon aus, dass die 
Hardware frisch der Reset initialisiert ist (was fast alle Anwendungen 
tun), dann geht die Anwendung also von falschen Voraussetzungen aus.

Falls möglich, sollte ein Reset immer ein Hard-Reset sein!


> Falls ihr noch was findet, immer gerne

Ad '\r'

Ein Zeilenumbruch in C ist immer ein '\n', d.h. im Code wird man 
immer ein \n ausgeben.  Das '\r' hat im "normalen" Code nix zu suchen, 
denn der Code weiß ja nicht, welches OS die Gegenstelle fährt.  Ergo: 
Falls notwendig, gibt es eine einzige Stelle im Code, welche das \r 
ausgibt, und zwar die zentrale put-Routine selbst, etwa so:

    ...
#ifdef HOST_WINDOWS
    // For MS-Windows terminal: output newline as "\r\n".
    if (c == '\n')
        uart_putc ('\r');
#endif /* HOST_WINDOWS */
    uart_putc (c);
    ...

In diesem Beispiel wird mit -DHOST_WINDOWS compiliert falls die 
Gegenstelle ein Windows ist.  Falls es zur Compilezeit nicht bekannt 
ist, wird es etwas komplizierter.

Dies muss natürlich nur beachtet werden, wenn die Kommunikation mit 
einem terminal o.ä. geschieht; falls es sich um ein eigenes Protokoll 
mit einer definierten Gegenstelle handelt, ist die Unterscheidung i.d.R. 
nicht notwendig, aber dennoch ist es nicht ratsam, den Code mit \r zu 
übersäen.


> Falls ihr noch was findet, immer gerne

An vielen Stellen stehen Casts wie

ahtoUint16((uint8_t*)&rxbuff...

Besser den Cast in ahtoUint16 machen und als Parameter const void* 
übergeben.

[Frank M. (ukw) (Moderator)]

Johann L. schrieb:
> In diesem Beispiel wird mit -DHOST_WINDOWS compiliert falls die
> Gegenstelle ein Windows ist.  Falls es zur Compilezeit nicht bekannt
> ist, wird es etwas komplizierter.

Wieso? Ich beschreibe mal das Szenario für Unix/Linux:

Ich kann es mir nur so vorstellen: Ich starte Kermit oder ein ähnliches 
(Terminal-Emulations-)Programm, welches mit TTYs umgehen kann. Dieses 
Programm wird das TTY, an dem der µC via UART angeschlossen ist, im 
Normalfall im Raw-Mode öffnen, d.h. es findet keine 
CarriageReturn/Newline-Wandlung statt. Oder auch anders gesagt: Das Flag 
ONLCR ist normalerweise am TTY des µCs nicht gesetzt.

Ein Terminal - egal ob es ein echtes Terminal oder eine Emulation ist, 
erwartet standardmäßig immer ein Carriage Return ('\r' und ein Newline 
('\n'), um den Cursor:

  a) an den Anfang der(selben) Zeile zu setzen ('\r')
  b) den Cursor um eine Zeile nach unten zu setzen ('\n')

Das heisst: Auch wenn Dein µC mit einem Unix-/Linux-Host verbunden ist, 
muss der µC ein \r\n schicken, um einen korrekten Zeilenvorschub zu 
erzeugen.

Das ist komplett unabhängig vom Host.

Warum Unix-/Linux-Programme selber lediglich ein bloßes '\n' schicken 
(müssen), um einen korrekten Zeilenvorschub zu erzeugen, liegt an den 
Einstellungen des TTYs, an dem der Benutzer arbeitet: Dieses läuft im 
"Cooked-Mode", d.h. es sind (unter anderem) die Flags OPOST und ONLCR 
eingeschaltet. Damit wird ein Newline ('\n') vom TTY-Treiber in ein 
CarriageReturn + Newline ('\r\n') gewandelt. Aber wohlgemerkt: Das ist 
das TTY, an dem der User arbeitet und nicht das TTY, an dem der µC 
hängt!

Fazit: Es muss keine Unterscheidung bzgl. des Hosts gemacht werden. Wenn 
doch, ist das TTY für den µC am Unix-/Linux falsch eingestellt. 
Kommunikationsprogramme wie Kermit und andere 
Terminal-Emulationsprogramme arbeiten in dieser Hinsicht aber korrekt.

Auch wenn man ein eigenes Flash-Programm (und kein Terminalprogramm) 
verwendet, welches über das TTY mit dem µC kommuniziert und keine 
TTY-Flags ändert: Standardmäßig sind die Flags OPOST und ONLCR 
abgeschaltet auf TTYs, auf denen kein getty (o.ä.) läuft. D.h. die 
Zeichen werden 1:1 im Hostprogramm ankommen. Selbstverständlich muss es 
dann natürlich ein '\r\n' in der Antwort erwarten. Warum sollte es nur 
ein '\n' sein? Nur, weil es unter Linux läuft? Nein, das ist kein 
Kriterium, wenn es um TTY-Kommunikation geht.

[JSachs (Gast)]

Das Protokoll läuft zwischen dem atmega und einem speziellen Programm 
ab.
Das Protokoll ist nicht für die direkte Ausgabe in einem terminal 
gedacht.

Statt dem CR hätte ich auch ein etx (0x03) nehmen können.

Da das ganze über Bluetooth geht, will ich unnötige Zeichen vermeiden.

Zum Flaschen gibt es eine spezielle Software, die mit dem bootloader 
über Bluetooth spricht.

Im Normalbetrieb sind es 2 atmega, die sich per Bluetooth unterhalten.

Also spielt das CR nur eine untergeordnete Rolle.

Stelen und strcat sind, dank eurer Vorschläge, Vergangenheit.

Warum die Funktionen für den UART nicht blockend sind, hat einfach den 
Hintergrund, das die aus einer frühen Version des hauptcodes kommen und 
da muss das alles per interrupt laufen.

Das cli genutzt wird, aber kein sei hat einfach den Grund sicher zu 
sein, dass der interrupt aus ist, wenn ich z.b. vom Programm in den 
bootloader springe.

Und ich springe an Position 0x0000 da ein reset mich wieder in den 
bootloader bringt. Das ist per Fuse so eingestellt und beabsichtigt. 
Mein Programm initialisiert alles (hoffe ich)

Gruss
Juergen

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Hallo,
ich habe mir das jetzt nicht im Detail angeguckt: hast Du die 
Optimierung (-Os) des Compilers eingeschaltet? Ansonsten kannst Du mit 
--gc-sections noch dafür sorgen, dass nur referenzierter Code auch im 
binary landet. Und mit -ffunction-sections -fdata-sections dafür sorgen, 
dass jede Funktion und jedes Datum in einer eigenen section landet und 
damit nur dann im binary landet, wenn es referenziert wird. Danach würde 
ich dann mal im Mapfile gucken.

mfg Torsten

[Foka M. (foka)]

Johann L. schrieb:
> An vielen Stellen stehen Casts
> wie

ahtoUint16((uint8_t*)&rxbuff...

> Besser den Cast in ahtoUint16
> machen und als Parameter const void* übergeben.

Koenntest Du Beschreiben welchen Vorteil man davon hat?
Eine Signatur mit

 void foo(const uint8_t* x);

oder

 void foo(const void* x);

fuehrt doch immer dazu, dass ein 16-Bit Wert (auf dem 8-Bit AVR) kopiert 
wird. Was uebersehe ich?

-Foka

[Jürgen S. (jsachs)]

So,

sorry für die späte Rückmeldung, aber es gab leider andere Dinge die 
Vorrang hatten.

Aktuell ist es so, dass ich die Maximale Größe des Bootloaders 
beanspruche, also 4k oder 2000 Worte. Da bin ich irgendwie durcheinander 
gekommen.
Beim compilieren ergibt sich daraus 3750 Bytes

avr-size bootloader.elf 
   text     data      bss      dec      hex  filename
   3678       74      330     4082      ff2  bootloader.elf
avr-size --mcu=atmega32 -C bootloader.elf
AVR Memory Usage
----------------
Device: atmega32

Program:    3750 bytes (11.4% Full)
(.text + .data + .bootloader)

Data:        402 bytes (19.6% Full)
(.data + .bss + .noinit)

Gibt es überhaupt eine Chance das auf unter 2000Byte zu bekommen?
Weil das wäre die nächst kleinere Größe des Bootloaders.

In Manchen Setups nehme ich schon eine größere CPU, aber beim manchen 
benutze ich das BCA8-BTM mit einem mega328p, da kann ich nicht größer 
werden.
Der Compile unten ist für einen mega32.

Zur Frage der Compiler Optionen

avr-gcc bootloader.cpp -mmcu=atmega32 -I. -MD -MP -MF .dep/bootloader.o.d -D_TYPE_1007_=1007 -DMODULE_TYPE=1007 -DMODULE_ID=0x1007 -DF_CPU=16000000UL -DBOOTLOADER_ADR=0x7000 -DMODULE_VERSION="0.2.1" -DADDR_PC_DEF=127 -DADDR_TX_LCD_DEF=102 -DADDR_TX_MAIN_DEF=101 -DADDR_RX_MAIN_DEF=1 -DADDR_BROADCAST_DEF=0 -DMY_DEF_ADDR=1 -DADDR_DEBUG_RS232_DEF=99 -DMAX_FUNC_CNT=32 -DTARGET_AVR -std=gnu99 -ffunction-sections

Linker

avr-gcc -mmcu=atmega32 -I.  -MD -MP -MF .dep/bootloader.elf.d -D_TYPE_1007_="1007" -DMODULE_TYPE="1007" -DMODULE_ID=0x1007 -DF_CPU=16000000UL -DBOOTLOADER_ADR=0x7000 -DMODULE_VERSION=\"0.2.1\" -DADDR_PC_DEF=127 -DADDR_TX_LCD_DEF=102 -DADDR_TX_MAIN_DEF=101  -DADDR_RX_MAIN_DEF=1 -DADDR_BROADCAST_DEF=0 -DMY_DEF_ADDR=1 -DADDR_DEBUG_RS232_DEF=99 -DMAX_FUNC_CNT=32 -DTARGET_AVR -std=gnu99 -ffunction-sections obj/bootloader.o obj/addr_list.o --output bootloader.elf -Wl,-Map=bootloader.map,--cref -Ttext=0x7000

Wenn ich etwas übersehen habe, bitte nochmal Fragen.

Danke
Jürgen

[Frank M. (ukw) (Moderator)]

Jürgen S. schrieb:
> Gibt es überhaupt eine Chance das auf unter 2000Byte zu bekommen?

Natürlich.

Aber:

../bootloader.cpp:16:40: fatal error: ../global_files/avr_helper.h: No 
such file or directory

[Jürgen S. (jsachs)]

Gut, da fehlen noch 3 Files, die aber nur "Konstanten" und 
Funktionsdefinitionen beinhalten.

Die liegen in einem anderen Ordner, da die aus allen Projekten 
eingebunden werden.

Wenn doch noch was fehlt, bitte kurz Info.

Gruss
Juergen

[Jürgen S. (jsachs)]

Wichtig, nur mit den Compile Zeilen von mir wird das gehen, da ich hier 
"Defines" mit rein gebe.

Siehe "addr_list.cpp".

Gruss
Juergen

[Steffen R. (steffen_rose)]

-ffunction-sections

vergrößert den Code (weil der Optimierer manche funktionsübergreifende 
Dinge Optimierungen nicht machen kann) und benötigt man nur, wenn man 
überflüssige Funktionen durch den Linker löschen lassen möchte.

Ich sehe keine Optimierer-Optionen -O?

[Jürgen S. (jsachs)]

Steffen R. schrieb:
> -ffunction-sections
>
> vergrößert den Code (weil der Optimierer manche funktionsübergreifende
> Dinge Optimierungen nicht machen kann) und benötigt man nur, wenn man
> überflüssige Funktionen durch den Linker löschen lassen möchte.
>
> Ich sehe keine Optimierer-Optionen -O?

Ok, das mit dem fehlenden Optimier Optionen ist ein grobes Faul.
Im Makefile wird zwar eine Konstante gesetzt, aber die nirgends 
umgesetzt :-(
Eingebaut und wir sind ein großes Stück weiter. von 3754 Bytes auf 2254. 
Das ist doch mal eine Ansage :-)

Das -ffunction-section ist auch (wieder) entfernt. macht hier in der Tat 
nicht viel Sinn. und hat fast 80 Byte gebracht.

avr-nm -n bootloader.elf > bootloader.sym
avr-size bootloader.elf 
   text     data      bss      dec      hex  filename
   2254       72      330     2656      a60  bootloader.elf
avr-size --mcu=atmega32 -C bootloader.elf
AVR Memory Usage
----------------
Device: atmega32

Program:    2324 bytes (7.1% Full)
(.text + .data + .bootloader)

Data:        400 bytes (19.5% Full)
(.data + .bss + .noinit)

Danke für die Hinweise.
Jürgen

[Jürgen S. (jsachs)]

Damit hat sich fast shcon mein Platz Problem erledigt.
Bisher war mein Code 28700 Byte groß, nach einfügen der fehlenden 
Optimierung 15002. Das hätte ich nicht erwartet.

Die Frage ist, ob noch alles geht :-)

Irgendwann muss ich mein UrMakefile mal die Optimierung entfernt haben.
Jetzt wieder drin.

Aber eventuell bekommt man den Bootloader ja noch unter 2000Bytes.

Aber wie bekannt ist, kosten die ersten 80% nur 20% der Zeit..

Gruss
Juergen

[Frank M. (ukw) (Moderator)]

Jürgen S. schrieb:
> Ok, das mit dem fehlenden Optimier Optionen ist ein grobes Faul.

Ich hoffe mal, Du benutzt -Os. -O wäre nämlich zuwenig.

Warum gibst Du Deinen Sourcen eigentlich die Endung .cpp, wenn Du darin 
nur reines C schreibst?

[Steffen R. (steffen_rose)]

Bei -Os bin ich mir etwas unsicher. Hier sollte man mal verschiedene 
durchtesten. -Os versucht ein Optimum zwischen Laufzeit und Codegröße zu 
schaffen, mit Präferenz auf Codegröße. Hier scheint aber die Codegröße 
viel wichtiger zu sein und die Laufzeit eher keine Rolle zu spielen.

An dieser Stelle fehlt mir aber die Erfahrung bei den kleinen Atmels.

[Frank M. (ukw) (Moderator)]

Steffen R. schrieb:
> Hier scheint aber die Codegröße
> viel wichtiger zu sein und die Laufzeit eher keine Rolle zu spielen.

Eben. Und daher ist -Os genau dafür geschaffen.

Dass oft (aber natürlich nicht immer) durch geringe Codegröße auch 
effektiver Code entsteht, ist hier eher als Nebenprodukt zu betrachten.

[Jsachs (Gast)]

Ich benutze -Os.

Alle anderen codes haben zum teil CPP classes.

Damit ich mein makefile nicht doppelt pflegen muss ist alles CPP.

Jürgen

[Peter D. (peda)]

Ich benutze auch:
-fno-inline-small-functions

Der AVR-GCC ist etwas zu übereifrig, kleine häufig aufgerufene 
Funktionen zu inlinen.

[Jürgen S. (jsachs)]

Peter D. schrieb:
> Ich benutze auch:
> -fno-inline-small-functions
>
> Der AVR-GCC ist etwas zu übereifrig, kleine häufig aufgerufene
> Funktionen zu inlinen.

Hab ich eingefügt, hatte keine Auswirkung.

War ein Versuch Wert ...

Danke
Juergen