'''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

* 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:

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

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

 

 

 

 

 

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

Zur bedingten Codeerzeugung und zur Erkennung, welcher Compiler sich an der Quelle zu schaffen macht, sind folgende Builtins hilfreich.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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/io.h>

#include <avr/signal.h>

 

#if defined (__cplusplus)

extern "C" {

#endif /* __cplusplus */ 

 

SIGNAL (SIG_NAME)

{

  /* machwas */

}

 

INTERRUPT (SIG_NAME)

{

  /* mach was */

}

 

#if defined (__cplusplus)

}

#endif /* __cplusplus */ 

<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>.

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

  // Liest den Inhalt von SREG an Adresse 0x5f

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

 

Die Bezeichner der SFRs sind die gleichen wie im Manual. Evtl verschafft ein Blick in den Header Klarheit. Dieser befinden 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.

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, was zu fehlerhaften Resultaten führen kann. Entsprechende Codestücke müssen daher atomar gehalten werden!

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 die Includes und die Makros:

<pre>

#include <avr/io.h>

#include <avr/signal.h>

SIGNAL (SIG_OUTPUT_COMPARE1A)

  /* ISR-Code */

INTERRUPT (SIG_OUTPUT_COMPARE1B)

{

  /* 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.

  SIGNAL (SIG_OUTPUT_COMPARE1A ) // !!! Macht NICHT das, was man will (Blank am Ende)!!!

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

 

Nachschlagen kann man den Namen in

#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")));

 

 

 

 

 

 

 

 

 

 

 

  /* !!! never call this function !!! */

  void __attribute__ ((naked, section (".init3")))

code_init3 (void)

     /* Code */

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

Dem Compiler bekannt ist der Pfad <tt><GCC_HOME>/avr/include</tt>.

In dem Verzeichnis stehen Standard-Includes die benötigt werden, wenn man libc-Funktionen  

oder mathematische Funktionen verwendet.  

  ctype.h                  character conversion macros and ctype macros

  errno.h                  provides symbolic names for various error codes

  inttypes.h               Use [u]intN_t if you need exactly N bits.

                           These typedefs are mandated by the C99 standard.

  math.h                    mathematical functions

  setjmp.h                  The C library provides the setjmp() and longjmp() functions

                           to jump directly to another (non-local) function.  

  stdio.h                  Standard IO facilities

  stdlib.h                  Declares some basic C macros and functions as defined by

                           the ISO standard, plus some AVR-specific extensions

  string.h                  perform string operations on NULL terminated strings

Dadurch werden z.B. genau der I/O-Header eingebunden, der zum AVR-Modell passt, 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

 

GCC erzeugt zwar recht guten Code, aber er ist nicht perfekt. Gerade auf Systemen wie AVR mit nur sehr begrenzten Resourcen muss man daher dem Compiler hilfreich zur Seite stehen, wenn man noch dichteren/schnelleren Code erhalten möchte.

 

 

Als Optimierungsgrad erweist sich <tt>-Os</tt> (Optimize for Size) als der beste, evtl. noch <tt>-O2</tt>. Ohne Angabe eines Optimierungsgrades wird nicht optimiert, was gleichbedeutend mit der Option <tt>-O0</tt> ist. Abzuraten ist von der maximalen Optimierung <tt>-O3</tt>, die wegen function inlining und loop unrolling zu sehr breitem Code führt und für AVR absolut nicht angesagt ist.

 

==Vermeide printf, scanf, malloc==

 

Alternativen findet man reichlich in der <tt>avr-libc</tt> wie <tt>itoa</tt> und <tt>atoi</tt>.

Und für <tt>malloc</tt> und Konsorten sind dynamische Arrays und das Compiler-Builtin <tt>__builtin_alloca</tt> effizientere Alternativen, siehe auch im Abschnitt "[[avr-gcc#Dynamische Speicherallokierung|Dynamische Speicherallokierung]]".

 

 

 

#include <avr/pgmspace.h>

 

===Sprungtabelle===

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