ATTiny13 - avr-gcc Hello World utilizza oltre 100 byte?

Sto cercando di scrivere un programma per ATTiny13. Il mio problema è che ha vincoli di dimensioni enormi. Bene, quando ho realizzato il mio primo programma Hello World, ci sono voluti 100 byte di spazio del programma solo per accendere e spegnere la luce! Ci sono opzioni che posso dare ad avr-gcc per ridurre questa dimensione? Inoltre, cosa c'è nel crt0? Non sono troppo appassionato di assemblaggio AVR, quindi non lo capisco molto ..

Non voglio passare all'assemblaggio per questo progetto.

crt0 è la routine di avvio per l'UC. Le routine eseguono la configurazione dei registri e anche l'inizializzazione dei dati.

I 100 byte includono la tabella vettoriale di interrupt? Non sono sicuro di ATtiny13 ma ATtiny25 / 45/85 ha 15 vettori di interrupt. Ciò richiederebbe 30 byte.

gcc ha un'opzione per il collegamento nel tuo crt0. È possibile prendere il file crt0.S di AVR e modificarlo. Non è molto lungo, quindi non dovrebbe essere difficile da fare.

Puoi usare avr-objdump -d .elf per vedere cosa viene generato:

Analizziamolo un po ':

[jpc@jpc ~] avr-objdump -d avr.elf | sed -e 's/^/    /' | pbcopy

avr.elf:     file format elf32-avr

Disassembly of section .text:

00000000 <__vectors>:
   0:   09 c0           rjmp    .+18        ; 0x14 <__ctors_end>
   2:   0e c0           rjmp    .+28        ; 0x20 <__bad_interrupt>
   4:   0d c0           rjmp    .+26        ; 0x20 <__bad_interrupt>
   6:   0c c0           rjmp    .+24        ; 0x20 <__bad_interrupt>
   8:   0b c0           rjmp    .+22        ; 0x20 <__bad_interrupt>
   a:   0a c0           rjmp    .+20        ; 0x20 <__bad_interrupt>
   c:   09 c0           rjmp    .+18        ; 0x20 <__bad_interrupt>
   e:   08 c0           rjmp    .+16        ; 0x20 <__bad_interrupt>
  10:   07 c0           rjmp    .+14        ; 0x20 <__bad_interrupt>
  12:   06 c0           rjmp    .+12        ; 0x20 <__bad_interrupt>

Tabella vettoriale di interrupt di 20 byte (almeno alcune voci potrebbero essere omesse se si insistesse e si fosse promesso di non abilitare mai gli interrupt corrispondenti).

00000014 <__ctors_end>:
  14:   11 24           eor r1, r1
  16:   1f be           out 0x3f, r1    ; 63
  18:   cf e9           ldi r28, 0x9F   ; 159
  1a:   cd bf           out 0x3d, r28   ; 61
  1c:   02 d0           rcall   .+4         ; 0x22 <main>
  1e:   05 c0           rjmp    .+10        ; 0x2a <_exit>

Cancella SREG (non sono sicuro che sia davvero necessario), scrive 0x9f (RAMEND) su SPL (il puntatore dello stack) e passa alla schermata principale. L'ultimo rjmp è un po 'ridondante. (potresti promettere di non tornare mai dalla rete principale)

00000020 <__bad_interrupt>:
  20:   ef cf           rjmp    .-34        ; 0x0 <__vectors>

Procedura di interruzione predefinita per quegli interrupt che non ne hanno uno sovrascritto in C. (stesse regole di __vettori)

00000022 <main>:
  22:   bb 9a           sbi 0x17, 3 ; 23
  24:   c3 9a           sbi 0x18, 3 ; 24
  26:   c3 98           cbi 0x18, 3 ; 24
  28:   fd cf           rjmp    .-6         ; 0x24 <main+0x2>

Il tuo proc principale. Stretto.

0000002a <_exit>:
  2a:   f8 94           cli

0000002c <__stop_program>:
  2c:   ff cf           rjmp    .-2         ; 0x2c <__stop_program>

Questi due non sono molto utili. _exit è probabilmente richiesto dallo standard C ed __stop_program è necessario per farlo funzionare come dovrebbe.

Qual è la tua eventuale domanda? Un ATtiny13 ha 1kB di flash e puoi fare molto con quello in C. crt0 è il runtime C di avr-libc. Contiene cose come la gestione dello stack in modo da poter usare le funzioni con argomenti e valori di ritorno.

100 byte per l'installazione C incorporata non sono troppo male e hanno dimensioni costanti. Raddoppiare le linee della logica del programma non lo renderà necessariamente di 200 byte. A quale livello di ottimizzazione stai compilando? Dovresti essere in "-Os". E come lo stai compilando? I Makefile nei progetti demo disponibili dal sito avr-libc sono abbastanza buoni e completi.

Il semplice programma di attivazione / disattivazione LED di seguito prende 62 byte su un ATtiny13 con "-Os" su avr-gcc 4.3.3. da CrossPack-AVR:

#include <avr / io.h>
#include <avr / delay.h>

int main (vuoto)
{
    DDRB | = _BV (PB3);
    while (1) { 
        PORTB | = _BV (PB3);
        _delay_ms (200);
        PORTB & = ~ _BV (PB3);
        _delay_ms (200);
    }
}

La rimozione delle chiamate _delay_ms () lo rende 46 byte.

Un esempio più ampio su ATtiny13 sono i miei prototipi di Smart LED . Questo codice contiene un software PWM a 3 canali, una conversione di colore da HSV a RGB, una macchina a stati e legge due pulsanti. Non è scritto particolarmente bene e arriva a 864 byte. Sotto avr-gcc 3.x era ancora più piccolo. (per qualche ragione avr-gcc 4 ha fatto crescere di quasi tutti i programmi quasi pochi byte)

Se sei a corto di spazio, prova il banco di lavoro integrato di IAR: la loro versione gratuita di "kickstart" ha un limite di dimensioni del codice parola 4K, quindi molto per ATTiny e probabilmente un'ottimizzazione migliore di gcc

Dispositivi del genere sono spesso programmati in assemblatore, con conseguente eseguibili più piccoli. Vale la pena fare lo sforzo e imparare a usarlo.