Version vom 23. Juni 2006, 08:25 Uhr

Es gibt bereits eine sehr gute Anleitung für das Installieren vom avr-gcc, aber sie ist etwas veraltet. Für den original Text siehe [1]. Ich werde im folgenden nur das nötigste von diesem Artikel kopieren.

Es gibt drei Teile. Im ersten Teil wird die Installation erklärt, im zweiten wird gezeigt, wie man damit denn nun seine Programme für den MCU erstellt. Im dritten Teil stehen noch ein paar typische Fehlermeldungen und die Lösungen.

Installation

Also los. Wir brauchen folgende Software:

• binutils-2.16.1.tar.bz2
• gcc-core-4.0.2.tar.bz2
• avr-libc-1.2.5.tar.bz2 Dort findet ihr auch das Manual der avr-libc
• avrdude-5.0.tar.gz

Als erstes erstellen wir das Verzeichnis, in das der avr-gcc installiert wird:

• Als root:

mkdir /usr/local/avr

Und das Verzeichnis in dem die Programme liegen werden:

• Als root:

mkdir /usr/local/avr/bin

Dieses Verzeichnis wird auch gleich in die PATH-Variable geschrieben:

export PATH=$PATH:/usr/local/avr/bin

Achtung, dieser Befehl ist nur in dieser eine Konsole in der ihr seid gültig und auch nur solange wie diese offen ist. Um die Änderung systemweit wirksam zu machen, müsst ihr in die Datei /etc/profile den PATH nachtragen. Bei mir sieht das z.B. so aus:

# Set the default system $PATH:
PATH="/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/usr/games[b]:/usr/local/avr/bin[/b]"

binutils

Mit den binutils bekommt ihr Programme wie z.b. avr-as (Assembler), avr-ld (Linker), avr-objcopy (Um die Intel-Hex-Files zu erstellen).

Und so wird's gemacht (Das entpacken kann eine Weile dauern):

tar jxf binutils-2.16.1.tar.bz2
cd binutils-2.16.1/
mkdir obj-avr
cd obj-avr
../configure --target=avr --prefix=/usr/local/avr --disable-nls
make

• Als root:

make install

avr-gcc

avr-gcc ist unser eigentlicher Compiler. Er installiert sich wie folgt:

tar jxf gcc-core-4.0.2.tar.bz2
cd gcc-4.0.2

mkdir obj-avr
cd obj-avr
../configure --target=avr --prefix=/usr/local/avr --disable-nls --enable-language=c

make

Hinweis: Falls ihr jetzt beim Installieren Fehler bekommt die sich z.B so äussern:

make[2]: avr-ranlib: Command not found

Dann liegt /usr/local/avr/bin wider erwarten nicht in PATH. Führt diesen Befehl als root nochmal aus, dann sollte es gehen:

export PATH=$PATH:/usr/local/avr/bin

• Als root:

make install

avr C-library (avr-libc)

tar jxf avr-libc-1.2.5.tar.bz2
cd avr-libc-1.2.5

PREFIX=/usr/local/avr
export PREFIX
sh -x ./doconf
./domake

cd build

• Als root:

make install

avrdude

tar xzf avrdude-5.0.tar.gz
cd avrdude-5.0
./configure --prefix=/usr/local/avr
make

• Als root:

make install

Wer den avr910 Programmer benutzt, muss avrdude erst fit für einige neuere Controller machen. (ATtiny2313, ATmega162, ...). Dazu müsst ihr die Configdatei von avrdude anpassen. Ihr findet sie unter /usr/local/avr/etc/avrdude.conf

Folgende Zeilen müssen ergänzt werden:

#------------------------------------------------------------
# ATtiny2313
#------------------------------------------------------------

part
     id            = "t2313";
     desc          = "ATtiny2313";
     stk500_devcode   = 0x23;
##  Try the STK500 devcode:
   [b]avr910_devcode   = 0x23;[/b]
.....

#------------------------------------------------------------
# ATmega8535
#------------------------------------------------------------

part
    id               = "m8535";
    desc             = "ATMEGA8535";
    stk500_devcode   = 0x64;
   [b] avr910_devcode   = 0x69;[/b]

Analog verfahren für ATmega64, ATmega162 und ATmega169. Die devicecodes hiefür sind:

m64:     avr910_devcode   = 0x45;
m162:    avr910_devcode   = 0x62;
m169:    avr910_devcode   = 0x78;

Wer sich einen eigenen avr910 Programmer bauen will, dem sei diese Seite ans Herz gelegt: [2]. Ich habe die Version genommen und um ein Buffer erweitert. Die Bauanleitung dafür gibt es bald auf unserer Roboterseite.

Somit hätten wir nun alles was wir brauchen installiert.

Beispiel-Projekt

Hier erstmal ein winziges Beispielprogramm für den ATtiny2313.

/*
 *  blink.c
 *  ATTiny2313 mit 1 MHz
 *  PORTB wird ueber ein Timer alle 0.263s ein- und ausgeschaltet. Das entspricht 3.81Hz
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>

SIGNAL (SIG_TIMER0_OVF)
{
  PORTB =~ PORTB; // PORTB inventieren
}

int main()
{

  DDRB  = 0xFF; // PORTB als Ausgang schalten
  PORTB = 0x00; // Alle Ausgaenge auf 0 schalten

  TCCR0B |= (1 << CS02) | (1 << CS00); //Prescaler auf 1024 stellen
  TIMSK  |= (1 << TOIE0);              // Timer 0 Overflow Interrupt enable

  sei(); // Interrupts einschalten

  for(;;); //ever
}

Den Quelltext nehmt ihr und speichert ihn in die Datei blink.c.

Jetzt kommt das Makefile. Ich habe schonmal ein einfaches vorbereitet:

TARGET = blink
MCU    = attiny2313
CC     = avr-gcc
OBJCOPY=avr-objcopy
CFLAGS =-g -mmcu=$(MCU) -Wall -Wstrict-prototypes -Os -mcall-prologues -save-temps -fno-common

all: $(TARGET).hex

$(TARGET).hex : $(TARGET).out
	$(OBJCOPY) -R .eeprom -O ihex $(TARGET).out $(TARGET).hex

$(TARGET).out : $(TARGET).o
	$(CC) $(CFLAGS) -o $(TARGET).out -Wl,-Map,$(TARGET).map $(TARGET).o

$(TARGET).o : $(TARGET).c
	$(CC) $(CFLAGS) -c $(TARGET).c

load: $(TARGET).hex
	avrdude -p t2313 -c avr910 -U flash:w:$(TARGET).hex -v

clean:
	rm -f *.o *.map *.out *.hex *.s *.i

Das speichert ihr in der Datei Makefile im selben Ordner in der auch die Datei blink.c liegt. Unbedingt darauf auchten, daß die Einrückungen durch TABs erfolgen und nicht durch Leerzeichen!

Dann einfach in der Konsole [[make]] tippen und es sollte compiliert werden. Mit make load wird das Hexfile dann in den MCU übertragen.

Und nun zur Erklärung.

MCU=attiny2313 ist eine Variable mit dem Inhalt attiny2313. Überall, wo jetzte $(TARGET) steht, wird der Variabelninhalt benutzt. Genauso funktioniert das auch mit CC, OBJCOPY und CFLAGS. Nachdem ihr make erfolgreich ausgefuehrt habt, liegt in dem Ordner nun die Hexfile und eine Datei mit der Endung  .s. Darin sind die Assemblerbefehle, die der Compiler aus dem C-Code gemacht hat. Wer so etwas nicht braucht, der kann den Parameter -save-temps in der Variable CFLAGS getrost entfernen.

Wenn ihr make load ausfürt, wird avrdude gestarte. -p gibt an, um welchen MCU es sich handelt. Mit -c gebt ihr an, um welchen Programmer es sich handelt. Hier könnte z.B stk500 stehen. -U flash:w:$(TARGET).hex bedeutet einfach, dass das Programm in den Flash geschrieben werden soll. w steht für Schreiben, r für Lesen und v für verify. Dann kommt die Variable $(TARGET), die besagt, welche Datei genau übertragen werden soll. Und am Schluss steht noch ein -v. v Bedeutet "Verbose Output" und gibt euch mehr Informationen auf der Konsole aus.

Mit make clean werden alle Object-Dateien etc. gelöscht.

Fehlermeldungen

sollten eigentlich keine vorkommen. Wenn doch, vergewissert euch, dass ihr euch genau an die Anleitung gehalten und nichts falsch abgeschrieben habt!

Hier ein paar typische Fehlermeldungen und ihr Lösungen:

Permission denied

Ihr habt nicht die Rechte, um diesen Befehl auszuführen. Höchswahrscheinlich müsst ihr den Befehl als root ausführen.

make[2]: avr-ranlib: Command not found

/usr/local/avr/bin liegt nicht in $PATH. Folgendes Command ausführen:

export PATH=$PATH:/usr/local/avr/bin

programmer is not responding

Es kann keine Verbindung zum Programmer aufgenommen werden: Defektes Kabel, Programmer an der falschen Schnittstelle angeschlossen (default: /dev/ttyS0), kein Strom am Programmer etc.

can't open device "/dev/ttyS0": Permission denied

Als normaler User darf man auf die Serielle Schnittstelle nicht lesen oder schreiben. Folgenden Befehl als root ausfueren:

chmod 666 /dev/ttyS0

Siehe auch

• avr-gcc

Quelle

[3]

Autoren

• Kater (Manuscript)
• SprinterSB (Transcript und Typo)