Programmieren des AVR Microcontrollers mit GCC, libc 1.0.4

ArticleCategory: [Choose a category, do not translate this]

Hardware

AuthorImage:[Here we need a little image from you]


    [Photo of the Author]

TranslationInfo:[Author + translation history. mailto: or http://homepage]

original in en Guido Socher

AboutTheAuthor:[A small biography about the author]

Guido mag Linux, weil es ein wirklich gutes System ist, um seine eigene Hardware zu entwickeln.

Abstract:[Here you write a little summary]

Der AVR 8-Bit RISC Microcontroller von Atmel ist ein sehr verbreiteter Microcontroller. Es ist nur ein Chip mit EEPROM, Ram, Analog zu Digital Umwandler, einer Menge digitaler Ein- und Ausgabezeilen, Timern, UART f�r RS 232 communication und vielen anderen Dingen.

Das beste ist jedoch, dass es daf�r unter Linux eine vollst�ndige Programmierumgebung daf�r gibt: Man kann diesen Microcontroller in C programmieren, mit dem GCC Compiler.

Ich habe schon im M�rz 2002 einen Artikel �ber dasselbe Thema geschrieben. Eine Menge Dinge haben sich seitdem in der avr-libc Entwicklung ge�ndert und der AT90S4433 Microcontroller, den ich 2002 benutzt habe, wird nicht l�nger von Atmel hergestellt. Dies ist deshalb ein Update des M�rz 2002 Artikels. Ich benutze libc-1.0.4 und den ATmega8 Microcontroller.

Dieser Artikel soll nur eine Einf�hrung sein und in sp�teren Artikel werden wir wieder interessante Hardware bauen, die aber dies Mal auf dem ATmega8 basierend.

ArticleIllustration:[This is the title picture for your article]

[Illustration]

ArticleBody:[The article body]

Einleitung

Viele Leute waren am Programmieren des Atmel Microcontrollers interessiert, als ich 2002 den Artikel schrieb. Der erste Schritt, die Entwicklungsumgebung zum Laufen zu kriegen, ist jedoch der schwerste. Wenn etwas nicht funktioniert, hat man absolut keinen Hinweis, wo der Fehler liegen k�nnte. Liegt es am Programmierkabel?? Ein Fehler in der Schaltung? Fehlerhafte Installation? Ist der Parallelport im Bios abgeschaltet? Sind die Kernelmodule f�r ppdev falsch kompiliert? Es gibt eine Menge Gr�nde, warum es nicht funktioniert.

Um den Einstieg in die aufregende Welt der Microcontroller einfacher zu machen, gibt es bei shop.tuxgraphics.org jetzt eine bootbare CD mit einem kleinen Handbuch und der Programmierhardware. Alles, was du dann machen mu�t, ist, von der CD zu booten und alles l�uft. Es ist keine Softwareinstallation erforderlich und auf deinem Computer wird nichts ge�ndert.

Selbst ich benutze seit einer Weile so eine CD, da die Hardware, die ich baue, oft einige Generationen von Kerneln und Softwareinstallationenen auf meinem PC �berlebt. Wenn ich dann sp�ter die Microcontrollersoftware updaten will, brauche ich mir keine Gedanken dar�ber zu machen, ob meine Entwicklungsumgebung auf meinem Linux-PC noch l�uft. Ich boote einfach von der CD und alles l�uft.

Unabh�ngig von der CD erkl�re ich in den n�chsten Abschnitten die Installation der GCC avr Entwicklungsumgebung. Wenn du die CD von tuxgraphics hast, dann lies ab "Ein kleines Testprojekt" weiter.

Softwareinstallation: Was man dazu braucht

Um die GNU C Entwicklungsumgebung benutzen zu k�nnen, braucht man die folgende Software:

binutils-2.15.tar.bz2 Verf�gbar unter:
ftp://ftp.gnu.org/gnu/binutils/
oder einem der Mirrors. Z.B.
ftp://gatekeeper.dec.com/pub/GNU/binutils/
gcc-core-3.4.2.tar.bz2 Verf�gbar unter: ftp://ftp.gnu.org/gnu/gcc/
oder einem der Mirrors. Z.B.
ftp://gatekeeper.dec.com/pub/GNU/gcc/
avr-libc-1.0.4.tar.bz2.tar Die AVR C-library ist verf�gbar unter: http://savannah.nongnu.org/projects/avr-libc/
uisp-20040311.tar.bz2 Die AVR Programmiersoftware gibt es auf: http://savannah.nongnu.org/projects/uisp


Wir installieren alle Programme nach /usr/local/avr. Dadurch halten wir das Programm vom normalem Linux C Compiler getrennt. Erzeuge dieses Verzeichnis mit dem Befehl:
    mkdir /usr/local/avr 

Du kannst es jetzt schon zu deinem PATH hinzuf�gen:
    mkdir /usr/local/avr/bin
    export PATH=/usr/local/avr/bin:${PATH}

Softwareinstallation: GNU binutils

Das binutils Paket enth�lt alle n�tigen low-level Utilities, um Objektdateien zu bauen. Es beinhaltet einen AVR assembler (avr-as), Linker (avr-ld), library handling tools (avr-ranlib, avr-ar), Programme, zum Erzeugen von Objektdateien, die auf das EEPROM des Microcontrollers (avr-objcopy) geladen werden k�nnen, disassembler (avr-objdump) und utilities wie avr-strip und avr-size.

La� die folgenden Befehle laufen, um die binutils zu bilden und zu installieren:
tar jxvf binutils-2.15.tar.bz2
cd binutils-2.15/
mkdir obj-avr
cd obj-avr
../configure --target=avr --prefix=/usr/local/avr --disable-nls
make

# as root:
make install


F�ge die Zeile /usr/local/avr/lib zu der Datei /etc/ld.so.conf hinzu und la� den Befehl /sbin/ldconfig laufen, um den Linker-cache erneut zu bilden.

Softwareinstallation: AVR gcc

avr-gcc ist unser C Compiler.

La� den folgenden Befehl zum Bilden und Installieren laufen:
tar jxvf gcc-core-3.4.2.tar.bz2
cd gcc-3.4.2

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

make

# as root:
make install
   

Softwareinstallation: Die AVR C-library

Die C-library ist inzwischen ganz stabil, verglichen mit der, die ich im M�rz 2002 vorgestellt habe. La� den folgenden Befehl zum Bilden und Installieren laufen:
tar jxvf avr-libc-1.0.4.tar.bz2.tar
cd avr-libc-1.0.4
PREFIX=/usr/local/avr
export PREFIX
sh -x ./doconf
./domake

cd build
#as root:
make install
   

Softwareinstallation: Der Programmierer

Die Programmiersoftware l�dt den speziell preparierten Objektcode in das EEPROM unseres Microcontrollers.

Der uisp Programmierer f�r Linux ist ein sehr guter Programmierer. Er kann direkt von einem Makefile aus benutzt werden. Man f�gt einfach eine "make load" Regel hinzu und schon kann man die Software in einem kompilieren und laden.

uisp wird wie folgt installiert:

tar jxvf uisp-20040311.tar.bz2.tar
cd uisp-20040311
./configure --prefix=/usr/local/avr
make

# as root:
make install
   

Ein kleines Testprojekt

Wir beginnen mit einer kleinen Testschaltung, die du dann sp�ter erweitern kannst.

Dieses Schaltung kann auch als einfache Testumgebung f�r komplexere Hardware benutzt werden. Man kann einfach Software zum Testen laden und dann Sensoren oder Me�instrumente anschlie�en.

Unser Testprogramm, so wie es hier dargestellt ist, bringt einfach eine LED zum Blinken.

Ben�tigte Hardware


    [test circuit]
Du brauchst die unten aufgef�hrten Teile. Obwohl es ein ganz gew�hnlicher Microcontroller ist, ist er eventuell nicht in jedem Elektroladen vor Ort zu haben, aber gr��ere Distributoren f�r elektronische Komponenten wie ( www.conrad.de (Deutschland), www.selectronic.fr (Frankreich), digikey.com (US, Canada), etc... haben sie vorr�tig.
Du kannst sowohl den gesamten Bausatz als auch nur den Microcontroller bei shop.tuxgraphics.org bestellen.
1 x ATmega8 DIP version, Atmel 8 bit Avr risc processor.
1 x 28 pin 7.5mm IC Sockel
Der 28 pin Sockel ist ein bi�chen schwieriger zu bekommen. Normalerweise sind die 28 Sockel 14mm breit, aber wir brauchen einen 7.5mm Sockel.
1 x 10K Widerstand (Farbcode: braun, schwarz, orange)
1 x 1K Widerstand (Farbcode: braun, schwarz, rot)
1 x 10uF Elektrolytkondensator
einigen Draht
1 x LED
matrix board
Das folgende wird f�r den Programmierer ben�tigt (es wird nicht gebraucht, wenn du dir das "Linux AVR programming kit" von tuxgraphics besorgst):
1 x DB25 Stecker, der in den Parallelport pa�t.
Irgendeinen 5 pin Stecker/Sockel f�r den Programmierer. Ich empfehle, Prezisonsstreifenstcker (�hnlich der IC Sockel) zu benutzen und 5 Pins abzubrechen.
1 x 220 Ohm Widerstand (Farbcode: rot, rot, braun)
3 x 470 Ohm Widerstand (Farbcode: gelb, lila. braun)
Zus�tzlich zu den oben genannten Teilen brauchst du eine 5V elektronisch stabilisierte Spannungsversorgung oder man kann eine 4.5V Batterie als Stromversorgung benutzen.

Du hast wahrscheinlich bemerkt, da� wir keinen Kristall brauchen. Das ist so, weil der ATmega8 jetzt einen eingebauten Oszillator hat. Dieser Oszillator kann benutzt werden, wenn die genaue Taktfrequenz keine Rolle spielt. Wenn du jedoch pr�zise Me�instrumente bauen willst oder die UART/RS232 Schnittstelle benutzen willst, dann brauchst du einen Kristall. Welcher Typ von Oszillator benutzt wird, kann durch die "fuse bits" definiert werden, die man mit dem Programmierer ver�ndern kann. Ab Werk der interne 1Mhz Oszilator aktiv.

Bauen der Programmiererhardware

Die AVR Microcontroller erlauben in circuit programming (ISP). 
    [Linux AVR programmer]
D.h. man braucht den Microcontroller nicht von der Platine abmachen, um ihn zu programmieren. Es gibt verschiedene Programmierhardware zwischen 50-150 Euro. Mit Linux ist es jedoch m�glich, einen sehr einfachen Programmierer zu bauen, der dasselbe macht. Man braucht einen freien Parallelport und das folgende Kabel.

Beachte, dass das hier ein verbesserter Programmierer ist im Vergleich zu dem im M�rz 2002 Artikel vorgestellten. Wir bauen die Schutzwiderst�nde in den Programmierer ein. Das spart dann einiges an Platz und Teilen auf der Schaltungsplatine. Die Verdrahtung f�r das Programmiererkabel mu� wie folgt sein:
Pin auf pcb Pin auf AVR Schutzwiderstand Pin am Parallel Port
5 Reset (1) -- Init (16)
4 MOSI (17) 470 Ohm D0 (2)
3 MISO (18) 220 Ohm Busy (11)
2 SCK (19) 470 Ohm Strobe (1)
1 GND -- GND (18)

Das Kabel sollte nicht l�nger as 70cm lang sein.

Die Schutzwiderst�nde k�nnen in den Stecker wie in dem Bild rechts eingebaut werden.

Software schreiben

Der Atmeag 8 kann in normalem C mit der Hilfe von gcc programmiert werden. Ein bi�chen AVR assembler zu k�nnen, kann n�tzlich sein, ist aber nicht notwendig.

Die AVR libc kommt mit einem avr-libc-user-manual-1.0.4.pdf (1139921 bytes), das alle in C verf�gbaren Funktionen dokumentiert. Auf Atmels Website, (www.atmel.com, und dann: avr products -> 8 bit risc-> Datasheets), kann man das gesamte Datenblatt herunterladen. Es beschreibt alle Register und wie man die CPU benutzt.

Eine Sache, die man beachten mu�, wenn man einen Microcontroller benutzt, ist, dass er nur ein paar Bytes an Ram besitzt. D.h., man kann keine gro�en Datenstrukturen oder Strings deklarieren. Dein Programm sollte auch keine tief verschachtelten Funktionsaufrufe oder Rekursion benutzen.

Viel besser als alle Theorie ist ein richtiges Beispiel. Wir schreiben ein kleines Programm, das unsere LED in 0.5 Sekundenintervallen blinken l��t. Nicht sehr n�tzlich, aber sehr gut f�r den Anfang.

Die avr-libc hat sich sehr ge�ndert. Fr�her hat man ein Bit auf einem Port mit sbi gesetzt und es mit cbi wieder gel�scht. Jetzt werden solche Funktionen abgelehnt. Zuerst stelle ich den "guten alten Weg" dar:
    /* defines for future compatibility */
    #ifndef cbi
    #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
    #endif
    #ifndef sbi
    #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
    #endif

    void main(void)
    {
          /* INITIALIZE */
          /* enable PC5 as output */
          sbi(DDRC,PC5);

          
          /* BLINK, BLINK ... */
          while (1) {
                /* led on, pin=0 */
                cbi(PORTC,PC5);
                delay_ms(500);
                /* set output to 5V, LED off */
                sbi(PORTC,PC5);
                delay_ms(500);
          }
    }
   
Das folgende Beispiel macht genau dasselbe, benutzt aber die neue Syntax:

    void main(void)
    {
          /* INITIALIZE */
          /* enable PC5 as output */
          DDRC|= _BV(PC5);

          
          /* BLINK, BLINK ... */

          /* PC5 is 5 (see file include/avr/iom8.h) and _BV(PC5) is 00100000 */
          while (1) {
                /* led on, pin=0 */
                PORTC&= ~_BV(PC5);
                delay_ms(500);
                /* set output to 5V, LED off */
                PORTC|= _BV(PC5);
                delay_ms(500);
          }
    }
   
Das obige Codest�ck zeigt, wie einfach es ist, ein Programm zu schreiben. Du siehst nur das Hauptprogramm, die delay_ms Funktion ist in dem kompletten Programm (avrm8ledtest.c) enthalten. Um Pin PC5 als Output zu benutzen, mu�t du das PC5 Bit in dem Data Direction Register f�r port C (DDRC) setzen. Danach kannst du PC5 auf 0V setzen, mit der Funktion cbi(PORTC,PC5) (clear bit PC5) oder auf 5V mit sbi(PORTC,PC5) (set bit PC5). Der Wert von "PC5" ist in iom8.h definiert, das in io.h enthalten ist. Du mu�t dir dar�ber keine Gedanken machen. Wenn du schon mal Programme f�r multi user / multi tasking Systeme wie Linux geschrieben hast, wei�t du, dass man niemals eine nicht blockierende Endlosschleife schreiben darf. Dies w�re eine Verschwengung von CPU-Zeit und w�rde das System sehr verlangsamen. Im Falle des AVR ist das anders. Es gibt nicht mehrere Aufgaben und es l�uft auch kein weiteres Programm. Es gibt nicht mal ein Betriebssystem. Es ist deshalb ganz normal, Schleifen f�r immer laufen zu lassen.

Kompilieren und Laden

Bevor du anf�ngst, stell sicher, dass du /usr/local/avr/bin im PATH stehen hast. Wenn n�tig, �ndere dein .bash_profile oder .tcshrc und f�ge folgendes hinzu:

export PATH=/usr/local/avr/bin:${PATH} (for bash)
setenv PATH /usr/local/atmel/bin:${PATH} (for tcsh)

Wir benutzen den Parallelport und uisp zum Programmieren des AVRs. Uisp benutzt das ppdev Interface des Kernels. Deshalb mu�t du die folgenden Kernelmodule geladen haben:
    # /sbin/lsmod
    parport_pc
    ppdev
    parport
�berpr�fe mit dem Befehl /sbin/lsmod, dass sie geladen sind, ansonsten lade sie (als root) mit:
    modprobe parport
    modprobe parport_pc
    modprobe ppdev
   
Es ist eine gute Idee, diese Befehle automatisch beim Starten auszuf�hren. Du kannst sie zu einem rc script (z.B. f�r RedHat /etc/rc.d/rc.local) hinzuf�gen.
Um das ppdev Interface als normaler Benutzer zu benutzen, mu� root dir Schreibrechte geben durch einmaliges Laufenlassen des Befehls

chmod 666 /dev/parport0

Stell auch sicher, dass kein Druckerdaemon auf dem Parallelport l�uft. Wenn du einen laufen hast, dann stoppe ihn, bevor du das Programmierkabel anschlie�t. Jetzt ist alles fertig, um unseren Microcontroller zu kompilieren und zu programmieren.

Das Paket f�r unser Testprogramm (avrm8ledtest-0.1.tar.gz) enth�lt ein Make-file. Alles, was du tun mu�t, ist, das folgende zu tippen:

make
make load

Dies kompiliert und l�dt deine Software. Ich werde die Befehle nicht im Detail beschreiben. Du kannst sie im Makefile sehen und sie sind immer gleich. Ich erinnere mich selber nicht mehr an alle. Ich wei� nur, da� ich "make load" benutzen mu�. Wenn du ein anderes Programm schreiben willst, mu�t du nur alle avrm8ledtest in dem Makefile durch den Namen deines Programms ersetzen.

Einige interessante binutils

Interessanter als der tats�chliche Komilationsprozess sind einige binutils.
Diese utilities haben sich jedoch seit M�rz 2002 nicht ge�ndert. Schau deshalb im Abschnitt "Einige interessante binutils" im Artikel 231, M�rz 2002 nach.

Ideen und Anregungen

Der ATmega8 ist f�r die meisten Anwendungen zu dem AT90S4433 kompatibel. Du mu�t die "fuse bits" programmieren, um den externen Oszillator zu benutzen und die fr�her dargestellte Hardware arbeitet m�glicherweise mit nur kleinen �nderungen. Leider hatte ich noch nicht gen�gend Zeit, um alle Schaltungen nochmal f�r den ATmega8 zu testen. Wenn du auf der sicheren Seite sein willst, dann benutze den AT90S4433 f�r die alten Artikel. Wenn es dir nichts ausmacht, Fehler zu suchen und Probleme zu l�sen, dann probier den ATmega8 mit den alten Artikeln/Schaltungen aus.

Hier ist eine Liste der fr�heren Hardwareartikel:

Beachte, da� der hier dargestellte Programmierer schon die Schutzwiderst�nde enth�lt, die in den �lteren Hardwareartikeln auf die Platine eingebaut wurden. Um den neuen Programmierer mit den alten Platinen zu benutzen, mu�t du nur die Schutzwiderst�nde auf der Platine durch die Dr�hte ersetzen.

Referenzen