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

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

Der Artikel ist ein Handbuch zu avr-gcc. Er bespricht zum Beispiel, wie man avr-gcc anwendet und Besonderheiten von avr-gcc-C,

die nicht zum Sprachumfang von C gehören.

Es gibt es ein allgemeines [[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].

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

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

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

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

* ein Compiler ist ein Compiler ist ein Compiler (und keine grafische Bedienschnittstelle)

=Allgemeine Charakteristika von avr-gcc=

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

;Linken und Lokatieren: Der Linker (<tt>avr-ld</tt>) bindet die angegebenen Objekte (*.o) zusammen und löst externe Referenzen auf. Der Linker entscheidet anhand der Beschreibung im Linker-Script, in welchen Speicheradressen und [[#Sections|Sections]] die Daten landen: er ''lokatiert'' (von location, locate (en)). Module aus Bibliotheken (*.a) werden hinzugebunden (z.B. <tt>printf</tt>) und die elf32-avr Ausgabedatei (üblicherweise *.elf) erzeugt.

;Umwandeln ins gewünschte Objekt-Format: Ohne Angabe spezieller [[#Kommandozeilen-Optionen|Optionen]] erzeugen Linker und Assembler ihre Ausgabe im Objektformat elf32-avr. Wird ein anderes Objektformat wie Intel-HEX (*.hex), binary (*.bin) oder srec (*.srec) benötigt, kann <tt>avr-objcopy</tt> dazu verwendet werden, um diese zu erstellen. Der Inhalt einzelner Sections kann gezielt umkopiert oder ausgeblendet werden, so daß Dateien erstellt werden können, die nur den Inhalt des Flashs (Section <tt>.text</tt>) oder des [[EEPROM]]s (Section <tt>.eeprom</tt>) repräsentieren. Durch das Umwandeln in ein anderes Objektformat gehen üblicherweise Informationen wie Debug-Informationen verloren.

:Es ist auch möglich, den Linker mit der Optione <tt>--oformat=...</tt> zu starten, damit er direkt das gewünschte Ausgabeformat erzeugt. Diese Option lässt man von avr-gcc an den Linker weiterreichen, etwa wenn man direkt eine Intel-HEX-Datei erstellen will und keine elf-Datei braucht, wie sie z.b. beim Debuggen benötigt wird:

Dabei ist dafür zu sorgen, daß keine Debug-Informationen etc. in der hex-Datei landen. Generell ist es jedoch vorzuziehen, die hex-Datei aus einer elf-Datei zu erzeugen.

; <tt>--target-help</tt>: Anzeige der wichtigsten maschinenspezifischen Optionen

; <tt>-O0</tt>: keine Optimierung

; <tt>-Os</tt>: optimiert für Code-Größe

; <tt>-S</tt>: (pre)compilert nur und erzeugt Assembler-Ausgabe (*.s)

; <tt>-E</tt>: nur Precompilat (<tt>*.i</tt>) erzeugen, kein Compilieren, kein Assemblieren, kein Linken

; <tt>-save-temps</tt>: Temporäre Dateien (<tt>*.i</tt>, <tt>*.s</tt>) werden nicht gelöscht. Teilweise fehlerhaft zusammen mit <tt>-c</tt>

:;<tt>-Wl,--section-start=<section>=<address></tt>: Linker legt die [[#Sections|Section]] <tt><section></tt> ab Adresse <tt><address></tt>, z.B: <tt>.eeprom=0x810001</tt>

; <tt>-pedantic</tt>: geht besonders pedantisch mit Code um

; <tt>-ansi</tt>: bricht mit einer Fehlermeldung ab, wenn kein ANSI-C verwendet wurde

; <tt>-ffreestanding</tt>: Das erzeugte Programm läuft nicht in einer Umgebung wie einer Shell. Der Prototyp von <tt>main</tt> ist

:<pre>void main (void);</pre>

;-mmcu=xxx: Festlegen des Targets (Zielsystem/Controller), für das Code generiert werden soll. Je nach Target muss avr-gcc unterschiedliche Instruktionen verwendet 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:  

Zwar gibt es für alle AVR-Derivate die <tt>avr/io.h</tt>, aber die AVR-Familien unterscheiden sich in ihrer Hardware; z.B. darin, wie I/O-Register heissen oder wie Hardware zu initialisieren ist. Diese Abhängigkeit kann man in unterschiedlichen Codestücken aufteilen und wie oben gezeigt bedingt übersetzen. Dadurch hat man Funktionalitäten wie <tt>uart_init</tt> auf unterschiedlichen Controllern und wahrt den Überblick, weil nicht für jede Controller-Familie eine extra Datei notwendig ist.

 

:{| {{Blauetabelle}}

|- bgcolor="#ccccff"

|[[Atmel Controller Mega8|atmega8]] ||<tt>__AVR_ATmega8__</tt>

|atmega8515 ||<tt>__AVR_ATmega8515__</tt>

|+ '''AVR enhanced, &gt; 8 kByte'''

|- bgcolor="#ccccff"

|[[Atmel Controller Mega16 und Mega32|atmega16]] ||<tt>__AVR_ATmega16__</tt>

|[[Atmel Controller Mega16 und Mega32|atmega32]] ||<tt>__AVR_ATmega32__</tt>

|atmega323 ||<tt>__AVR_ATmega323__</tt>

|[[ATMega64|atmega64]] ||<tt>__AVR_ATmega64__</tt>

|[[Atmel Controller Mega128|atmega128]] ||<tt>__AVR_ATmega128__</tt>

|at94k ||<tt>__AVR_AT94K__</tt>

 

----<!----------------------------------------------------------->

 

 

|+ '''AVR, nur Assembler'''

|- bgcolor="#ccccff"

 

; -mint8: Datentyp <tt>int</tt> ist nur 8 Bit breit, anstatt 16 Bit. Datentypen mit 32 Bit wie <tt>long</tt> sind nicht verfügbar

=Builtins=

 

 

 

;<tt>__VERSION__</tt>: "X.Y.Z" wenn GCC-Version X.Y.Z

;<tt>__cplusplus</tt>: Es wird C++ übersetzt (Quell-Endung <tt>*.cpp</tt>, <tt>*.c++</tt> oder Option <tt>-x c++</tt>).

 

 

 

 

 

 

|<tt>.data</tt> ||SRAM  ||Daten ||wird vom Startup-Code initialisiert, u.a. aus <tt>.progmem</tt>

|<tt>.init''n''</tt> ||Flash ||Code ||wird vor <tt>main</tt> ausgeführt, ''n'' = 0...9

 

 

 

GCC geht jedoch davon aus, daß der Adressraum linear organisiert ist (von-Neumann-Struktur). In GCC gibt es keine Möglichkeit, diese unterschiedlichen Adressbereiche zu kennzeichnen. Zwar gibt es [[#Attribute|Attribute]], um die Lokatierung &ndash; also die Daten/Codeablage &ndash; zu beeinflussen, aber beim Datenzugriff über eine Adresse wird immer in den SRAM gegriffen. Attribute sind leider nicht wirklich geeignet, die verschiedenen Pointer-Arten zu unterscheiden. Dazu wären Qualifier das Mittel der Wahl. Das Einführen neuer Qualifier würde eine Spracherweiterung von C bedeuten und tiefgreifende Änderung in GCC erfordern, die weit über die Backend-Beschreibung für AVR hinausgingen und in absehbarer Zeit nicht zu erwarten sind.

 

 

 

 

 

 

|+ '''Tabelle: Attribute von GCC''' (Auszug)

|Diese Funktion hängt nur von ihren Parametrn ab und hat keine Nebenwirkungen, ausser den Rückgabewert zu liefern. Dieses Wissen ermöglicht Optimierungen.

 

 

 

 

#define EEPROM __attribute__ ((section (".eeprom")))

 

 

 

 

 

 

Von der Verwendung ist der mittels <tt>__builtin_alloca</tt> und dynamischer Arrays erhaltene '''Speicher also wie eine lokale Variable, mitsamt den bekannten Regeln für den Gültigkeitsbereich'''.

 

 

 

 

 

Aus Effizienzgründen sollte der Einsatz von C++ sehr kritisch betrachtet werden:

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

  #include <avr/signal.h>

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

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

For den Zugriff auf die SFRs gibt es Defines über den Include

Abhängig vom eingestellten Controller werden denn 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>

 

...

   // SREG lesen

   // SREG schreiben

  // Liest den Inhalt von SREG an Adresse 0x5f

  unsigned char sreg = *((unsigned char volatile*) 0x5f);

Für einen Überblick über die eingebundenen Defines und kann ein Blick in den Controller-spezifischen Header hilfreich sein. Dieser befindet sich in

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

Dieser Zugriff geht auch für 16-Bit Register wie <tt>TCNT1</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.

Um zu kennzeichnen, daß es sich bei einer Funktion um eine Interrupt Sevice Routine (ISR) handelt, gibt es spezielle Attribute. Diese brauchen nicht explizit hingeschrieben zu werden, ebensowenig wie die genaue Nummer des Interrupt Requests (IRQ). Dafür gibt es Includes und die folganeden Makros.

Bitte beachte auch die Hinweise zu den [[#Inkompatibilität|Inkompatibilität]]en von avr-gcc!

#include <avr/io.h>

#include <avr/signal.h>

SIGNAL (SIG_OUTPUT_COMPARE1A)

{

  /* ISR-Code */

}

  /* ISR-Code */

Dadurch wird die Funktion mit dem richtigen Prolog/Epilog erzeugt, und es wird ein Eintrag in die Interrupt-Vektortabelle gemacht &#150; bei obigem Beispiel also zwei Einträge.

Die Schreibweise des Signal-Names muss genau die sein wie im Header, das schliesst auch Leerzeichen ein! Nicht alle GCC-Versionen bringen Fehler/Warnung, wenn die Schreibweise nicht stimmt.

;<tt>SIGNAL</tt>: Mit Ausführung einer ISR deaktiviert die AVR-Hardware die Interrupts, sodaß die ISR nicht durch andere Interrupt-Anforderungen unterbrochen wird. Beim Verlassen der ISR werden Interrupts wieder aktiviert. Tritt während der ISR ein IRQ auf, wird diese erst nach Beenden des ISR-Codes ausgeführt. Der Interrupt geht also nicht verloren. Zwischen zwei ISRs wird zusätzlich mindestens ein Befehl des normalen Programm-Codes abgearbeitet.

;<tt>INTERRUPT</tt>: Früh im ISR-Prolog werden mit <tt>sei</tt> die von der AVR-Hardware temporär deaktivierten Interrupts reaktiviert. Dadurch kann die ISR von einer IRQ unterbrochen werden. Das bietet die Möglichkeit, so etwas wie Interrupt-Priorisierung nachzubilden, was AVRs selbst nicht können. Weiterhin kann man schneller auf bestimmte Ereignisse reagieren. Tritt während der ISR ein anderer IRQ auf, der schnell bedient werden muss, kann sofort der dringende ISR-Code ausgeführt werden. Ansonsten (Verwendung von <tt>SIGNAL</tt>) würde der Code erst ausgeführt werden, nachdem die aktuelle ISR beendet ist.

 

 

#include <avr/io.h>

#include <avr/interrupt.h>

 

  ...

  // enable OutputCompareA Interrupt für Timer1

  TIMSK |= (1 << OCIE1A);

 

  // disable OutputCompareA Interrupt für Timer1

  TIMSK &= ~(1 << OCIE1A);

 

  // Interrupts aktivieren

  sei();

 

  // Interrupts abschalten

  cli();

#include <avr/signal.h>

SIGNAL (__vector_default)

sondern weiter zu <tt>__vector_default</tt>, welches durch <tt>SIGNAL</tt> oder

<tt>INTERRUPT</tt> den üblichen ISR-Prolog/Epilog bekommt.

dann definiert man eine nackte Funktion.

<pre>

#include <avr/io.h>

  /* Port B.6 = 0                                                        */

   c6 98       cbi  0x18, 6

   18 95       reti

void __attribute__ ((naked))  

  const prog_char str3[] = "Hallo Welt!";

  unsigned int strlen_P (const prog_char *str)

     unsigned int len = 0;

  void foo()

     unsigned int len;

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

  const char str4[] __attribute__ ((section(".eeprom"))) = "Hallo Welt!";

  unsigned int strlen_EE (const char *str)

     unsigned int len = 0;

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

#include <avr/wdt.h>

#include <avr/interrupt.h>

...   

  cli();                    // Interrupts global abschalten

  wdt_enable (WDTO_15MS);    // Watchdog aufziehen auf 15ms

  while (1);                // warten, bis er zubeisst...

#include <avr/io.h>

 

// status informiert z.B. darüber, ob wir selber den Watchdog ausgelöst haben

// oder nicht, oder andere Informationen

unsigned char status __attribute__ ((section (".noinit")));

 

void main (void)

{

  // Wert von MCUSCR merken, möglichst früh im Programm

  unsigned char mcucsr = MCUCSR;

 

  // MCUCSR zurücksetzen

  MCUCSR = 0;

 

  // Watchdog-Reset

  if (mcuscr & (1 << WDRF))

  {

      // status auswerten  

  }

 

  // Power-On Reset: status auf definierten Wert setzen

  if (mcuscr & (1 << PORF))

  {

      status = 0;

  }

 

  // status auswerten

}

 

 

 

 

Mitunter ist es notwendig, Code unmittelbar nach dem Reset auszuführen, noch bevor man in <tt>main()</tt> mit der eigentlichen Programmausführung beginnt. Das kann zB. zur Bedienung eines [[Watchdog]]-Timers erforderlich sein.

 

 

}

* Zuweisungen wie <tt>i=0;</tt> ergeben vor <tt>.init3</tt> inkorrekten Code, da vor Ende von <tt>.init2</tt> Register R1 noch nicht mit 0 besetzt ist, avr-gcc aber davon ausgeht, daß es eben diesen Wert enthält.

Ein Programmbeispiel für Code in einer init-Section ist in "[[Speicherverbrauch bestimmen mit avr-gcc#Dynamischer RAM-Verbrauch|Speicherverbrauch bestimmen mit avr-gcc]]".

  inttypes.h               Definiert [u]intN_t wenn man genau N [un]signed Bits

                           braucht, ISO C99.

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

  stdlib.h                  Deklariert grundlegende ISO C-Makros und -Funktionen  

Dadurch werden z.B. genau die I/O-Header eingebunden, die zum AVR-Modell passen, also

*<tt>avr/iom8.h</tt> für [[ATmega8]],

*<tt>avr/io2313.h</tt> für [[AT90S2313]], etc.  

 

Verantwortlich dafür ist der Schalter '<tt>-mmcu=xxx</tt>'.

Obwohl diese Header nicht explizit angegeben werden müssen,  

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

avr/io.h              --> inttypes.h, io*.h

avr/io*.h            SFRs, SIG_****, SPM_PAGESIZE, RAMEND, XRAMEND, E2END, FLASHEND

avr/parity.h          [*] Parität

avr/pgmspace.h        Zugriff aufs Flash: Byte lesen, PROGMEM, prog_char, prog_uint8_t, ...

avr/signal.h          [**] Makros SIGNAL() und INTERRUPT(), ...

avr/sleep.h          Power-Safe

=Optimierungen, Tipps & Tricks=

 

 

 

 

 

 

 

 

'''Anwendung:'''

 

Genauso macht man auch eine Sprungtabelle, um anhand von Kommando-Strings dazugehörige Funktionen ausführen zu lassen:

    char text[1+TEXT_LEN]; {{ccomment|Text, maximal TEXT_LEN Zeichen lang}}

const command_t commands[] PROGMEM =