'''avr-gcc''' ist ein freier C-[[Compiler]], mit dem C-Programme zu ausführbaren Programmen übersetzen werden können, die auf [[Microcontroller]]n der [[AVR]]-Familie lauffähig sind.

An Sprachen versteht avr-gcc sowohl C als auch [[#C%2b%2b|C++]].

Neben Standard-C bzw. ANSI-C versteht avr-gcc auch GNU-C, das etwas mehr Möglichkeiten und kleinere Spracherweiterungen bietet.

avr-gcc kann auch dazu verwendet werden, um C/C++ Programme nach Assembler zu übersetzen oder um Bibliotheken zu erstellen, die später in unterschiedlichen Projekten verwendet werden können.

Wie bei allen aus der UNIX-Welt kommenden Programmen ist das Kommando-Interface von avr-gcc die Shell bzw. die Kommandozeile, über die Optionen, Parameter, Einstellungen und die Namen der zu übersetzenden Dateien angegeben werden.  

=How to Read=

Dieser Artikel bespricht avr-gcc Version 3.x. Er ist kein C-Tutorial und kein AVR-Handbuch – das würde den Umfang des Artikels bei weitem sprengen.

Dafür enthält dieser Artikel zusammen mit dem AVR-Handbuch das Rüstzeug,

Neben diesem Artikel gibt es den Unterartikel [[avr-gcc/Interna|Interna von avr-gcc]] wo Dinge wie die Registerverwendung, Attribute, Builtins und Sections von avr-gcc dargestellt werden. Zudem findet sich dort ein Überblick über die Arbeitsweise von gcc mit den Schritten

Ein weiterer Unterartikel widmet sich dem Thema [[Inline-Assembler in avr-gcc]].

In den [[:Kategorie:Quellcode C|C-Codebeispielen]]

befindet sich das ausführlichere Beispiel "[[Hallo Welt für AVR (LED blinken)]]",

wie ein kleines Projekt mit avr-gcc compiliert werden kann.

Es gibt ein [[C-Tutorial]], das jedoch noch unvollständig und teilweise feherhaft ist (Stand 02/2006). Darüber hinaus gibt es ein [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial C-Tutorial bei www.mikrocontroller.net].

=Benutzer-Schnittstelle=

Die Benutzer-Schnittstelle von avr-gcc ist – wie für alle Programme, die aus der UNIX-Welt kommen – die Kommandozeile einer Shell, Console bzw. Eingabeaufforderung.  

Im einfachsten Fall sieht ein Aufruf von avr-gcc also so aus:

Dabei das '<tt>></tt>' nicht mittippen, und ein ENTER am Ende der Zeile drücken.

Was bedeutet: das Programm avr-gcc wurde vom Betriebssystem gefunden und konnte/durfte gestartet werden. Dann gibt avr-gcc eine Fehlermeldung aus und beendet die Ausführung, weil er keine Eingabedatei(en) bekommen hat &#150; was ja auch stimmt. Soweit ist also alles in Butter.

Um eine C-Datei <tt>foo.c</tt> mir avr-gcc optimiert zu einem lauffähigen elf-Programm <tt>foo.elf</tt> für einen [[ATmega32]] zu compileren, würde man angeben

> avr-gcc -Os -mmcu=atmega32 foo.c -o foo.elf

Hat man seine Quellen auf zwei oder mehre Dateien verteilt, geht es analog:

> avr-gcc -Os -mmcu=atmega32 foo.c foo2.c -o foo.elf

Will man nur eine Objekt-Datei erstellen (nur compilieren, nicht linken), dann geht das wie folgt. Das kann günstig sein bei grösseren Projekten, wenn man das Projekt neu erzeugen will, aber nur in einer Quelldatei was geändert hat. Oder wenn das Objekt in einer Bibliothek landen soll.

  > avr-gcc -Os -c -mmcu=atmega32 foo.c -o foo.o

Die ausführbare Gesamtdatei <tt>foo_all.elf</tt> erhält man dann, indem alle Objekte zusammenlinkt:

  > avr-gcc -mmcu=atmega32 foo.o foo2.o foo3.o -o foo_all.elf

Um die ausführbare Datei in das oft verwendete Intex-HEX-Format umzuwandeln (einmal fürs Programm, einmal für ein Abbild des [[EEPROM]]s) gibt man an:

  > avr-objcopy -O ihex -j .text -j .data                        foo_all.elf foo_all.hex

  > avr-objcopy -O ihex -j .eeprom --change-section-lma .eeprom=1 foo_all.elf foo_all_eeprom.hex

----

:→ ''[http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html GCC Manual: AVR Options]

> avr-gcc --target-help

bzw. ab Version 4.7 mit

> avr-gcc --help=target

Siehe auch "AVR Options" in der GCC [[#Dokumentation|Dokumentation]].

=Kommandozeilen-Optionen=

Aus der Masse an GCC-Optionen kann hier nur ein kleiner Auszug der wichtigsten und am häufigsten verwendeten Optionen vorgestellt werden. Eine Auflistung aller GCC-Optionen mit Kurzbeschreibung umfasst knapp 1000 Zeilen &#150; ohne undokumentierte Optionen, versteht sich.

==Allgemeine Optionen für GCC==

;-mmcu=xxx: Festlegen des Targets (Zielsystem/Controller), für das Code generiert werden soll. Je nach Target muss avr-gcc unterschiedliche Instruktionen verwenden und andere Startup-Dateien (<tt>crtxxx.o</tt>) einbinden. avr-gcc setzt spezielle Defines, um auch in der Quelle zwischen den Targets unterscheiden zu können, falls das notwendig sein sollte:

:{| border="0" cellpadding="0" cellspacing="0"

#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__)

: Built-in Makros wie <tt>__AVR_ATmega8__</tt> und <tt>__AVR_ARCH__</tt> sind ab Version 4.7 im Kapitel "AVR Options" in der GCC [[#Dokumentation|Dokumentation]] erklärt, siehe z.B. [http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html "AVR Built-in Macros"].

; -mint8: Datentyp <tt>int</tt> ist nur 8 Bit breit anstatt 16 Bit. Datentypen mit 64 Bit sind nicht verfügbar. 8-Bit <tt>int</tt> ist nicht C-Standard konform und wird nicht von der AVR Libc unterstützt (ausser in <tt>stdint.h</tt>).

; -mno-interrupts: Ändert den Stackpointer ohne Interrupts zu deaktivieren

; -mcall-prologues: Funktions-Prolog und -Epilog werden als Unterroutinen umgesetzt, um die Codegröße zu verkleinern

:''"C++ is a complex language and an evolving one, and its standard definition (the ISO C++ standard) was only recently completed. As a result, your C++ compiler may occasionally surprise you, even when its behavior is correct."''

:''"When programming C++ in space- and runtime-sensitive environments like microcontrollers, extra care should be taken to avoid unwanted side effects of the C++ calling conventions like implied copy constructors that could be called upon function invocation etc. These things could easily add up into a considerable amount of time and program memory wasted. Thus, casual inspection of the generated assembler code (using the <tt>-S</tt> compiler option) seems to be warranted."''

Weiterhin unterliegt der Einsatz von C++ je nach Compiler/Lib-Version bestimmten Einschränkungen:

*Einer kompletten C++ Implementierung fehlt die Unterstützung durch die <tt>libstdc++</tt>, dadurch fehlen Standardfunktionen, -Klassen und -Templates

* Die Operatoren <tt>new</tt> und <tt>delete</tt> sind nicht implementiert, ihre Verwendung führt zu unauflösbaren externen Referenzen (Linker-Fehler)

 

Interrupt-Service-Routinen (ISRs) sind C-Funktionen und werden definiert wie gehabt. Siehe auch [[#Interrupts|Interrupts]].

  #include <avr/io.h>

  #include <avr/interrupt.h>

   

  #if defined (__cplusplus)

  extern "C" {

  #endif {{comment|__cplusplus}}

   

  SIGNAL (SIG_NAME)

  {

    {{comment|machwas}}

  }

   

  INTERRUPT (SIG_NAME)

  {

    {{comment|mach was}}

  }

   

  #if defined (__cplusplus)

  }

  #endif {{comment|__cplusplus}}

<tt>__cplusplus</tt> ist ein Standard [[avr-gcc/Interna#Builtin Defines|GCC-Builtin-Define]].

 

Globale Konstruktoren werden in [[avr-gcc/Interna#Sections|Section]] <tt>.init6</tt> ausgeführt, die Destruktoren in <tt>.fini6</tt>.

Dieser Abschnitt enthält Code-Schnippsel für avr-gcc. Es werden Besonderheiten besprochen, die für avr-gcc zu beachten sind.  

Dieser Abschnitt ist ''kein'' [[C-Tutorial|Tutorial zur C-Programmierung]] und ''keine'' Einführung in die Programmiersprache C im allgemeinen. Dafür sei auf einschlägige Tutorials/Bücher verwiesen.

Für den Zugriff auf die SFRs gibt es Defines über den Include

#include <avr/io.h>

Abhängig vom eingestellten Controller werden dann Defines eingebunden, über die auf SFRs wie auf normale Variablen zugegriffen werden kann. Die Namen der Defines sind i.d.R. die gleichen wie im AVR-Manual, also z.b. <tt>SREG</tt> für das Prozessorstatus-Register SREG:

#include <avr/io.h>

...

   {{ccomment|SREG lesen}}

   {{ccomment|SREG schreiben}}

Das bedeutet in etwa: "Lies ein flüchtiges (<tt>volatile</tt>) Byte (<tt>unsigned char</tt>) von Adresse <tt>0x5f</tt>". Der Speicherinhalt von SFRs ist flüchtig, denn er kann sich ändern, ohne daß avr-gcc dies mitbekommt. Daher muss bei jedem C-Zugriff auf ein SFR dieses wirklich gelesen/geschrieben werden, was der Qualifier <tt>volatile</tt> sicherstellt. Ansonst geht der Compiler u.U. davon aus, daß der Inhalt bekannt ist und verwendet einen alten, in einem GPR befindlichen Wert.

:<tt> &lt;GCC_HOME&gt;/avr/include/avr/io****.h</tt>

Dieser Zugriff geht auch für 16-Bit Register wie <tt>TCNT1</tt> oder <tt>ADC</tt>, für die eine bestimmte Reihenfolge für den Zugriff auf Low- und High-Teil eingehalten werden muss: avr-gcc generiert die Zugriffe in der richtigen Reihenfolge.

 

Zu beachten ist, daß dieser Zugriff nicht atomar erfolgt. Das Lesen/Schreiben mehrbytiger Werte muss vom Compiler in mehrere Byte-Zugriffe zerlegt werden. Zwischen diesen Zugriffen kann ein [[Interrupt]] auftreten, wenn Interrupts aktiviert sind. Je nach Programm und welche Aufgaben eine [[ISR]] erledigt, kann dies zu Fehlfunktion führen. In dem Fall müssen diese Code-Stücke atomar gemacht werden, damit sie nicht durch einen [[IRQ]] unterbrochen werden können!

<tt>&amp;</tt> (and),

<tt>|</tt> (or),

<tt>^</tt> (xor) und

<tt>~</tt> (not)

#define INT1   7

#define INT0   6

#define IVSEL   1

#define IVCE   0

Masken ergeben sich durch Schieben von <tt>1</tt> an die richtige Position:

87 b3           in     r24, 0x17

83 60           ori     r24, 0x03

87 bb           out     0x17, r24

Etwas anders sieht der Code aus, wenn die Bits einzeln gesetzt werden und das Register im bitadressierbaren Bereich liegt (SRAM <tt>0x20</tt> bis <tt>0x3f</tt> resp. I/O <tt>0x0</tt> bis <tt>0x1f</tt>):

b8 9a           sbi     0x17, 0

b9 9a           sbi     0x17, 1

88 b3           in     r24, 0x18

91 e0           ldi     r25, 0x01

89 27           eor     r24, r25

88 bb           out     0x18, r24

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

==SRAM, Flash, EEPROM: Datenablage am Beispiel Strings==

Die Programmiersprache C kennt selber keine Strings; das einzige, was C bekannt ist, ist der Datentyp <tt>char</tt>, der ein einzelnes Zeichen repräsentiert.  

Ein String im Sinne von C ist ein Array von Charactern bzw. ein Zeiger auf den Anfang des Arrays. Die einzelnen Zeichen folgen im Speicher direkt aufeinander und werden in aufsteigenden Adressen gespeichert. Am String-Ende folgt als Abschluss der Character <tt>'\0'</tt>, um das Ende zu kennzeichnen. Dies ist besonders bei der Berechnung des Speicherplatzes für Strings zu berücksichtigen, denn für die 0 muss auch Platz reserviert werden.

  /* Bestimmt die Laenge des Strings ohne die abschliessende '\0' zu zaehlen */

Die Stringlänge kann auch mit der Standard-Funktion <tt>strlen</tt> bestimmt werden, deren Prototyp sich in <tt>string.h</tt> befindet:

dann werden die Strings im SRAM abgelegt. Im Startup-Code werden die Strings vom Flash ins SRAM kopiert und belegen daher sowohl Platz im SRAM als auch im Flash. Wird ein String nicht verändert, braucht er nicht ins SRAM kopiert zu werden. Das spart Platz im knapp bemessenen SRAM. Allerdings muss anders auf den String zugegriffen werden, denn wegen der Harvard-Architektur des AVR-Kerns kann avr-gcc anhand der Adresse nicht unterscheiden, ob diese ins SRAM, ins Flash oder ins EEPROM zeigt.

  const char str3[] PROGMEM = "Hallo Welt!";

  size_t strlen_P (const char *str)

     size_t len = 0;

  void foo (void)

     size_t len;

     len = strlen_P (PSTR ("String im Flash"));

  const char str4[] EEMEM = "Hallo Welt!";

  size_t strlen_EE (const char *str)

     size_t len = 0;

==Reset auslösen==

Falls ein Reset per Software ausgelöst werden soll, dann geht das am besten über den [[Watchdog]].

Einfach nur an den Reset-Punkt an Adresse&nbsp;0 zu springen

initialisiert zwar den Controller von neuem, aber es macht keinen wirkliches RESET mit Zurücksetzen der Hardware und allen I/O-Registern.  

Durch den Watchdog kann man ein 'richtiges' RESET-Signal erzeugen lassen, so daß die AVR-Hardware genau so initialisiert ist, wie nach einem externen RESET. So kann man z.B. via [[UART]] ein RESET-Kommando schicken. Allerdings lässt sich der Watchdog nur minimal auf 15ms einstellen:

#include <avr/wdt.h>

#include <avr/interrupt.h>

Welches Ereignis einen RESET ausgelöst hat, kann man im Register '''MCUCSR''' (''MCU Control and Status Register'') erfahren. Es gibt 4 mögliche RESET-Quellen:

  {{ccomment| status informiert z.B. darüber, ob wir selber den Watchdog ausgelöst haben }}

uint8_t status __attribute__ ((__section__ (".noinit")));

int main (void)

    uint8_t mcucsr = MCUCSR;

    MCUCSR = 0;

    if (mcuscr & (1 << WDRF))

    if (mcuscr & (1 << PORF))

        status = 0;

  extern void reset (void) __attribute__((noreturn));

<tt>reset</tt> wird bein Linken mittels <tt>-Wl,--defsym=reset=0</tt> auf&nbsp;0&nbsp;gesetzt.

Weitere Möglichkeit ist, im erzeugten Assembler&nbsp;<tt>0</tt> als Funktionsnamen zu verwenden:

<GCC_HOME>/avr/include                          Standard              (stdio.h, ...)

<GCC_HOME>/lib/gcc/avr/<GCC_VERSION>/include    Standard, compilerabh. (limits.h, ...)

Gibt man z.B. an

dann wird automatisch in diesem Verzeichnis nach <tt>stdio.h</tt> gesucht.

In den Verzeichnissen stehen Standard-Includes, die benötigt werden, wenn man libc-Funktionen

oder mathematische Funktionen etc. verwendet.

ctype.h                  Zeichen-Umwandlungs-Makros und ctype Makros

errno.h                  Symbolische Namen für Fehlercodes

stdint, inttypes.h        C99 definiert [u]intN_t wenn man genau N [un]signed

  math.h                    Mathematische Funktionen: sin, cos, log, gamma, bessel, ...

  setjmp.h                  libc unterstützt setjmp() und longjmp(), um direkt in eine

                          andere (nicht-lokale) Funktion zu springen.

  stdio.h                  Standard I/O-Funktionen (printf, fscanf, ...)

stdlib.h                  Deklariert grundlegende ISO C Makros und Funktionen

                          sowie einige AVR-spezifische Erweiterungen

string.h                  Stringoperationen auf NULL-terminierten Strings. (strlen, ...)

stdarg.h                  Funktionen mit variabler Argumenanzahl

limits.h                  Min- und Max-Werte von Skalaren (UCHAR_MAX, LONG_MIN, ...)

==AVR-spezifisch==

Die AVR-spezifischen Includes finden sich wie gesagt im Unterverzeichnis <tt>avr</tt>.

#include <avr/io.h>

Dadurch werden genau die I/O-Header eingebunden, die zum AVR-Modell passen, also  z.B. <tt>avr/iom8.h</tt> für [[ATmega8]] etc.  Verantwortlich für die Auswahl des richtigen Sub-Headers ist der Schalter '<tt>-mmcu=xxx</tt>'.

Ihre Namen sind immer <tt>avr/io*.h</tt>.

* für ATtiny: <tt>avr/iotn*.h</tt>

avr/interrupt.h      sei(), cli(), ISR(), ...

avr/io.h              RAMEND, ***_vect, SFRs: PORTB, DDRB, PINB, SREG, ...,

util/crc16.h          Prüfsumme CRC16

Eigene Header, die nur innerhalb eigener Projekte gebraucht werden, includet man mit

#include "..."

Auch hier darf man Unterverzeichnisse angeben oder ins übergeordnete Verzeichnis:

Mit der Option <tt>-I<path></tt> kann ein Pfad zu den bekannten Include-Pfaden hinzugefügt werden; im obigen Beispiel etwa <tt>-I../..</tt> und im Programm dann:

#include "mein-zeug.h"

= Optimierungen, Tipps & Tricks =

; [[GCC]]: GNU Compiler Collection

; [[ISR]]: [[Interrupt|'''I'''nterrupt]] '''S'''ervice '''R'''outine

; [[IRQ]]: '''I'''nterrupt '''R'''e'''q'''uest

; Prolog/Epilog: Code am Anfang/Ende jeder Funktionen/ISR, der dazu dient, verwendete Register zu sichern, den Stack-Frame für lokale [[Variable|Variablen]] anzulegen (falls benötigt), Stackpointer zu setzen, zurück zu springen (<tt>ret</tt>, <tt>reti</tt>), etc.

* [[C-Tutorial]]

* [[Hallo Welt für AVR (LED blinken)]] - ein erstes Beispiel für avr-gcc

 

 

* [[Speicherverbrauch bestimmen mit avr-gcc]]

* [[Compiler]]

* [[Sourcevergleich]]

* [[Codevergleich AVR-Compiler]]