Installation der AVR-Toolchain

Die folgende Anleitung beschreibt die Installation aller nötigen Tools, um Code für den realen Bot zu übersetzen und auf den Bot zu übertragen.

Wer eine ältere Version des Codes (vor Release 20) benutzt, verwendet bitte die alte Anleitung.

Fertige Pakete verwenden (empfohlen)

Linux

Offizielle Toolchain:

AVR Toolchain for Linux herunterladen (8-bit Version) und entpacken. Getestete Version: 3.2.3. Anschließend sollte man noch das bin-Verzeichnis der AVR Toolchain zu $PATH hinzufügen oder die $PATH-Einstellung in Eclipse vornehmen.

Alternative:

Die meisten Linux-Distributionen liefern bereits mehr oder weniger aktuelle AVR-Compiler über ihre Paketverwaltung mit. Allerdings sollte man auf die Version des Compilers (der c't-Bot-Code benötigt avr-gcc Version 4.2.2 oder neuer) und der avr-libc Bibliothek (1.6.7 oder neuer) achten. Außerdem sind nach derzeitigem Stand Patches erforderlich, die Binutils und Compiler um Funktionalität erweitern, Fehler korrigieren und Unterstützung für neuere Prozessoren nachrüsten.
Die zu installierenden Pakete lauten z.B. unter Debian oder Ubuntu: binutils-avr, gcc-avr, avr-libc, avrdude; unter Fedora avr-binutils, avr-gcc, avr-libc, avrdude.

Bietet die eigene Linux Distribution keine kompatible Version an, lässt sich die AVR-Toolchain auch leicht selbst bauen, siehe Abschnitt Toolchain selber bauen.

Mac OS X

Unter Mac OS X kann man auf das Paket CrossPack for AVR zurückgreifen, das (analog zu WinAVR unter Windows) eine komplette AVR-Toolchain installiert. Derzeit empfohlene Version: 20100115.
Anschließend muss man nur noch die $PATH-Einstellung in Eclipse vornehmen.

Alternativ lässt sich die AVR-Toolchain auch leicht selbst bauen, siehe Abschnitt Toolchain selber bauen.

Windows

Offizielle Toolchain:

AVR Toolchain for Windows herunterladen und installieren. Das Installationsprogramm sollte man dabei explizit als Administrator ausführen (via Kontextmenü), sonst schlägt der Installer einen komischen Installationsort vor anstatt höhere Rechte anzufordern. Getestete Version: 3.2.3.

Alternative:

Alle benötigten Programme befinden sich fertig übersetzt im Paket WinAVR (letzte getestete Version: 20100110).
WinAVR wird derzeit nicht mehr weiterentwickelt, eine aktuellere Compiler Version findet man in der AVR Toolchain (s.o.).

Toolchain selber bauen

Linux und Mac OS X

Getestet unter Debian Lenny, Ubuntu Maverick (10.10), Ubuntu Natty (11.04), Mac OS X Leopard (10.5), Mac OS X Snow Leopard (10.6) und Mac OS X Lion (10.7), die Schritte sollten sich aber auch leicht auf andere Systeme übertragen lassen.
Wir installieren sämtliche Programme nach /usr/local/avr/.

Zunächst müssen die Pakete patch und texinfo über die Paketverwaltung der Distribution installiert werden, falls sie noch nicht installiert sind (unter Debian / Ubuntu z.B.: sudo apt-get install patch texinfo).

Herunterladen der Quellen

Alle Dateien können in ein beliebiges Verzeichnis heruntergeladen werden, diese Anleitung verwendet ~/avrtoolchain.

1. Patches
2. binutils 2.20.1
3. gcc 4.5.1
4. gmp 5.0.2
5. mpfr 2.4.2
6. avr-libc 1.7.1
7. avrdude 5.10
8. libusb 0.1.12 (wird nur benötigt, falls ein USB-Programmer mit avrdude eingesetzt werden soll)
9. gdb-7.0.1 (wird nur benötigt, falls low-level-Debugging gewünscht ist)
10. simulavr-1.2.5 (Version 1.2.6 funktioniert nicht für ATmegas; wird nur benötigt, falls low-level-Debugging gewünscht ist)

Patches entpacken

Ab hier geht diese Anleitung davon aus, dass das aktuelle Arbeitsverzeichnis –/avrtoolchain ist, in das die o.g. Archive heruntergeladen wurden.
Auf Mehrprozessorsystemen bietet es sich an, anstatt make jeweils make -j N zu verwenden, wobei N auf 2 bis 4 pro (logischem) Prozessor gesetzt werden sollte.

1. tar xvjf patches.tar.bz2

avr-binutils

1. tar xvjf binutils-2.20.1.tar.bz2
2. cd binutils-2.20.1
3. for file in $(find ../patches/binutils/ -type f -name "*.patch" | sort); do patch -p0 -i $file; done
4. cd ..
5. mkdir build-binutils
6. cd build-binutils
7. ../binutils-2.20.1/configure --prefix=/usr/local/avr --target=avr --program-prefix=avr- --enable-install-libbfd --with-dwarf2 --enable-languages=c,c++ --disable-werror --disable-nls
8. make
9. sudo make install
10. cd ..
11. rm -rf build-binutils
12. rm -rf binutils-2.20.1
13. export PATH=$PATH:/usr/local/avr/bin (für nicht-bash-Shells evtl. anpassen)
14. Es bietet sich an, die Pfadanpassung dauerhaft zu machen, indem man sie ins Login- oder Bash-Script des Systems einträgt (in ~/.profile bzw. ~/.bashrc usw. je nach System)

avr-gcc

1. export CC=/usr/bin/gcc-4.2 # nur unter Mac OS X Lion (10.7)
2. tar xvjf gcc-4.5.1.tar.bz2
3. tar xvjf gmp-5.0.2.tar.bz2
4. mv gmp-5.0.2 gcc-4.5.1/gmp
5. tar xvjf mpfr-2.4.2.tar.bz2
6. mv mpfr-2.4.2 gcc-4.5.1/mpfr
7. tar xvzf mpc-0.9.tar.gz
8. mv mpc-0.9 gcc-4.5.1/mpc
9. cd gcc-4.5.1
10. for file in $(find ../patches/gcc/ -type f -name "*.patch" | sort); do patch -p0 -i $file; done
11. cd ..
12. mkdir build-gcc
13. cd build-gcc
14. ../gcc-4.5.1/configure --prefix=/usr/local/avr --target=avr --program-prefix=avr- --enable-languages=c,c++ --with-dwarf2 --enable-doc --disable-shared --disable-libada --disable-libssp --disable-nls --enable-fixed-point
15. make
16. sudo make install
17. cd ..
18. rm -rf build-gcc
19. rm -rf gcc-4.5.1

avr-libc

1. tar xvjf avr-libc-1.7.1.tar.bz2
2. cd avr-libc-1.7.1
3. for file in $(find ../patches/avr-libc/ -type f -name "*.patch" | sort); do patch -p0 -i $file; done
4. cd ..
5. mkdir build-libc
6. cd build-libc
7. ../avr-libc-1.7.1/configure --prefix=/usr/local/avr --build=`../avr-libc-1.7.1/config.guess` --host=avr
8. make
9. sudo su
10. export PATH=$PATH:/usr/local/avr/bin
11. make install
12. exit
13. cd ..
14. rm -rf build-libc
15. rm -rf avr-libc-1.7.1

libusb

libusb wird nur benötigt, falls ein USB-Programmer mit avrdude benutzt werden soll und es noch nicht installiert ist (wie z.B. unter Mac OS X). Das betrifft Atmel mkII und AVR Dragon (siehe auch Übertragen von Firmware in den AVR-Mikrocontroller).

1. tar xvzf libusb-0.1.12.tar.gz
2. cd libusb-0.1.12
3. patch -p0 -i ../patches/libusb/werror.patch
4. cd ..
5. mkdir build-libusb
6. cd build-libusb
7. ../libusb-0.1.12/configure --prefix=/usr/local/avr
8. make
9. sudo make install
10. cd ..
11. rm -rf build-libusb
12. rm -rf libusb-0.1.12

avrdude

1. tar xvzf avrdude-5.10.tar.gz
2. mkdir build-avrdude
3. cd build-avrdude
4. CFLAGS=-I/usr/local/avr/include LDFLAGS=-L/usr/local/avr/lib ../avrdude-5.10/configure --prefix=/usr/local/avr
5. make
6. sudo make install
7. cd ..
8. rm -rf build-avrdude
9. rm -rf avrdude-5.10

avr-gdb (optional)

avr-gdb wird nur benötigt, wenn low-level-Debugging gewünscht ist. Debuggen auf dieser Ebene ist nur in seltenen Spezialfällen erforderlich.

Der C-Code, der insgesamt c't-Bot genannt wird, hat drei Komponenten:

• High-Level-Anteile (inkl. von Lesern entwickeltem Bot-Steuercode), die z. B. Sensorwerte zugestellt bekommen und auf sie reagieren. Derselbe High-Level-Code läuft sowohl auf dem PC um einen virtuellen Bot in einer vom c't Sim simulierten Welt zu steuern, als auch auf der AVR um einen in Hardware realisierten Bot zu steuern.
• PC-Low-Level-Teile, die auf dem PC ausgeführt werden und z.B. (simulierte) Sensorwerte per TCP vom c't-Sim lesen und an den High-Level-Code weiterreichen
• AVR-Low-Level-Teile, die vom Mikrocontroller des in Hardware realisierten Bot ausgeführt werden und z.B. Sensorwerte von den Hardware-Sensoren lesen und an den High-Level-Code weiterreichen.
  

Der AVR-gdb dient nun dazu, diesen letzteren Teil des C-Codes debuggen zu können – und zwar in einer auf dem PC laufenden, vom Simulavr-Paket bitgenau emulierten Umgebung. Das ist hilfreich in den (wenigen, speziellen) Fällen, wo es nicht möglich oder zu unbequem ist, Debuginformationen auf dem Display des Roboters auszugeben. Bisher haben wir das nur unter Linux ausprobiert; unter Windows sollte es jedoch analog funktionieren.

1. tar xvjf gdb-7.0.1.tar.bz2
2. mkdir build-gdb
3. cd build-gdb
4. ../gdb-7.0.1/configure --prefix=/usr/local/avr --target=avr --enable-languages=c,c++ --disable-werror
5. make
6. sudo make install
7. cd ..
8. rm -rf build-gdb
9. rm -rf gdb-7.0.1

simulavr (optional)

simulavr wird nur benötigt, wenn low-level-Debugging gewünscht ist, siehe avr-gdb.

1. tar xvzf simulavr-0.1.2.5.tar.gz
2. cd simulavr-0.1.2.5
3. patch -p0 -i ../patches/simulavr/simulavr.patch
4. CFLAGS="-g -O2 -Wall -fomit-frame-pointer -finline-functions -mtune=native" ./configure --prefix=/usr/local/avr
5. make
6. sudo make install
7. cd ..
8. rm -rf simulavr-0.1.2.5

Aufräumen

1. Alle heruntergeladenen Archive und die entpackten Patches können nun gelöscht werden.

Eclipse-Konfiguration

$PATH-Einstellung in Eclipse

Dies ist nur nötig, falls avr-gcc nicht im systemweiten $PATH liegt.
Um $PATH für alle Projekte in Eclipse zentral einzustellen, trägt man die Änderungen am besten in den globalen Einstellungen von Eclipse ein:

• Dazu wählt man zunächst "PATH" unter "Select..." aus und hängt mit "Edit..." anschließend die folgende Zeichenkette an den bestehenden Eintrag an:
  
  • AVR Toolchain for Linux: Pfad zum bin-Verzeichnis der Installationsorts
  • CrossPack for AVR (unter Mac OS X): :/usr/local/CrossPack-AVR/bin
  • selbstgebaute Toolchain: :/usr/local/avr/bin

Makeflags-Einstellung in Eclipse

Um den Build-Prozess auf Mehrkernsystemen zu beschleunigen, bietet es sich an, per Makeflags global den -j N Parameter für Make einzustellen. N stellt man dabei üblicherweise auf das Doppelte der Kernanzahl ein.

• Dazu wählt man zunächst "Add" aus und trägt unter "Name:" ein: MAKEFLAGS
  
• Unter Value: trägt man -jN ein, wobei N die Anzahl der gleichzeitig zu startenden Jobs ist (s.o.).

avr-gdb in Eclipse einbinden (optional)

• In Eclipse unter Run -> Debug Configurations... ein neues Debug-Target für den Mikrocontroller anlegen. Es sollte folgende Eigenschaften haben:
  1. 
     
     
  2. 
     
     
  3. 
     
     

• Emulator starten: Damit nun der avr-gdb, der von Eclipse aufgerufen wird, den Code in der AVR-Umgebung ausführen kann, muss simulavr im Hintergrund laufen. In einer Shell startet man deshalb: simulavr -g -p 1212 -d atmega32 -c 16000000