Aus RN-Wissen.de
Wechseln zu: Navigation, Suche
Rasenmaehroboter Test

(Siehe auch)
(prefix /usr/local/avr entfernt, da eine bereits vorhandene default-Installation nach /local/avr sich damit überschneidet)
 
(24 dazwischenliegende Versionen von 10 Benutzern werden nicht angezeigt)
Zeile 4: Zeile 4:
 
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 [[Microcontroller|MCU]] erstellt. Im dritten Teil stehen noch ein paar typische Fehlermeldungen und die Lösungen.
 
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 [[Microcontroller|MCU]] erstellt. Im dritten Teil stehen noch ein paar typische Fehlermeldungen und die Lösungen.
  
=Installation=
+
= Installation =
  
 
Also los. Wir brauchen folgende Software:
 
Also los. Wir brauchen folgende Software:
  
* [ftp://ftp.gnu.org/gnu/binutils/ binutils-2.16.1.tar.bz2]
+
* [ftp://ftp.gnu.org/gnu/binutils/ binutils-2.17.tar.bz2]
* [ftp://ftp.gnu.org/gnu/gcc/gcc-4.0.2/ gcc-core-4.0.2.tar.bz2]  
+
* [ftp://ftp.gnu.org/gnu/gcc/gcc-4.1.2/ gcc-core-4.1.2.tar.bz2]  
* [http://savannah.nongnu.org/download/avr-libc/ avr-libc-1.2.5.tar.bz2]    Dort findet ihr auch das Manual der avr-libc
+
* [http://savannah.nongnu.org/download/avr-libc/ avr-libc-1.4.5.tar.bz2]    Dort findet ihr auch das Manual der avr-libc
* [http://savannah.nongnu.org/download/avrdude/ avrdude-5.0.tar.gz]       
+
* [http://savannah.nongnu.org/download/avrdude/ avrdude-5.3.1.tar.gz]       
  
Als erstes erstellen wir das Verzeichnis, in das der avr-gcc installiert wird:
+
== [[binutils]] ==
 
+
* 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 <tt>PATH</tt>-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 <tt>/etc/profile</tt> den <tt>PATH</tt> nachtragen. Bei mir sieht das z.B. so aus:
+
<pre>
+
# Set the default system $PATH:
+
PATH="/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/usr/games[b]:/usr/local/avr/bin[/b]"
+
</pre>
+
 
+
==binutils==
+
  
 
Mit den binutils bekommt ihr Programme wie z.b. <tt>avr-as</tt> (Assembler), <tt>avr-ld</tt> (Linker), <tt>avr-objcopy</tt> (Um die Intel-Hex-Files zu erstellen).
 
Mit den binutils bekommt ihr Programme wie z.b. <tt>avr-as</tt> (Assembler), <tt>avr-ld</tt> (Linker), <tt>avr-objcopy</tt> (Um die Intel-Hex-Files zu erstellen).
Zeile 38: Zeile 19:
 
Und so wird's gemacht (Das entpacken kann eine Weile dauern):
 
Und so wird's gemacht (Das entpacken kann eine Weile dauern):
 
<pre>
 
<pre>
tar jxf binutils-2.16.1.tar.bz2
+
tar jxf binutils-2.17.tar.bz2
cd binutils-2.16.1/
+
cd binutils-2.17/
 
mkdir obj-avr
 
mkdir obj-avr
 
cd obj-avr
 
cd obj-avr
../configure --target=avr --prefix=/usr/local/avr --disable-nls
+
../configure --target=avr --disable-nls
 
make
 
make
 
</pre>
 
</pre>
Zeile 48: Zeile 29:
 
  make install
 
  make install
  
==avr-gcc==
+
== [[avr-gcc]] ==
  
 
avr-gcc ist unser eigentlicher Compiler. Er installiert sich wie folgt:
 
avr-gcc ist unser eigentlicher Compiler. Er installiert sich wie folgt:
 
<pre>
 
<pre>
tar jxf gcc-core-4.0.2.tar.bz2
+
tar jxf gcc-core-4.1.2.tar.bz2
cd gcc-4.0.2
+
cd gcc-4.1.2
  
 
mkdir obj-avr
 
mkdir obj-avr
 
cd obj-avr
 
cd obj-avr
../configure --target=avr --prefix=/usr/local/avr --disable-nls --enable-language=c
+
../configure --target=avr --disable-nls --enable-languages=c --disable-libssp
  
 
make
 
make
 
</pre>
 
</pre>
 
Hinweis: Falls ihr jetzt beim Installieren Fehler bekommt die sich z.B so äussern:
 
make[2]: avr-ranlib: Command not found
 
Dann liegt <tt>/usr/local/avr/bin</tt> wider erwarten nicht in <tt>PATH</tt>. Führt diesen Befehl als root nochmal aus, dann sollte es gehen:
 
export PATH=$PATH:/usr/local/avr/bin
 
  
 
* Als root:
 
* Als root:
 
  make install
 
  make install
  
==avr C-library (avr-libc)==
+
==avr C-library ([[avr-libc]])==
 
<pre>
 
<pre>
tar jxf avr-libc-1.2.5.tar.bz2
+
tar jxf avr-libc-1.4.5.tar.bz2
cd avr-libc-1.2.5
+
cd avr-libc-1.4.5
  
PREFIX=/usr/local/avr
+
./configure --build=`./config.guess` --host=avr
export PREFIX
+
sh -x ./doconf
+
./domake
+
  
cd build
+
make
 
</pre>
 
</pre>
 
* Als root:
 
* Als root:
Zeile 86: Zeile 59:
  
  
==avrdude==
+
== [[avrdude]] ==
  
 
<pre>
 
<pre>
tar xzf avrdude-5.0.tar.gz
+
tar xzf avrdude-5.3.1.tar.gz
cd avrdude-5.0
+
cd avrdude-5.3.1
./configure --prefix=/usr/local/avr
+
./configure
 
make
 
make
 
</pre>
 
</pre>
Zeile 100: Zeile 73:
 
([[ATtiny2313]], [[ATmega162]], ...). Dazu müsst ihr die Configdatei von avrdude anpassen. Ihr findet sie unter <tt>/usr/local/avr/etc/avrdude.conf</tt>
 
([[ATtiny2313]], [[ATmega162]], ...). Dazu müsst ihr die Configdatei von avrdude anpassen. Ihr findet sie unter <tt>/usr/local/avr/etc/avrdude.conf</tt>
  
Folgende Zeilen muessen ergänzt werden:
+
Folgende Zeilen müssen ergänzt werden:
 
<pre>
 
<pre>
 
#------------------------------------------------------------
 
#------------------------------------------------------------
Zeile 137: Zeile 110:
 
Somit hätten wir nun alles was wir brauchen installiert.
 
Somit hätten wir nun alles was wir brauchen installiert.
  
=Beispiel-Projekt=
+
= Beispiel-Projekt =
  
 
Hier erstmal ein winziges Beispielprogramm für den [[ATtiny2313]].
 
Hier erstmal ein winziges Beispielprogramm für den [[ATtiny2313]].
Zeile 143: Zeile 116:
 
/*
 
/*
 
  *  blink.c
 
  *  blink.c
  *  ATTiny2313 mit 1 MHz
+
  *  ATtiny2313 mit 1 MHz
 
  *  PORTB wird ueber ein Timer alle 0.263s ein- und ausgeschaltet. Das entspricht 3.81Hz
 
  *  PORTB wird ueber ein Timer alle 0.263s ein- und ausgeschaltet. Das entspricht 3.81Hz
 
  */
 
  */
Zeile 149: Zeile 122:
 
#include <avr/io.h>
 
#include <avr/io.h>
 
#include <avr/interrupt.h>
 
#include <avr/interrupt.h>
#include <avr/signal.h>
 
  
SIGNAL (SIG_TIMER0_OVF)
+
ISR (SIG_TIMER0_OVF)
 
{
 
{
 
   PORTB =~ PORTB; // PORTB inventieren
 
   PORTB =~ PORTB; // PORTB inventieren
Zeile 158: Zeile 130:
 
int main()
 
int main()
 
{
 
{
 
 
   DDRB  = 0xFF; // PORTB als Ausgang schalten
 
   DDRB  = 0xFF; // PORTB als Ausgang schalten
 
   PORTB = 0x00; // Alle Ausgaenge auf 0 schalten
 
   PORTB = 0x00; // Alle Ausgaenge auf 0 schalten
Zeile 177: Zeile 148:
 
MCU    = attiny2313
 
MCU    = attiny2313
 
CC    = avr-gcc
 
CC    = avr-gcc
OBJCOPY=avr-objcopy
+
CFLAGS =-g -mmcu=$(MCU) -Wall -Wstrict-prototypes -Os -mcall-prologues -save-temps -fno-common
+
CFLAGS =-mmcu=$(MCU) -Wall  
 +
LDFLAGS =-mmcu=$(MCU)
  
all: $(TARGET).hex
+
$(TARGET): $(TARGET).o
  
$(TARGET).hex : $(TARGET).out
+
$(TARGET).hex : $(TARGET)
$(OBJCOPY) -R .eeprom -O ihex $(TARGET).out $(TARGET).hex
+
avr-objcopy -j .data -j .text -O ihex $< $@
 
+
$(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
 
load: $(TARGET).hex
Zeile 195: Zeile 161:
  
 
clean:
 
clean:
rm -f *.o *.map *.out *.hex *.s *.i
+
rm -f *.o *.hex $(TARGET)
 
</pre>
 
</pre>
Das speichert ihr in der Datei <tt>Makefile</tt> im selben Ordner in der auch die Datei <tt>blink.c liegt</tt>. '''Unbedingt darauf auchten, daß die Einrückungen durch TABs erfolgen und nicht durch Leerzeichen!'''
+
Das speichert ihr in der Datei <tt>Makefile</tt> im selben Ordner, in der auch die Datei <tt>blink.c liegt</tt>. '''Unbedingt darauf achten, daß die Einrückungen durch TABs erfolgen und nicht durch Leerzeichen!'''
 +
 
 +
Als ersten Test kann man ohne Gefahr <tt>make -n</tt> benutzen. Hier wird nur gezeigt was passieren würde.
  
Dann einfach in der Konsole [[<tt>make</tt>]] tippen und es sollte compiliert werden. Mit <tt>make load</tt> wird das Hexfile dann in den MCU übertragen.
+
Dann in der Konsole "<tt>[[make]]</tt>" tippen und es sollte compiliert werden. Mit "<tt>make load</tt>" wird das Hexfile dann in den MCU übertragen.
  
Und nun zur Erklärung.
+
===Erklärung===
  
<tt>MCU=attiny2313</tt> ist eine Variable mit dem Inhalt <tt>attiny2313</tt>. Überall, wo jetzte <tt>$(TARGET)</tt> steht, wird der Variabelninhalt benutzt. Genauso funktioniert das auch mit <tt>CC</tt>, <tt>OBJCOPY</tt> und <tt>CFLAGS</tt>. Nachdem ihr <tt>make</tt> erfolgreich ausgefuehrt habt, liegt in dem Ordner nun die Hexfile und eine Datei mit der Endung <tt>&nbsp;.s</tt>.
+
;<tt>MCU=attiny2313</tt>: <tt>MCU</tt> ist eine Variable mit dem Inhalt <tt>attiny2313</tt>. Überall, wo jetzte <tt>$(MCU)</tt> steht, wird der Variabelninhalt benutzt. Genauso funktioniert das auch mit <tt>TARGET</tt>, <tt>CC</tt>, <tt>LDFLAGS</tt> und <tt>CFLAGS</tt>.  
Darin sind die Assemblerbefehle, die der Compiler aus dem C-Code gemacht hat. Wer so etwas nicht braucht, der kann den Parameter <tt>-save-temps</tt> in der Variable <tt>CFLAGS</tt> getrost entfernen.
+
  
Wenn ihr <tt>make load</tt> ausfürt, wird avrdude gestarte. <tt>-p</tt> gibt an, um welchen MCU es sich handelt. Mit <tt>-c</tt> gebt ihr an, um welchen Programmer es sich handelt. Hier könnte z.B <tt>stk500</tt> stehen.
+
Mit den letzten drei Variablen wird das Verhalten von ''make'' verändert. '''CC''' bestimmt welcher Compiler verwendet wird (Default:''cc''). ''CFLAGS'' beinflussen das Compilieren, mit ''-mmcu='' wird hier der Prozessortyp gesetzt, ''-Wall'' schaltet Warnungen für den ''avr-gcc'' ein. '''LDFLAGS''' werden dem Linker übergeben und sollten mindestens den  Prozessortyp beinnhalten.  
<tt>-U flash:w:$(TARGET).hex</tt> bedeutet einfach, dass das Programm in den Flash geschrieben werden soll.
+
<tt>w</tt> steht für Schreiben, <tt>r</tt> für Lesen und <tt>v</tt> für verify. Dann kommt die Variable <tt>$(TARGET)</tt>, die besagt, welche Datei genau übertragen werden soll. Und am Schluss steht noch ein <tt>-v</tt>. <tt>v</tt> Bedeutet ''"Verbose Output"'' und gibt euch mehr Informationen auf der Konsole aus.
+
  
Mit <tt>make clean</tt> werden alle Object-Dateien etc. gelöscht.
+
Führt man nun <tt>make</tt> aus, passiert folgendes:
 +
Nach dem die Variablen gesetzt sind, wird überprüft ob $(TARGET) &mdash; das ist hier ''blink'' &mdash; existiert.
 +
Wenn nicht will ''make'' es aus $(TARGET).o (''blink.o'') erzeugen. Nun gibt es aber auch $(TARGET).o nicht, aber dank der eingebauten Regeln weiß ''make'' das er das .o aus den zugehörigen .c erzeugen muss, und schon ist der erste Schritt getan.
  
=Fehlermeldungen=
+
Nachdem ihr <tt>make</tt> erfolgreich ausgeführt habt, liegt im Ordner eine Datei mit dem Name ''blink''. Nun kommt Schritt 2. mit <tt>make load</tt> wird die Datei in den Controler gebrannt. Dazu sind 2 Dinge notwendig:
 +
avr-objcopy -j .text -j .data -O ihex blink blink.hex
 +
:Hier wird mit Hilfe des Programms <tt>avr-objcopy</tt> alles überflüssige entfernt und ein Hexfile erzeugt.
 +
avrdude -p t2313 -c avr910 -U flash:w:blink.hex -v
 +
:Hier wird durch <tt>avrdude</tt> das Programm wirklich gebrannt.
 +
;<tt>-p</tt>: gibt an, um welchen MCU es sich handelt
 +
;<tt>-c</tt>: gibt an, um welchen Programmer es sich handelt. Hier könnte z.B <tt>stk500</tt> stehen.
 +
;<tt><nowiki>-U flash:w:$(TARGET).hex</nowiki></tt>: bedeutet einfach, dass das Programm in den Flash geschrieben werden soll. <tt>w</tt> steht für Schreiben, <tt>r</tt> für Lesen und <tt>v</tt> für verify. Dann kommt die Variable <tt>$(TARGET)</tt>, die besagt, welche Datei genau übertragen werden soll.
 +
;<tt>-v</tt>: bedeutet ''"Verbose Output"'' und gibt euch mehr Informationen auf der Konsole aus.
 +
 
 +
Mit <tt>make clean</tt> werden alle überflüssigen Dateien gelöscht.
 +
 
 +
= Fehlermeldungen =
  
 
sollten eigentlich keine vorkommen. Wenn doch, vergewissert euch, dass ihr euch genau an die
 
sollten eigentlich keine vorkommen. Wenn doch, vergewissert euch, dass ihr euch genau an die
Zeile 220: Zeile 199:
  
 
;<tt>Permission denied</tt>: Ihr habt nicht die Rechte, um diesen Befehl auszuführen. Höchswahrscheinlich müsst ihr den Befehl als root ausführen.
 
;<tt>Permission denied</tt>: Ihr habt nicht die Rechte, um diesen Befehl auszuführen. Höchswahrscheinlich müsst ihr den Befehl als root ausführen.
 
;<tt><nowiki>make[2]: avr-ranlib: Command not found</nowiki></tt>:<tt>/usr/local/avr/bin</tt> liegt nicht in <tt>$PATH</tt>. Folgendes Command ausführen:
 
:<pre>export PATH=$PATH:/usr/local/avr/bin</pre>
 
  
 
;<tt>programmer is not responding</tt>: Es kann keine Verbindung zum Programmer aufgenommen werden: Defektes Kabel, Programmer an der falschen Schnittstelle angeschlossen (default: <tt>/dev/ttyS0</tt>), kein Strom am Programmer etc.
 
;<tt>programmer is not responding</tt>: Es kann keine Verbindung zum Programmer aufgenommen werden: Defektes Kabel, Programmer an der falschen Schnittstelle angeschlossen (default: <tt>/dev/ttyS0</tt>), kein Strom am Programmer etc.
  
;<tt><nowiki>can't open device "/dev/ttyS0": Permission denied</nowiki></tt>: Als normaler User darf man auf die Serielle Schnittstelle nicht lesen oder schreiben. Folgenden Befehl als root ausfueren:
+
;<tt><nowiki>can't open device "/dev/ttyS0": Permission denied</nowiki></tt>: Als normaler User darf man auf die serielle Schnittstelle nicht lesen oder schreiben. Folgenden Befehl als root ausführen:
:<pre>chmod 666 /dev/ttyS0[/i]</pre>
+
:<pre>chmod 666 /dev/ttyS0</pre>
 +
:{|
 +
Zweite und bessere Möglichkeit, die Rechte zu ändern ist es, den Benutzer in die tty-Gruppe auzunehmen.
 +
Hier ein Beispiel für Gentoo.
 +
Die Gruppe kann bei anderen Distributionen auch anders heißen!
 +
 
 +
Als root in die Konsole schreiben:
 +
<pre>
 +
> ls -all /dev/ttyS0
 +
crw-rw---- 1 root tty 4, 64 25. Jun 02:12 /dev/ttyS0
 +
>
 +
</pre>
 +
Hier kann man schön erkennen, daß die serielle Schnittstelle dem Benutzer root gehört und die Gruppe <tt>tty</tt> darauf zugreifen darf. Mit einem einfachen
 +
> usermod -a -G tty sebastian
 +
wird der User <tt>sebastian</tt> in die tty-Gruppe aufgenommen.
 +
 
 +
Noch ein Test, ob alles geklappt hat:
 +
<pre>> groups sebastian
 +
tty wheel audio cdrom dialout video games usb users portage scanner
 +
</pre>
 +
Danach muss sich Benutzer <tt>sebastian</tt> neu einlogen und wir sind fertig.
 +
 
 +
Der Vorteil hierbei ist, daß man Rechte für alle Geräte der Gruppe <tt>tty</tt> erlangt, also alle seriellen Schnittstellen sowie [[USB]]&nbsp;&harr;&nbsp;[[RS232]]-Adapter, und man braucht an den eigentlichen Rechten nichts zu verändern.
 +
|}
 +
 
 +
= Weblinks =
 +
*[http://www.nongnu.org/avr-libc/user-manual/install_tools.html ''"Installing the GNU Tool Chain"''] Hilfe zum Build und Installation von GCC, binutils, etc unter Linux
 +
* [http://www.linuxfocus.org/Deutsch/November2004/article352.shtml www.linuxfocus.org (Artikel)] - Tipps zu Build und Installation von avr-gcc, binutils und avr-libc unter Linux
 +
* [http://users.rcn.com/rneswold/avr/ Rich Neswold: ''A GNU Development Environment for the AVR Microcontroller'']
 +
* [http://www.mikrocontroller.net/topic/24166 www.mikrocontroller.net (Foren-Beitrag)] - Installation von GCC und Toolchain unter Mac OS X
 +
 
 +
=Pakete=
 +
==Slackware==
 +
Ein Paket für Slackware ist für Zenwalk erhältlich. Mehr dazu siehe hier:
 +
http://support.zenwalk.org/index.php?topic=14131.
 +
==Debian Pakete==
 +
Die lange Installation kann man sich unter Debian auch leichter machen. Folgende Pakete werden benötigt:
 +
# gcc-avr
 +
# avrdude
 +
# avr-libc
 +
Einfach per APT installieren: "apt-get install gcc-avr", "apt-get install avrdude" und "apt-get install avr-libc".
 +
Das funktioniert natürlich auch bei den ganzen Debian Abkömmlingen(Knoppix, Ubuntu, etc.).
  
 
=Siehe auch=
 
=Siehe auch=
 
* [[avr-gcc]]
 
* [[avr-gcc]]
 +
* [[WinAVR]]
  
 
=Quelle=
 
=Quelle=
[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603]
+
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603 www.roboternetz.de (Foren-Beitrag)] ''avrgcc + avrdude installieren''
  
 
=Autoren=
 
=Autoren=

Aktuelle Version vom 31. Oktober 2011, 16:55 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

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.17.tar.bz2
cd binutils-2.17/
mkdir obj-avr
cd obj-avr
../configure --target=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.1.2.tar.bz2
cd gcc-4.1.2

mkdir obj-avr
cd obj-avr
../configure --target=avr --disable-nls --enable-languages=c --disable-libssp

make
  • Als root:
make install

avr C-library (avr-libc)

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

./configure --build=`./config.guess` --host=avr

make 
  • Als root:
make install


avrdude

tar xzf avrdude-5.3.1.tar.gz
cd avrdude-5.3.1
./configure
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>

ISR (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
 
CFLAGS  =-mmcu=$(MCU) -Wall 
LDFLAGS =-mmcu=$(MCU)

$(TARGET): $(TARGET).o

$(TARGET).hex : $(TARGET)
	 avr-objcopy -j .data -j .text -O ihex $< $@

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

clean:
	rm -f *.o  *.hex $(TARGET)

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

Als ersten Test kann man ohne Gefahr make -n benutzen. Hier wird nur gezeigt was passieren würde.

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

Erklärung

MCU=attiny2313
MCU ist eine Variable mit dem Inhalt attiny2313. Überall, wo jetzte $(MCU) steht, wird der Variabelninhalt benutzt. Genauso funktioniert das auch mit TARGET, CC, LDFLAGS und CFLAGS.

Mit den letzten drei Variablen wird das Verhalten von make verändert. CC bestimmt welcher Compiler verwendet wird (Default:cc). CFLAGS beinflussen das Compilieren, mit -mmcu= wird hier der Prozessortyp gesetzt, -Wall schaltet Warnungen für den avr-gcc ein. LDFLAGS werden dem Linker übergeben und sollten mindestens den Prozessortyp beinnhalten.

Führt man nun make aus, passiert folgendes: Nach dem die Variablen gesetzt sind, wird überprüft ob $(TARGET) — das ist hier blink — existiert. Wenn nicht will make es aus $(TARGET).o (blink.o) erzeugen. Nun gibt es aber auch $(TARGET).o nicht, aber dank der eingebauten Regeln weiß make das er das .o aus den zugehörigen .c erzeugen muss, und schon ist der erste Schritt getan.

Nachdem ihr make erfolgreich ausgeführt habt, liegt im Ordner eine Datei mit dem Name blink. Nun kommt Schritt 2. mit make load wird die Datei in den Controler gebrannt. Dazu sind 2 Dinge notwendig:

avr-objcopy -j .text -j .data -O ihex blink blink.hex
Hier wird mit Hilfe des Programms avr-objcopy alles überflüssige entfernt und ein Hexfile erzeugt.
avrdude -p t2313 -c avr910 -U flash:w:blink.hex -v
Hier wird durch avrdude das Programm wirklich gebrannt.
-p
gibt an, um welchen MCU es sich handelt
-c
gibt 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.
-v
bedeutet "Verbose Output" und gibt euch mehr Informationen auf der Konsole aus.

Mit make clean werden alle überflüssigen Dateien 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.
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 ausführen:
chmod 666 /dev/ttyS0
Zweite und bessere Möglichkeit, die Rechte zu ändern ist es, den Benutzer in die tty-Gruppe auzunehmen. Hier ein Beispiel für Gentoo. Die Gruppe kann bei anderen Distributionen auch anders heißen! Als root in die Konsole schreiben:
> ls -all /dev/ttyS0
crw-rw---- 1 root tty 4, 64 25. Jun 02:12 /dev/ttyS0
>

Hier kann man schön erkennen, daß die serielle Schnittstelle dem Benutzer root gehört und die Gruppe tty darauf zugreifen darf. Mit einem einfachen

> usermod -a -G tty sebastian

wird der User sebastian in die tty-Gruppe aufgenommen.

Noch ein Test, ob alles geklappt hat:

> groups sebastian
tty wheel audio cdrom dialout video games usb users portage scanner

Danach muss sich Benutzer sebastian neu einlogen und wir sind fertig.

Der Vorteil hierbei ist, daß man Rechte für alle Geräte der Gruppe tty erlangt, also alle seriellen Schnittstellen sowie USB ↔ RS232-Adapter, und man braucht an den eigentlichen Rechten nichts zu verändern.

Weblinks

Pakete

Slackware

Ein Paket für Slackware ist für Zenwalk erhältlich. Mehr dazu siehe hier: http://support.zenwalk.org/index.php?topic=14131.

Debian Pakete

Die lange Installation kann man sich unter Debian auch leichter machen. Folgende Pakete werden benötigt:

  1. gcc-avr
  2. avrdude
  3. avr-libc

Einfach per APT installieren: "apt-get install gcc-avr", "apt-get install avrdude" und "apt-get install avr-libc". Das funktioniert natürlich auch bei den ganzen Debian Abkömmlingen(Knoppix, Ubuntu, etc.).

Siehe auch

Quelle

Autoren


LiFePO4 Speicher Test