Version vom 29. November 2005, 14:35 Uhr

Für den GNU C-Compiler GCC ist ein Port für AVR verfügbar. GCC ist ein sehr leistungsfähiger Compiler, und er kann als die wichtigste freie Software überhaupt bezeichnet werden. Immerhin sind das freie Betriebssystem Linux und viele andere Programme -- auch gcc und die Toolchains selbst -- mit gcc generiert.

Im Gegensatz zu BASCOM ist GCC ein reiner Compiler, bringt also keine umfangreiche Bibliothek an Funktionalitäten mit. Jedoch finden sich einige low-level Funktionen zum Lesen aus dem Flash oder Lesen/Schreiben des EEPROMs etc. in der avr-libc.

Inhaltsverzeichnis

1 Allgemeine Charakteristika von avr-gcc
2 Kommandozeilen-Optionen
- 2.1 Allgemeine Optionen für GCC
- 2.2 Maschinenspezifische Optionen für avr-gcc
3 Code-Beispiele
- 3.1 Strings
4 Siehe auch
5 Weblinks

Allgemeine Charakteristika von avr-gcc

Größe des Typs int: der Standard-Typ int ist 16 Bit groß
Größe von Pointern: ein Pointer (Zeiger) ist 16 Bit groß
Endianess: avr-gcc implementiert Datentypen als little-endian, d.h. bei Datentypen, die mehrere Bytes groß sind, wird das niederwertigste Byte an der niedrigsten Adresse gespeichert. Dies gilt auch für Adressen und deren Ablage auf dem Stack sowie die Ablage von Werten, die mehrere Register belegen.

Kommandozeilen-Optionen

Die Codegenerierung bei avr-gcc wird über Kommandozeilen-Optionen gesteuert. Diese legen fest, für welchen Controller Code zu erzeugen ist, wie stark optimiert wird, ob Debug-Informationen erzeugt werden, etc. Die Optionen teilen sich in zwei Gruppen: Optionen, die für alle GCC-Ports verfürgbar sind und maschinenspezifische Optionen, die nur für AVR verfügbar sind.

Aus der Masse an GCC-Optionen kann hier nur ein kleiner Auszug der wichtigsten und am häufigsten verwendeten Optionen vorgestellt werden.

Allgemeine Optionen für GCC

--help: Anzeige der wichtigsten Optionen
--target-help: Anzeige der wichtigsten maschinenspezifischen Optionen
-O0: keine Optimierung
-O1: Optimierung
-Os: optimiert für Code-Größe
-O2: stärkere Optimierung für bessere Laufzeit
-g: erzeugt Debug-Informationen
-c: (pre)compilert und assembliert nur bis zum Objekt (*.o), kein link-Lauf
-S: (pre)compilert nur und erzeugt Assembler-Ausgabe (*.s)
-E: nur Precompilat (*.i) erzeugen, kein Compilieren, kein Assemblieren, kein Linken
-o <filename>: legt den Name der Ausgabedatei fest
-v: zeigt Versionsinformationen an und ist geschwätzig (verbose): Anzeige der aufgerufenen tools
-I<path>: Angabe eines weiteren Include-Pfads, in dem Dateien mit #include <...> gesucht werden
-E -dM <filename>: Anzeige aller Defines
-D<name>: Definiert Makro <name>
-D<name>=<wert>: Definiert Makro <name> zu <wert>
-U<name>: Undefiniert Makro <name>
-save-temps:Temporäre Dateien (*.i, *.s) werden nicht gelöscht. Teilweise fehlerhaft zusammen mit <code>-c

-Wa,<options>: übergibt Komma-getrennte Liste <options> an den Assembler (avr-as)
-Wp,<options>: übergibt Komma-getrennte Liste <options> an den Preprozessor
-Wl,<options>: übergibt Komma-getrennte Liste <options> an den Linker (avr-ld)
-ffreestanding: Das erzeugte Programm läuft nicht in einer Umgebung wie einer Shell. Der Prototyp von mein ist


void main (void);

Maschinenspezifische Optionen für avr-gcc

-mmcu=xxx: Festlegen des Targets, für das Code generiert werden soll. Je nach Target werden unterschiedliche Instruktionen verwendet und andere Startup-Dateien (crtxxx.o) eingebunden. Spezielle Defines werden gesetzt, um in der Quelle zwischen den Targets unterscheiden zu können:


#ifdef __AVR_AT90S2313__
/* Code fuer AT90S2313 */
#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega8__)
/* Code fuer Mega8 und Mega32 */ 
#else
#error Das ist noch nicht implementiert für diesen Controller!
#endif

mcu für AVR Classic, <= 8 kByte	Builtin define
avr2	`__AVR_ARCH__ = 2`
at90s2313	`__AVR_AT90S2313__`
at90s2323	`__AVR_AT90S2323__`
at90s2333	`__AVR_AT90S2333__`
at90s2343	`__AVR_AT90S2343__`
attiny22	`__AVR_ATtiny22__`
attiny26	`__AVR_ATtiny26__`
at90s4414	`__AVR_AT90S4414__`
at90s4433	`__AVR_AT90S4433__`
at90s4434	`__AVR_AT90S4434__`
at90s8515	`__AVR_AT90S8515__`
at90c8534	`__AVR_AT90C8534__`
at90s8535	`__AVR_AT90S8535__`
at86rf401	`__AVR_AT86RF401__`
mcu für AVR classic, > 8 kByte	Builtin define
avr3	`__AVR_ARCH__ = 3`
atmega103	`__AVR_ATmega103__`
atmega603	`__AVR_ATmega603__`
at43usb320	`__AVR_AT43USB320__`
at43usb355	`__AVR_AT43USB355__`
at76c711	`__AVR_AT76C711__`
mcu für AVR enhanced, <= 8 kByte	Builtin define
avr4	`__AVR_ARCH__ = 4`
atmega8	`__AVR_ATmega8__`
atmega8515	`__AVR_ATmega8515__`
atmega8535	`__AVR_ATmega8535__`
mcu für AVR enhanced, > 8 kByte	Builtin define
avr5	`__AVR_ARCH__ = 5`
atmega16	`__AVR_ATmega16__`
atmega161	`__AVR_ATmega161__`
atmega162	`__AVR_ATmega162__`
atmega163	`__AVR_ATmega163__`
atmega169	`__AVR_ATmega169__`
atmega32	`__AVR_ATmega32__`
atmega323	`__AVR_ATmega323__`
atmega64	`__AVR_ATmega64__`
atmega128	`__AVR_ATmega128__`
at94k	`__AVR_AT94K__`
mcu für AVR, nur Assembler	Builtin define
avr1	`__AVR_ARCH__ = 1`
at90s1200	`__AVR_AT90S1200__`
attiny11	`__AVR_ATtiny11__`
attiny12	`__AVR_ATtiny12__`
attiny15	`__AVR_ATtiny15__`
attiny28	`__AVR_ATtiny28__`

-minit-stack=xxx: Festlegen der Stack-Adresse
-mint8: Datentyp int ist nur 8 Bit breit, anstatt 16 Bit. Datentypen mit 32 Bit wie long sind nicht verfügbar
-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
-mtiny-stack: Nur die unteren 8 Bit des Stackpointers werden verändert
-mno-tablejump: Für ein switch-Statement werden keine Sprungtabellen angelegt
-mshort-calls: Verwendet rjmp/rcall (begrenzte Sprungweite) auf Devices mit mehr als 8 kByte Flash
-msize: Ausgabe der Instruktonslängen im asm-File
-mdeb: (undokumentiert) Ausgabe von Debug-Informationen für GCC-Entwickler
-morder1: (undokumentiert) andere Register-Allokierung
-morder2: (undokumentiert) andere Register-Allokierung

Code-Beispiele

Strings

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

Darstellung in C

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 '\0', 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.

Bestimmen der Stringlänge


/* Bestimmt die Laenge des Strings ohne die abschliessende '\0' zu zaehlen
unsigned int strlength (const char *str)
{
  unsigned int len = 0;
  
  while (*str++)
     len++;
  
  return len;
}

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


#include <string.h>
size_t strlen (const char*);

String im Flash belassen

Oftmals werden Strings nur zu Ausgabezwecken verwendet und nicht verändert. Verwendet man Sequenzen der Gestalt


char *str1 = "Hallo Welt!";
char str2[] = "Hallo Welt!";

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 man anhand der Adresse nicht unterscheiden, ob diese ins SRAM, inbsFlash oder ins EEPROM zeigt.


#include <avr/pgmspace.h>

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

unsigned int strlen_P (const prog_char *str)
{
   unsigned int len = 0;

   while (1)
   {
      char c = (char) pgm_read_byte (str);
      if ('\0' == c)
         return len;
      len++;
      str++; 
   }
}

void foo()
{
   unsigned int len;
   len = strlen_P (str3);
   len = strlen_P (PSTR("String im Flash"));
}

String ins EEPROM legen

Dies geht nach dem gleichen Muster, nach dem Strings ins Flash gelegt werden. Der Zugriff wird vergleichsweise langsam, denn der EEPROM ist langsamer als SRAM bzw. Flash.


#include <avr/eeprom.h>

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

unsigned int strlen_EE (const char *str)
{
   unsigned int len = 0;

   while (1)
   {
      char c = (char) eeprom_read_byte (str);
      if ('\0' == c)
         return len;
      len++;
      str++; 
   }
}

Siehe auch

Weblinks

@@ Zeile 209: / Zeile 209: @@
 ==Strings==
 Die Programmiersprache C kennt selber keine Strings; das einzige, was C bekannt ist, ist der Datentyp <code>char</code>, der ein einzelnes Zeichen repräsentiert.
-===Datstellung in C===
+===Darstellung in C===
 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 <code>'\0'</code>, 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.
 ===Bestimmen der Stringlänge===
 <code>

Avr-gcc: Unterschied zwischen den Versionen

Ansichten