Diskussion:FIFO mit avr-gcc

2007-04-23T19:34:46Z

Izaseba: habe ich hier ein sei(); übersehen ?

int fifo_get_nowait (fifo_t *b)
Liefert das nächste Byte aus der FIFO als int bzw. -1, falls die FIFO leer ist.

Was machst du, wenn FF gespeichert ist ? oder muß das nur für Text gehen ?
--PicNick 18:16, 4. Mär 2006 (CET)

----

Wenn FF gespeichert ist, wird FF zurück geliefert. Die FIFOs speichern ihre Werte als unsigned. Der return-Wert ist int, mithin ist also <tt>255 != -1</tt>.
Will man ein <tt>char</tt> lesen, dann so:
<pre>
char zeichen;
int value;
if (value = fifo_get_nowait (&fifo), value >= 0)
zeichen = (char) value;
</pre>
bzw. man schreibt <tt>value</tt> direkt nach UDR oder wohin auch immer. --[[Benutzer:SprinterSB|SprinterSB]] 19:04, 4. Mär 2006 (CET)
----
d.h. du verwendest die Bits >8 implizit als Schalter ? naja.
--PicNick 08:59, 5. Mär 2006 (CET)
----
In der FIFO stehen ja nur Werte >= 0. Und der Rückgabewert ist auch immer >= 0, wenn was drinne ist, ansonsten eben <0. Ich erweitere also den Wertebereich. Ausserdem kann auf <0 sehr effizient getestet werden. Wie würdest du es machen? --[[Benutzer:SprinterSB|SprinterSB]] 09:59, 5. Mär 2006 (CET)

----
Mach nur, die Geschmäcker sind halt verschieden, absolute Wahrheiten gibt's nicht. Ich trenne immer Frage und Abholen, wobei die Frage immer non-destruktiv nach der verfügbaren Länge ist.
<pre>
while (fifo_data() >= required_length ) // anzahl im Buffer
{
Uns_16 = fifo_read_short() // oder ähnlich
}
</pre>
Beispiel: Bei IP etc. hab immer 16 Bit als Länge vorn, da lese ich z.B. erst, wenn die auch da sind. Und dann erst weiter, wenn der record komplett ist. Aber für eine Controller-UART etc. ist das vielleicht auch etwas über-drüber.
--PicNick 12:05, 5. Mär 2006 (CET)

Jo, das geht auch. Auf <tt>fifo.count</tt> kann man ja frei zugreifen. Beim nachfolgenden Lesen sind aber evtl. mehr Zeichen im Puffer, was bei den meisten Anwendungen nicht stört. Es sollte nur ein einfaches Grundgerüst sein, das man nach eigenem Gusto erweitern kann, etwa
static inline int fifo_contains_at_least_n_bytes_p (const fifo_t * f, const unsigned char num) { f->count >= num; }

Noch praktischer wäre natürlich eine FIFO, in der man ganze Objekte speichern kann, und nicht nur einzelne Bytes... --[[Benutzer:SprinterSB|SprinterSB]] 22:32, 5. Mär 2006 (CET)
----
*g* Wenn du Objecte auch als solches reinkriegst, is besser, du legst sie gleich als verkettete Liste an. das ist natürlich mit Heap einiges einfacher. Für Controller wird's da aber eng. geht meist eh' nur ums UART-buffern.
--PicNick 07:59, 6. Mär 2006 (CET)

== habe ich hier ein sei(); übersehen ? ==

Hallo Sprinter :-)

Ich analysiere gerade deine FIFO Puffer, klasse !

Nur eine Frage stellt sich noch, hier
<pre>
uint8_t sreg = SREG;
cli();
f->count--;
SREG = sreg;
</pre>

Muß da nicht noch ein sei(); hin<br/>
Oder hab ich da was übersehen ?<br/>
Gruß Sebastian
--[[Benutzer:Izaseba|izaseba]] 21:34, 23. Apr 2007 (CEST)

Avr-gcc und avrdude installieren

2006-06-25T13:52:36Z

Izaseba: /* Fehlermeldungen */

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 [http://www.tldp.org/linuxfocus/English/November2004/article352.shtml].
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 [[Microcontroller|MCU]] erstellt. Im dritten Teil stehen noch ein paar typische Fehlermeldungen und die Lösungen.

=Installation=

Also los. Wir brauchen folgende Software:

* [ftp://ftp.gnu.org/gnu/binutils/ binutils-2.16.1.tar.bz2]
* [ftp://ftp.gnu.org/gnu/gcc/gcc-4.0.2/ gcc-core-4.0.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/avrdude/ 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 <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).

Und so wird's gemacht (Das entpacken kann eine Weile dauern):
<pre>
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
</pre>
* Als root:
make install

==[[avr-gcc]]==

avr-gcc ist unser eigentlicher Compiler. Er installiert sich wie folgt:
<pre>
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
</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:
make install

==avr C-library ([[avr-libc]])==
<pre>
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
</pre>
* Als root:
make install

==[[avrdude]]==

<pre>
tar xzf avrdude-5.0.tar.gz
cd avrdude-5.0
./configure --prefix=/usr/local/avr
make
</pre>
* 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 <tt>/usr/local/avr/etc/avrdude.conf</tt>

Folgende Zeilen müssen ergänzt werden:
<pre>
#------------------------------------------------------------
# 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]
</pre>
Analog verfahren für [[ATmega64]], [[ATmega162]] und [[ATmega169]]. Die devicecodes hiefür sind:
<pre>
m64: avr910_devcode = 0x45;
m162: avr910_devcode = 0x62;
m169: avr910_devcode = 0x78;
</pre>

Wer sich einen eigenen avr910 Programmer bauen will, dem sei diese Seite ans Herz gelegt:
[http://www.klaus-leidinger.de/mp/Mikrocontroller/AVR-Prog/AVR-Programmer.html].
Ich habe die Version genommen und um ein Buffer erweitert. Die Bauanleitung dafür gibt es bald auf [http://www.amee-bot.de unserer Roboterseite].

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

=Beispiel-Projekt=

Hier erstmal ein winziges Beispielprogramm für den [[ATtiny2313]].
<pre>
/*
* 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
}
</pre>
Den Quelltext nehmt ihr und speichert ihn in die Datei <tt>blink.c</tt>.

Jetzt kommt das [[make|Makefile]]. Ich habe schonmal ein einfaches vorbereitet:
<pre>
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
</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!'''

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.

'''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 ausgeführt habt, liegt in dem Ordner die Hexfile und eine Datei mit der Endung <tt> .s</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
;<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 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:

;<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><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:
:<pre>chmod 666 /dev/ttyS0</pre>

Zweite,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>
<sebastian@pegasus ~ $ ls -all /dev/ttyS0
crw-rw---- 1 root tty 4, 64 25. Jun 02:12 /dev/ttyS0
<sebastian@pegasus ~ $
</pre>
Hier kann man schön erkennen, daß die serielle Schnittstelle dem Benutzer root gehört, und die Gruppe tty
darauf zugreifen darf.
Mit einem einfachem
<pre>
pegasus sebastian #usermod -a -G tty sebastian
pegasus sebastian #
</pre>
wird der user sebastian in die tty Gruppe aufgenommen.

Noch ein Test, ob alles geklappt hat:
<pre>pegasus sebastian # groups sebastian
tty wheel audio cdrom dialout video games usb users portage scanner
pegasus sebastian #
</pre>
Jetzt muß sich nur noch der Benutzer sebastian neu einlogen und wir sind fertig.<br>
Der Vorteil hierbei ist, man erlangt rechte für alle Geräte die der Gruppe tty angehören, also alle seriellen Schnittstellen sowie USB <-> Rs232 Adapter, und man braucht an den eigentlichen Rechten nichts zu verändern.

=Siehe auch=
* [[avr-gcc]]

=Quelle=
[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603]

=Autoren=
*[[Benutzer:Kater|Kater]] (Manuscript)
*[[Benutzer:SprinterSB|SprinterSB]] (Transcript und Typo)

[[Kategorie:Grundlagen]]
[[Kategorie:Microcontroller]]
[[Kategorie:Quellcode C]]

RN-Wissen.de - Benutzerbeiträge [de]

Diskussion:FIFO mit avr-gcc

Avr-gcc und avrdude installieren