https://www.mikrocontroller.net/api.php?action=feedcontributions&feedformat=atom&user=MskMikrocontroller.net - Benutzerbeiträge [de]2026-04-11T03:54:11ZBenutzerbeiträgeMediaWiki 1.39.7https://www.mikrocontroller.net/index.php?title=Benutzer:Msk&diff=38151Benutzer:Msk2009-07-31T01:03:43Z<p>Msk: Die Seite wurde neu angelegt: Neu hier und begeisterter ATmega-Frischling. :)</p>
<hr />
<div>Neu hier und begeisterter ATmega-Frischling. :)</div>Mskhttps://www.mikrocontroller.net/index.php?title=AVR-GCC&diff=38150AVR-GCC2009-07-31T01:00:45Z<p>Msk: /* Entwicklungsumgebungen */</p>
<hr />
<div>[[Category:AVR]]<br />
<br />
AVR-GCC ist ein kostenloser [[C]]-Cross-[[Compiler]] für [[AVR]]-[[Mikrocontroller]].<br />
<br />
AVR-GCC kann von der Leistungsfähigkeit her mit kommerziellen [[Compiler]]n gut mithalten. Sogar C++-Programme sind möglich, in der aktuellen Fassung wird C++ jedoch nur eingeschränkt unterstützt (Stand 6/2007).<br />
<br />
== Bestandteile ==<br />
<br />
Die Toolchain (Werkzeugsammlung) besteht aus mehreren Kommandozeilen-Programmen, die sich auf einfache Weise in einen Editor oder eine Entwicklungsumgebung einbinden lassen (typischerweise als Aufrufe von make mit Parameter, vgl. [[AVR-GCC-Tutorial]]). <br />
<br />
Die Bestandteile im einzelnen:<br />
* Binutils: Assembler, Linker und weitere Hilfsprogramme.<br />
* GCC: Der eigentliche C(++)-Compiler.<br />
* AVR-LIBC: Die C-Standardbibliothek mit AVR-spezifischen Headerdateien und Funktionen.<br />
* ([[AVRDUDE]]: universelle AVR-Programmiersoftware, kein eigentlicher Teil der Toolchain, aber oft verwendet)<br />
<br />
== Installation ==<br />
<br />
=== Linux/Unix ===<br />
<br />
Wenn keine aktuelle AVR-GCC-Version als Paket für die verwendete Distribution zur Verfügung steht, dann können sich [[Unix]]/[[Linux]]-Nutzer den Sourcecode herunterladen und selbst kompilieren. Schritt-für-Schritt-Anleitungen gibt es [http://www.nongnu.org/avr-libc/user-manual/install_tools.html hier] und [http://www.roboternetz.de/wissen/index.php/Avr-gcc_und_avrdude_installieren hier]. Empfehlenswert ist auch [http://cdk4avr.sf.net CDK4AVR], das die entsprechenden tools als einfach installierbare Linux-Pakete bereitstellt (distributionsunabhängig als .tar.gz). Leider ist das Projekt schon etwas älter, im [http://www.mikrocontroller.net/topic/130972 Forum] findet sich ein Beitrag, aktuellere Sourcen mit den entsprechenden Patches zu versehen und zu kompilieren. Patches zu den Binutils und GCC Sourcen sind unumgänglich, da die offiziellen Sourcen aufgrund des Umfangs an Prozessortargets den aktuellsten Entwicklungen hinterherhinken und damit bereits bekannte Fehler eventuell noch nicht behoben sind. Weitere Tipps zur AVR Programmierung unter Linux stehen im Artikel [[AVR und Linux]].<br />
<br />
=== Mac OS X ===<br />
Die beste fertige Toolchain ist das [http://www.obdev.at/crosspack/ Crosspack]. Dieses enthält auch die avr-libc, avrdude und avarice. Leider gab es bei Mac OS 10.5.6 eine tiefgreifende Änderung beim fork()-Systemcall, der bewirkt, dass avarice mit JTAGICE mkII und Dragon nicht funktioniert. Geräte mit Serial-USB-Konvertern (AVRISP clones etc) funktionieren dagegen problemlos. <br />
<br />
Wer die Toolchain von Hand bauen möchte kann das natürlich auch tun, dazu einfach den unter "Linux/Unix" verlinkten Anleitungen folgen. Unter [[Mac OS X]] muss man dazu zuerst die [http://developer.apple.com/Tools/ Apple Developer Tools] installieren.<br />
<br />
Teile der Toolchain (avr-libc und avrdude) kann man mit dem Paketsystem [http://www.macports.org/ MacPorts] installieren. Die Compiler-Toolchain kann man dann installieren, indem man folgenden Befehl im Terminal eingibt:<br />
<br />
sudo port install avr-libc<br />
<br />
Das Programmiertool avrdude bekommt man genauso:<br />
<br />
sudo port install avrdude<br />
<br />
Weblinks:<br />
<br />
* [http://tinkerlog.com/2007/09/29/programming-avr-with-a-macbook/ Programming AVR with a MacBook] (engl.)<br />
* [http://www.ladyada.net/library/avrdevtut/setup-mac.html AVR Tutorial from Lady Ada] (engl.)<br />
* [http://www.obdev.at/crosspack/ Crosspack]<br />
* [http://www.digithink.com/OSX-AVR OSX-AVR (nicht mehr aktuell)]<br />
<br />
=== Windows ===<br />
<br />
Für MS-Windows gibt es das fertig kompilierte Softwarepaket [[WinAVR]].<br />
<br />
== Entwicklungsumgebungen ==<br />
<br />
Win32:<br />
* [[AVR-Studio]]: ab Version 4.12 mit WinAVR-Unterstützung, integrierter Simulator, Debugger, rudimentäre Projektverwaltung<br />
* Programmers-Notepad: wird bei [[WinAVR]] mitgeliefert, ein guter Editor mit einer rudimentären Projektverwaltung<br />
* [http://www.myavr.info/download/benutzerhandbuch_sisy_avr.pdf SiSy-AVR]: ein CASE-Tool mit WinAVR-Unterstützung, das eine Entwicklungsumgebung bereitstellt.<br />
<br />
Platformunabhängig:<br />
* [http://www.eclipse.org/ Eclipse] mit CDT und dem [http://avr-eclipse.sourceforge.net/index.html AVR Eclipse Plugin]<br />
* [[Code::Blocks]]: vielseitige, freie Entwicklungsumgebung für Windows und Linux<br />
<br />
== Bibliotheken / Libraries ==<br />
<br />
Die [http://www.nongnu.org/avr-libc/ avr-libc] ist die gebräuchliche "Laufzeitbibliothek" zum avr-gcc C-Compiler, welche den Zugriff auf die AVR-Hardware erheblich erleichtert. Die offizielle Dokumentation zur avr-libc mit vielen Hinweisen auch zum Compiler avr-gcc und verschiedener Tools (z.B. [[AVRDUDE]]) findet man [http://www.nongnu.org/avr-libc/user-manual/index.html hier].<br />
<br />
Auch die [http://hubbard.engr.scu.edu/embedded/avr/avrlib/ Procyon AVRlib] enthält nützlichen Code z.B. für UART, LCD,.... Bei der Procyon AVRlib ist die Lizenz zu beachten (in Kurzform: man muss dritten auf Verlangen den gesamten Quellcode der Firmware zur Verfügung stellen, falls Teile der Procyon Bibliothek genutzt werden).<br />
<br />
Zum Zugriff auf interne Funktionen oder externe Peripherie existieren einige fertige Komponenten. Z.B. "Projects"-Bereich von [http://www.avrfreaks.net/ avrfreaks.net] (Anmeldung erforderlich (kostenlos)). <br />
<br />
Die Erstellung eigener Bibliotheken ist im Artikel [[Libraries]] erklärt.<br />
<br />
== Tipps & Tricks ==<br />
<br />
Eine (hoffentlich wachsende) Liste mit einigen Hinweisen:<br />
<br />
* Keine "antiken" Versionen verwenden. Für MS-Windows-Nutzer: aktuelles WinAVR installieren. Für Linux/Unix-Nutzer: letzte stabile Version selbst kompilieren oder aus "Distribution-Packages" installieren (z.B. [http://cdk4avr.sourceforge.net/ cdk4avr]).<br />
<br />
* Bei Problemen zuerst in die '''[http://www.nongnu.org/avr-libc/user-manual/index.html Anleitung] der avr-libc''' schauen. Insbesondere die FAQ lesen.<br />
<br />
* Sicherstellen, dass der MCU-Parameter (zum Compiler/Linker, meist im Makefile defniert) mit dem Zielprozessor übereinstimmt.<br />
<br />
* [[AVR-GCC-Tutorial]] in diesem Wiki lesen.<br />
<br />
* Im Zweifel '''nicht INTERRUPT(...) sondern SIGNAL(...)''' nutzen. In neueren Versionen der avr-libc wurde '''ISR''' als Ersatz für SIGNAL eingeführt und sollte genutzt werden (SIGNAL und INTERRUPT werden langfristig entfallen). Darauf achten, dass die Vektor- bzw. Signal-Namen ("Parameter") zu ISR bzw. SIGNAL (und INTERRUPT wenn denn unbedingt erforderlich) richtig geschrieben sind. Die Namen sind in der in der entsprechenden Header-Datei (ioxxx.h) für den Controller und der avr-libc-Dokumenation aufgelistet. Im Zweifel den erzeugten Interrupt-Vektor im Assembler-Listing prüfen, es darf '''kein''' SIG_''xxx'' oder xxx_vect mehr zu sehen sein, sondern _vector_''N'' (wobei ''N'' eine Zahl ist). Neuere Versionen der avr-gcc zeigen eine Warnung, falls etwas falsch geschrieben wurde, ältere Versionen nicht.<br />
<br />
* '''Zugriff auf Daten(-Tabellen) im Programmspeicher''' (Flash) erfolgt über Program-Space-Funktionen (pgm_read*). Lediglich die Definition einer Variablen/eines Feldes mit dem PROGMEM Attribut zu versehen, reicht (im Gegensatz zu Codevision, IAR, Imagecraft) nicht aus.<br />
<br />
* Nicht alle AVRs werden vollständig von der avr-libc bzw. dem Compiler unterstützt. Bei Problemen hilft oft ein Blick in den erzeugten Assembler-Code. Die Anzahl der unterstützen Controller steigt jedoch mit Version zu Version von binutils, avr-libc und avrdude. Evtl. reicht einfach ein Update auf neuere Software-Versionen (z.B. im jeweils aktuellen WinAVR-Packet).<br />
<br />
* '''inp(), outp(), sbi() und cbi()''' werden in der aktuellen Bibliotheksversion nicht offiziell unterstützt (man muss eine spezielle Header-Datei einbinden(deprected.h). Es wird schon seit längerem empfohlen, diese Makros nicht mehr zu nutzen. Einige Anleitungen sind in diesem Punkt veraltet. Mit halbwegs aktuellen avr-gcc/avr-libc-Versionen kann einfach z.B. DDRB=0xfe bzw. foo=PINB geschrieben werden. Mit PORTB |= _BV(1) setzt man PORTB.1, mit PORTB &= ~_BV(1) löscht man es wieder, mit PORTB ^= _BV(1) kann man es umschalten (_BV(x) entspricht dabei (1<<x)). Die ersten beiden Varianten erzeugen bei eingeschalteter Optimierung und passenden Parametern (wie hier im Beispiel Register im "unteren" Speicherbereich) die SBI bzw. CBI Prozessorbefehle.<br />
<br />
* Mit dem Tool '''avr-nm''' erhält man eine Übersicht über die Platzausnutzung in der erzeugten ELF-Datei bzw. dem damit gefüllten AVR. Das Tool wird per Kommandozeile mit <tt>avr-nm --size-sort --print-size <name of your ELF file></tt> aufgerufen. Alle Symbole mit einem "T" (globale Funktionen), "t" (statische Funktionen) und letztlich auch mit einem "D" oder "d" (globale bzw. statische Daten, die haben ihre Initialisierungswerte im ROM) betreffen das FLASH-ROM. "B" und "b" brauchen ausschließlich RAM (werden beim Start mit 0 initialisiert). Die erste Spalte ist die Adresse des Symbols, die zweite ist die Größe (beides hexadezimal). (nach [http://www.mikrocontroller.net/topic/59960#467920 Forenbeitrag] von Jörg Wunsch)<br />
<br />
* Mit dem Tool '''avr-size''' erhält man eine Übersicht über den Platzbedarf in den text, data und bss Sektionen innerhalb der ELF Binärdatei. Die Sektionen text und data benötigen Platz im FLASH-ROM und die Sektionen data und bss benötigen zur Laufzeit Platz im SRAM.<br />
<br />
== Siehe auch ==<br />
* [[AVR-GCC-Tutorial]]<br />
* [[AVR-GCC-Codeoptimierung]]<br />
* [[GCC: unbenutzte Funktionen entfernen]]<br />
* [http://www.roboternetz.de/wissen/index.php/Avr-gcc/Interna AVR-GCC Interna]<br />
<br />
== Weblinks ==<br />
* [http://winavr.sourceforge.net/install_config_WinAVR.pdf Tutorial von C. O'Flynn und E. Weddington] Einstieg in die Nutzung des avr-gcc unter MS-Windows mit WinAVR (englisch)<br />
* [http://www.linuxfocus.org/Deutsch/November2004/article352.shtml AVR-GCC und Linux]<br />
* [http://www.mikrocontroller.net/forum/list-2-1.html GCC-Forum auf mikrocontroller.net]</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37992Code::Blocks2009-07-23T20:13:41Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb|Oberfläche von Code::Blocks]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installiertes [http://www.mikrocontroller.net/articles/WinAVR WinAVR].<br />
<br />
Für Windows stellt das Code::Blocks-Projekt regelmäßig Nightly Builds im [http://forums.codeblocks.org/ Forum] des Projektes zur Verfügung. <br />
<br />
Ein Nightly Build ist nach folgender Vorgehensweise zu installieren:<br />
<br />
# Herunterladen des Progammpakets <tt>CB_XXXXXXX_revXXXX_win32.7z</tt> und Entpacken in das Zielverzeichnis.<br />
# Herunterladen der zur Verfügung gestellten wxWidgets-DLL (<tt>wxmswXXu_gcc_cb_wxXXXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
# Herunterladen der zur Verfügung gestellten MinGW-DLL (<tt>mingwmXX_gccXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
<br />
Hinweis: Die "<tt>X</tt>" in den Paketnamen stehen für die jeweiligen Versionsnummern und sind abhängig von der konkreten Build-Version.<br />
<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
Eine Abbildung des Dialogs befindet sich im Abschnitt "Installation unter Linux".<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installierter [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc].<br />
<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
<tt>svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk</tt><br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD". Entsprechend sind in einer Konsole folgende Befehle einzugeben:<br />
<br />
<tt>./bootstrap</tt><br />
<br />
<tt>./configure --with-contrib-plugins=all</tt><br />
<br />
<tt>make</tt><br />
<br />
<tt>sudo make install</tt><br />
<br />
Der letzte Befehl startet die Installation des Programms in die entsprechenden Verzeichnisse. Da hierfür root-Rechte erforderlich sind, wird dieses Kommando per <tt>sudo</tt> aufgerufen. Hierfür ist das root-Passwort erforderlich.<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb|Dialog für Compiler-Einstellungen]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
<br />
<br />
== Erstellung eines AVR-Projekts ==<br />
<br />
Die Erstellung eines AVR-Projektes ist sehr einfach:<br />
<br />
# Starten des Dialogs zum Anlegen eines neuen Projektes mittels <tt>File->New->Project...</tt><br />
# Auswahl des Punktes "AVR Project" und Klick auf "Go". Die Vielzahl an verfügbaren Projekttypen kann vom Nutzer durch die Auswahl der Kategorie (oben im Dialog, hier "Embedded Systems") eingeschränkt werden.<br />
# Überspringen der Begrüßungsseite.<br />
# Im folgenden Dialog sind der Name des Projektes und der Pfad des Projektverzeichnisses anzugeben. Der Dialog zeigt in der letzten Zeile den resultierenden Pfad an.<br />
# Die Einstellung der Ausgabe-Verzeichnisse für Release- und Debug-Konfigurationen sind im nächsten Dialog anzugeben.<br />
# Im darauf folgenden Dialog sind vom Nutzer die Prozessor-spezifischen Einstellungen vorzunehmen. Damit wird die Erstellung eines neuen Projektes abgeschlossen. Insbesondere der Typ und die Taktrate sind hier anzugeben. Spätere Änderungen sind auch noch in den "Project Build Options" möglich.<br />
<br />
Die mit dieser Entwicklungsumgebung erzeugten Programme bzw. .hex-Dateien können dann mittels [http://www.mikrocontroller.net/articles/AVRDUDE AVRDude] bzw. mit Hilfe der grafischen Oberfläche [http://www.mikrocontroller.net/articles/Burn-o-mat AVR-Burn-o_mat] für AVRDude auf den Controller geflasht werden.</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37763Code::Blocks2009-07-13T20:21:05Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb|Oberfläche von Code::Blocks]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installiertes [http://www.mikrocontroller.net/articles/WinAVR WinAVR].<br />
<br />
Für Windows stellt das Code::Blocks-Projekt regelmäßig Nightly Builds im [http://forums.codeblocks.org/ Forum] des Projektes zur Verfügung. <br />
<br />
Ein Nightly Build ist nach folgender Vorgehensweise zu installieren:<br />
<br />
# Herunterladen des Progammpakets <tt>CB_XXXXXXX_revXXXX_win32.7z</tt> und Entpacken in das Zielverzeichnis.<br />
# Herunterladen der zur Verfügung gestellten wxWidgets-DLL (<tt>wxmswXXu_gcc_cb_wxXXXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
# Herunterladen der zur Verfügung gestellten MinGW-DLL (<tt>mingwmXX_gccXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
<br />
Hinweis: Die "<tt>X</tt>" in den Paketnamen stehen für die jeweiligen Versionsnummern und sind abhängig von der konkreten Build-Version.<br />
<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
Eine Abbildung des Dialogs befindet sich im Abschnitt "Installation unter Linux".<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installierter [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc].<br />
<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
<tt>svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk</tt><br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD". Entsprechend sind in einer Konsole folgende Befehle einzugeben:<br />
<br />
<tt>./bootstrap</tt><br />
<br />
<tt>./configure</tt><br />
<br />
<tt>make</tt><br />
<br />
<tt>sudo make install</tt><br />
<br />
Der letzte Befehl startet die Installation des Programms in die entsprechenden Verzeichnisse. Da hierfür root-Rechte erforderlich sind, wird dieses Kommando per <tt>sudo</tt> aufgerufen. Hierfür ist das root-Passwort erforderlich.<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb|Dialog für Compiler-Einstellungen]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
<br />
<br />
== Erstellung eines AVR-Projekts ==<br />
<br />
Die Erstellung eines AVR-Projektes ist sehr einfach:<br />
<br />
# Starten des Dialogs zum Anlegen eines neuen Projektes mittels <tt>File->New->Project...</tt><br />
# Auswahl des Punktes "AVR Project" und Klick auf "Go". Die Vielzahl an verfügbaren Projekttypen kann vom Nutzer durch die Auswahl der Kategorie (oben im Dialog, hier "Embedded Systems") eingeschränkt werden.<br />
# Überspringen der Begrüßungsseite.<br />
# Im folgenden Dialog sind der Name des Projektes und der Pfad des Projektverzeichnisses anzugeben. Der Dialog zeigt in der letzten Zeile den resultierenden Pfad an.<br />
# Die Einstellung der Ausgabe-Verzeichnisse für Release- und Debug-Konfigurationen sind im nächsten Dialog anzugeben.<br />
# Im darauf folgenden Dialog sind vom Nutzer die Prozessor-spezifischen Einstellungen vorzunehmen. Damit wird die Erstellung eines neuen Projektes abgeschlossen. Insbesondere der Typ und die Taktrate sind hier anzugeben. Spätere Änderungen sind auch noch in den "Project Build Options" möglich.<br />
<br />
Die mit dieser Entwicklungsumgebung erzeugten Programme bzw. .hex-Dateien können dann mittels [http://www.mikrocontroller.net/articles/AVRDUDE AVRDude] bzw. mit Hilfe der grafischen Oberfläche [http://www.mikrocontroller.net/articles/Burn-o-mat AVR-Burn-o_mat] für AVRDude auf den Controller geflasht werden.</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37762Code::Blocks2009-07-13T20:16:04Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb|Oberfläche von Code::Blocks]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installiertes [http://www.mikrocontroller.net/articles/WinAVR WinAVR].<br />
<br />
Für Windows stellt das Code::Blocks-Projekt regelmäßig Nightly Builds im [http://forums.codeblocks.org/ Forum] des Projektes zur Verfügung. <br />
<br />
Ein Nightly Build ist nach folgender Vorgehensweise zu installieren:<br />
<br />
# Herunterladen des Progammpakets <tt>CB_XXXXXXX_revXXXX_win32.7z</tt> und Entpacken in das Zielverzeichnis.<br />
# Herunterladen der zur Verfügung gestellten wxWidgets-DLL (<tt>wxmswXXu_gcc_cb_wxXXXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
# Herunterladen der zur Verfügung gestellten MinGW-DLL (<tt>mingwmXX_gccXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
<br />
Hinweis: Die "<tt>X</tt>" in den Paketnamen stehen für die jeweiligen Versionsnummern und sind abhängig von der konkreten Build-Version.<br />
<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
Eine Abbildung des Dialogs befindet sich im Abschnitt "Installation unter Linux".<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installierter [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc].<br />
<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
<tt>svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk</tt><br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD". Entsprechend sind in einer Konsole folgende Befehle einzugeben:<br />
<br />
<tt>./bootstrap</tt><br />
<br />
<tt>./configure</tt><br />
<br />
<tt>make</tt><br />
<br />
<tt>sudo make install</tt><br />
<br />
Der letzte Befehl startet die Installation des Programms in die entsprechenden Verzeichnisse. Da hierfür root-Rechte erforderlich sind, wird dieses Kommando per <tt>sudo</tt> aufgerufen. Hierfür ist das root-Passwort erforderlich.<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb|Dialog für Compiler-Einstellungen]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
<br />
<br />
== Erstellung eines AVR-Projekts ==<br />
<br />
Die Erstellung eines AVR-Projektes ist sehr einfach:<br />
<br />
# Starten des Dialogs zum Anlegen eines neuen Projektes mittels <tt>File->New->Project...</tt><br />
# Auswahl des Punktes "AVR Project" und Klick auf "Go". Die Vielzahl an verfügbaren Projekttypen kann vom Nutzer durch die Auswahl der Kategorie (oben im Dialog, hier "Embedded Systems") eingeschränkt werden.<br />
# Überspringen der Begrüßungsseite.<br />
# Im folgenden Dialog sind der Name des Projektes und der Pfad des Projektverzeichnisses anzugeben. Der Dialog zeigt in der letzten Zeile den resultierenden Pfad an.<br />
# Die Einstellung der Ausgabe-Verzeichnisse für Release- und Debug-Konfigurationen sind im nächsten Dialog anzugeben.<br />
# Im darauf folgenden Dialog sind vom Nutzer die Prozessor-spezifischen Einstellungen vorzunehmen. Damit wird die Erstellung eines neuen Projektes abgeschlossen. Insbesondere der Typ und die Taktrate sind hier anzugeben. Spätere Änderungen sind auch noch in den "Project Build Options" möglich.</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37761Code::Blocks2009-07-13T20:14:49Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb|Oberfläche von Code::Blocks]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installiertes [http://www.mikrocontroller.net/articles/WinAVR WinAVR].<br />
<br />
Für Windows stellt das Code::Blocks-Projekt regelmäßig Nightly Builds im [http://forums.codeblocks.org/ Forum] des Projektes zur Verfügung. <br />
<br />
Ein Nightly Build ist nach folgender Vorgehensweise zu installieren:<br />
<br />
# Herunterladen des Progammpakets <tt>CB_XXXXXXX_revXXXX_win32.7z</tt> und Entpacken in das Zielverzeichnis.<br />
# Herunterladen der zur Verfügung gestellten wxWidgets-DLL (<tt>wxmswXXu_gcc_cb_wxXXXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
# Herunterladen der zur Verfügung gestellten MinGW-DLL (<tt>mingwmXX_gccXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
<br />
Hinweis: Die "<tt>X</tt>" in den Paketnamen stehen für die jeweiligen Versionsnummern und sind abhängig von der konkreten Build-Version.<br />
<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
Eine Abbildung des Dialogs befindet sich im Abschnitt "Installation unter Linux".<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installierter [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc].<br />
<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
<tt>svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk</tt><br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD". Entsprechend sind in einer Konsole folgende Befehle einzugeben:<br />
<br />
<tt>./bootstrap</tt><br />
<br />
<tt>./configure</tt><br />
<br />
<tt>make</tt><br />
<br />
<tt>sudo make install</tt><br />
<br />
Der letzte Befehl startet die Installation des Programms in die entsprechenden Verzeichnisse. Da hierfür root-Rechte erforderlich sind, wird dieses Kommando per <tt>sudo</tt> aufgerufen. Hierfür ist das root-Passwort erforderlich.<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb|Dialog für Compiler-Einstellungen]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
<br />
<br />
== Erstellung eines AVR-Projekts ==<br />
<br />
Die Erstellung eines AVR-Projektes ist sehr einfach:<br />
<br />
# Starten des Dialogs zum Anlegen eines neuen Projektes mittels <<tt>>File->New->Project...</tt><br />
# Auswahl des Punktes "AVR Project" und Klick auf "Go". Die Vielzahl an verfügbaren Projekttypen kann vom Nutzer durch die Auswahl der Kategorie (oben im Dialog, hier "Embedded Systems") eingeschränkt werden.<br />
# Überspringen der Begrüßungsseite.<br />
# Im folgenden Dialog sind der Name des Projektes und der Pfad des Projektverzeichnisses anzugeben. Der Dialog zeigt in der letzten Zeile den resultierenden Pfad an.<br />
# Die Einstellung der Ausgabe-Verzeichnisse für Release- und Debug-Konfigurationen sind im nächsten Dialog anzugeben.<br />
# Im darauf folgenden Dialog sind vom Nutzer die Prozessor-spezifischen Einstellungen vorzunehmen. Damit wird die Erstellung eines neuen Projektes abgeschlossen. Insbesondere der Typ und die Taktrate sind hier anzugeben. Spätere Änderungen sind auch noch in den "Project Build Options" möglich.</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37760Code::Blocks2009-07-13T20:01:05Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb|Oberfläche von Code::Blocks]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installiertes [http://www.mikrocontroller.net/articles/WinAVR WinAVR].<br />
<br />
Für Windows stellt das Code::Blocks-Projekt regelmäßig Nightly Builds im [http://forums.codeblocks.org/ Forum] des Projektes zur Verfügung. Diese sind in der Regel stabil und wesentlich aktueller als das offizielle Release. Es ist empfehlenswert, ein solches Nightly Build zu installieren.<br />
<br />
Ein Nightly Build ist nach folgender Vorgehensweise zu installieren:<br />
<br />
# Herunterladen des Progammpakets <tt>CB_XXXXXXX_revXXXX_win32.7z</tt> und Entpacken in das Zielverzeichnis.<br />
# Herunterladen der zur Verfügung gestellten wxWidgets-DLL (<tt>wxmswXXu_gcc_cb_wxXXXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
# Herunterladen der zur Verfügung gestellten MinGW-DLL (<tt>mingwmXX_gccXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
<br />
Hinweis: Die "<tt>X</tt>" in den Paketnamen stehen für die jeweiligen Versionsnummern und sind abhängig von der konkreten Build-Version.<br />
<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
Eine Abbildung des Dialogs befindet sich im Abschnitt "Installation unter Linux".<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installierter [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc].<br />
<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
<tt>svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk</tt><br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD". Entsprechend sind in einer Konsole folgende Befehle einzugeben:<br />
<br />
<tt>./bootstrap</tt><br />
<br />
<tt>./configure</tt><br />
<br />
<tt>make</tt><br />
<br />
<tt>sudo make install</tt><br />
<br />
Der letzte Befehl startet die Installation des Programms in die entsprechenden Verzeichnisse. Da hierfür root-Rechte erforderlich sind, wird dieses Kommando per <tt>sudo</tt> aufgerufen. Hierfür ist das root-Passwort erforderlich.<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb|Dialog für Compiler-Einstellungen]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
<br />
<br />
== Erstellung eines AVR-Projekts ==</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37759Code::Blocks2009-07-13T19:54:26Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb|Oberfläche von Code::Blocks]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
Voraussetzung für eine Nutzung von Code::Blocks für AVR-Projekte ist ein installiertes [http://www.mikrocontroller.net/articles/WinAVR WinAVR].<br />
<br />
Für Windows stellt das Code::Blocks-Projekt regelmäßig Nightly Builds im [http://forums.codeblocks.org/ Forum] des Projektes zur Verfügung. Diese sind in der Regel stabil und wesentlich aktueller als das offizielle Release. Es ist empfehlenswert, ein solches Nightly Build zu installieren.<br />
<br />
Ein Nightly Build ist nach folgender Vorgehensweise zu installieren:<br />
<br />
# Herunterladen des Progammpakets <tt>CB_XXXXXXX_revXXXX_win32.7z<</tt> und Entpacken in das Zielverzeichnis.<br />
# Herunterladen der zur Verfügung gestellten wxWidgets-DLL (<tt>wxmswXXu_gcc_cb_wxXXXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
# Herunterladen der zur Verfügung gestellten MinGW-DLL (<tt>mingwmXX_gccXX.7z</tt>) für Code::Blocks. Nach dem Entpacken ist die DLL direkt in das Programmverzeichnis von Code::Blocks zu kopieren.<br />
<br />
Hinweis: Die "<tt>X</tt>" in den Paketnamen stehen für die jeweiligen Versionsnummern und sind abhängig von der konkreten Build-Version.<br />
<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.<br />
Eine Abbildung des Dialogs befindet sich im Abschnitt "Installation unter Linux".<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Es wird davon ausgegangen, dass der [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc] bereits installiert ist.<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk<br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD". Entsprechend sind in einer Konsole folgende Befehle einzugeben:<br />
<br />
<tt>./bootstrap</tt><br />
<br />
<tt>./configure</tt><br />
<br />
<tt>make</tt><br />
<br />
<tt>sudo make install</tt><br />
<br />
Der letzte Befehl startet die Installation des Programms in die entsprechenden Verzeichnisse. Da hierfür root-Rechte erforderlich sind, wird dieses Kommando per <tt>sudo</tt> aufgerufen. Hierfür ist das root-Passwort erforderlich.<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb|Dialog für Compiler-Einstellungen]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.</div>Mskhttps://www.mikrocontroller.net/index.php?title=AVR-Tutorial:_Equipment&diff=37757AVR-Tutorial: Equipment2009-07-13T18:34:57Z<p>Msk: /* C */</p>
<hr />
<div>= AVR-Tutorial - Benötigte Ausrüstung =<br />
==Hardware==<br />
<br />
Ein Mikrocontroller alleine ist noch zu nichts nützlich. Damit man etwas damit anfangen kann, braucht man eine Schaltung, in die der Controller eingesetzt wird. Dazu werden bei Elektronikhändlern Platinen angeboten, die alles nötige (Taster, LEDs, Steckverbinder...) enthalten. Häufig enthalten diese Platinen nicht nur Platz für den Mikroprozessor, sondern auch einen ISP-Programmierer (Näheres dazu später).<br />
<br />
=== Fertige Evaluations-Boards und Starterkits ===<br />
<br />
==== AVR Starterkit aus dem Mikrocontroller.net-Shop ====<br />
<br />
Sehr gut für dieses Tutorial geeignet ist das [http://shop.mikrocontroller.net/?product_id=67 AVR-Starterkit aus dem Mikrocontroller.net-Shop]. Das Kit enthält eine Platine mit dem Controller ATmega8, einen USB-ISP-Programmieradapter und ein Steckernetzteil.<br />
<br />
==== STK500 ====<br />
[[Bild:Stk500.jpg|right]]<br />
Das STK500 ist das Standard-Board für AVR Entwicklung, direkt von Atmel. Es enthält auch einen ISP-Programmer und ist fertig aufgebaut. Es ist unter Entwicklern sehr beliebt und wird natürlich von Atmel unterstützt. Es gilt allgemein als gute Investition, wenn man ernsthaft in das Thema einsteigen möchte.<br />
<br />
Das STK500 kostet bei Reichelt ca. 80 Euro.<br />
<br />
==== Pollin Eval.-Board v2.x ====<br />
<br />
Bei Pollin Elektronik gibt es für 15 Euro ein Evaluation Board zum Selbstlöten (mit Platine und Bauteilen, aber ohne Mikrocontroller). Auch dieses Board enthält einen ISP-Programmer, allerdings der einfacheren Sorte. Im Vergleich zum STK500 ist das Board recht unflexibel und hat weniger Features. Die Beschreibung zum Zusammenlöten des Boards ist ausreichend, zur Benutzung des Boards erfährt man außer dem Schaltplan praktisch nichts. Der Schaltplan und dieses AVR-Tutorial zusammen sind allerdings ausreichend. <br />
<br />
Siehe: [http://www.pollin.de http://www.pollin.de]<br />
<br />
==== Pollin Funk-AVR-Evaluationsboard v1.x ====<br />
<br />
Bei diesem Board besteht die Möglichkeit, Funkmodule wie das [[RFM12]], RFM01 oder RFM02 auf dem Board aufzulöten.<br />
<br />
Siehe: <br />
* [[Pollin Funk-AVR-Evaluationsboard]]<br />
* [http://www.pollin.de http://www.pollin.de]<br />
<br />
==== ATmega8-Entwicklungsplatine ====<br />
<br />
Eine weitere Möglichkeit ist die [http://shop.mikrocontroller.net/?product_id=43 ATmega8-Entwicklungsplatine von shop.mikrocontroller.net]. Diese enthält eine Fassung für den Controller, einen Spannungswandler, die Beschaltung für die serielle Schnittstelle und einen Anschluss für den Programmieradapter. Die restliche Hardware wie LEDs und Taster kann man sich selber nach Belieben auf das Lochrasterfeld löten.<br />
<br />
==== Andere ====<br />
<br />
Das Angebot an AVR-Evaluationboards, -Experimentierplatinen, -Entwicklerplatinen oder wie die jeweiligen Hersteller ihre Produkte auch immer bezeichnen, ist mittlerweile recht groß geworden. Sie alle zu bewerten ist unmöglich geworden.<br />
<br />
===Selbstbau===<br />
<br />
Ein fertiges Board ist gar nicht nötig, man kann die benötigte Schaltung auch selbst auf einem kleinen Steckbrett oder einer Lochrasterplatine aufbauen. So kompliziert wie das STK500 wird es nicht, es reichen eine Hand voll Bauteile. Wie man das macht wird im Folgenden beschrieben.<br />
<br />
Die folgende Schaltung baut man am besten auf einem '''Breadboard''' (Steckbrett) auf. Solche Breadboards gibt's z.B. bei [http://www.reichelt.de Reichelt], [http://www.conelek.com/Steckplatinen ConeleK], [http://www.elv.de/ ELV] oder [http://www.conrad.de/ Conrad]. <br />
<br />
[[Bild:Avr-schaltplan-1.gif]]<br />
<br />
Über den Takteingang '''XTAL1''' ist der Mikrocontroller mit dem '''Quarzoszillator''' verbunden, der den benötigten Takt von 4 MHz liefert (siehe unten). Achtung: die Pins werden, wenn man den Oszillator mit der Schrift nach oben vor sich liegen hat, von unten links aus abgezählt. Unten links ist Pin 1, unten rechts Pin 7, oben rechts Pin 8 und oben links Pin 14 (natürlich hat der Oszillator nur 4 Pins. Die Nummerierung kommt daher, dass bei einem normalen IC dieser Größe an den gleichen Positionen die Pins Nr. 1, 7, 8 und 14 wären). <br />
<br />
'''PD0-PD7''' und '''PB0-PB5''' sind die '''IO-Ports''' des Mikrocontrollers. Hier können Bauteile wie LEDs, Taster oder LCDs angeschlossen werden.<br />
Der '''Port C (PC0-PC5)''' spielt beim Atmega8/AT90S4433 eine Sonderrolle: mit diesem Port können Analog-Spannungen gemessen werden. Aber dazu später mehr!<br />
An '''Pin 17-19''' ist die Stiftleiste zur Verbindung mit dem ISP-Programmer angeschlossen, über den der AVR vom PC programmiert wird (Achtung: PINs in Abbildung entsprechen nicht der Belegung des AVRISP mkII. Die korrekte Pin-Belegung kann im Handbuch des AVRISP mkII eingesehen werden).<br />
Die Resetschaltung, bestehend aus '''R1''' und '''C1''', sorgt dafür, dass der Reseteingang des Controllers standardmäßig auf Vcc=5V liegt.<br />
Zum Programmieren zieht der ISP-Adapter die Resetleitung auf Masse (GND), die Programmausführung wird dadurch unterbrochen und der interne Speicher des Controllers kann neu programmiert werden.<br />
Zwischen Vcc und GND kommt noch ein 100nF Keramik- oder Folienkondensator, um Störungen in der Versorgungsspannung zu unterdrücken. Dieser [[Abblockkondensator]] sollte so nah wie möglich am Controller plaziert werden.<br />
<br />
Hier die Liste der benötigten Bauteile: <br />
<br />
* R1 Widerstand 10 kOhm<br />
* C1 Keramikkondensator 47 nF<br />
* C2 Keramik- oder Folienkondensator 100 nF<br />
* Stiftleiste 6-polig<br />
* Mikrocontroller ATmega8 oder AT90S4433 (kann auf [http://shop.mikrocontroller.net/ http://shop.mikrocontroller.net/] bestellt werden)<br />
* Quarzoszillator 4 MHz<br />
<br />
Beim Breadboard ist darauf zu achten, dass man die parallel laufenden Schienen für GND (blau) und Vcc (rot) jeweils mit Drähten verbindet (nicht Vcc und GND miteinander!).<br />
<br />
Eine Zusammenstellung der benötigten Bauteile befindet sich in der [[AVR-Tutorial_Bestellliste|Bestellliste]].<br />
<br />
<div style="border: 1px solid grey; padding: 1ex; font-size: 90%;"><br />
<br />
===Ergänzende Hinweise zur Taktversorgung (kann übersprungen werden) ===<br />
<br />
Ein Mikrocontroller benötigt, wie jeder Computer, eine Taktversorgung. Der Takt ist notwendig, um die internen Abläufe im Prozessor in einer geordneten Reihenfolge ausführen zu können. Die Frequenz des Taktes bestimmt im Wesentlichen, wie schnell ein Computer arbeitet.<br />
<br />
Bei einem ATMega8 gibt es 2 Möglichkeiten zur Taktversorgung<br />
* interner Takt<br />
* externer Takt<br />
<br />
====interner Takt====<br />
Dies ist der Auslieferungszustand bei einem Mega8. Dabei wird der Takt von einem internen Schwingkreis geliefert.<br />
<br />
'''Vorteil''': Keine externe Beschaltung notwendig. Die Pins, an denen ansonsten ein Quarz oder ein Quarzoszillator angeschlossen wird, sind daher als normale Portpins für Ein/Ausgaben verwendbar.<br />
<br />
'''Nachteil''': Der Schwingkreis ist nicht sehr genau. Bei Temperaturänderungen verändert er seine Frequenz. Nur 4 Frequenzen (1MHz, 2MHz, 4MHz und 8MHz) sind bei einem Mega8 realisierbar. Es gibt zwar die Möglichkeit, die interne Frequenz in Grenzen noch zu verändern, dies ist aber aufwändig und erfordert mindestens einen Frequenzzähler, wenn man eine bestimmte Frequenz erreichen will.<br />
<br />
====externer Takt====<br />
Hier gibt es diesmal drei Möglichkeiten:<br />
* Quarz<br />
* Quarzoszillator<br />
* Keramikschwinger/Resonator<br />
<br />
'''Vorteil''': Die Taktfrequenz ist so stabil, wie es der Quarz, Oszillator oder Keramikschwinger vorgibt. Und das ist wesentlich genauer als der interne Oszillator. Kein Abgleich notwendig, wenn eine bestimmte Frequenz erreicht werden soll, solange es einen Quarz bzw. Oszillator oder Keramikschwinger in dieser Frequenz gibt.<br />
Ein spezieller Vorteil des Keramikschwingers ist, dass dieser keine Kondensatoren nach Masse braucht, weil er die schon eingebaut hat.<br />
Es muss lediglich ein dritter Pin mit Masse verbunden werden.<br />
<br />
'''Nachteil''': Die Pins an denen der Quarz bzw. Oszillator oder Keramikschwinger angeschlossen wird, sind nicht mehr als I/O Pins nutzbar.<br />
<br />
Spätestens dann, wenn eine RS232-Verbindung zu einem anderen Computer aufgebaut werden soll, ist eine exakte Taktversorgung einer der Schlüssel, um diese Verbindung auch stabil halten zu können. Aus diesem Grund wird in diesem Tutorial von vorne herein mit einem externen Takt gearbeitet. Es spielt dabei keine Rolle, ob dafür ein Quarzoszillator, ein Quarz oder ein Keramikschwinger benutzt wird.<br />
<br />
<font color="FF0000">Achtung: Ein ATMega8 wird mit aktiviertem internen Takt ausgeliefert. Um einen Quarzoszillator oder einen Quarz zu aktivieren, müssen die Fuse-Bits des Prozessors verändert werden. Details dazu finden sich [[AVR_Fuses|hier]].</font><br />
<br />
==== Quarz statt Quarzoszillator ====<br />
<br />
Wird anstelle eines Quarzoszillators ein Quarz eingesetzt, so sieht die Anbindung des Quarzes so aus:<br />
<br />
[[Bild:tutorial-quarz-schaltplan.png|center|framed| Quarz Standardbeschaltung]]<br />
<br />
Die beiden Kondensatoren '''C3''' und '''C4''' sind zum Betrieb des Quarzes notwendig. Ihre Größe ist abhängig von den Daten des Quarzes. 22pF sind ein Wert, der bei den meisten Quarzen funktionieren sollte.<br />
<br />
==== Keramikschwinger/Resonator- statt Quarz/Oszillator ====<br />
<br />
Wird anstelle eines Quarz/Oszillators ein Keramikschwinger eingesetzt, so sieht die Anbindung des Keramikschwingers so aus:<br />
<br />
[[Bild:Resonator.png|framed|center| Resonator Standardbeschaltung]]<br />
<br />
Es werden keine Kondensatoren benötigt, daher ist der Anschluss eines Keramikschwingers kinderleicht.<br />
<br />
=== Stromversorgung ===<br />
<br />
Die Versorgungsspannung '''Vcc''' beträgt 5V und kann z.B. mit folgender Schaltung erzeugt werden:<br />
<br />
[[Bild:V_Regler.gif|framed|center|Standard Netzteil Beschaltung eines 7805]]<br />
<br />
Bauteile:<br />
* IC1: 5V-Spannungsregler 7805<br />
* C1: Elko 10µF (Polung beachten!)<br />
* C2,C3: 2x Kondensator 100nF (kein Elektrolyt)<br />
* D1: Diode 1N4001<br />
<br />
Die beiden 100nF Kondensatoren haben die Aufgabe, eine mögliche Schwingneigung des 7805 zu unterdrücken. Sie müssen so nahe wie möglich an den Anschlusspins des 7805 angeschlossen werden, um ihre Wirkung zu entfalten.<br />
<br />
An den Eingang (+ und - im Schaltplan) wird ein Steckernetzteil mit einer Spannung von 9 - 12V angeschlossen. Der 7805 benötigt an seinem Eingang eine Gleichspannung die mindestens 8V beträgt. Mit einem 6V oder 7V Netzteil wird der 7805 keine stabilen 5V erzeugen können. Auf der anderen Seite macht es auch keinen Sinn, wesentlich über 12V Eingangsspannung hinauszugehen. Der 7805 ist ein Linearregler. Salopp gesagt, wird die überschüssige Spannung in Form von Wärme vernichtet. Liegt die Eingangsspannung weit über 12V, so wird schon wesentlich mehr Energie in Form von Wärme umgesetzt, als am Ausgang entnommen werden kann. Mal ganz davon abgesehen, dass der 7805 davon brennheiß werden wird.<br />
<br />
Eine Stromversorgung mit Batterien ist grundsätzlich auch möglich, wenn die elektrischen Grenzdaten des µC eingehalten werden (max. Spannung, min. Spannung). Bei der geregelten Stromversorgung oben sollte die Batteriespannung ca. 1.5 - 2.5V (Dropout-Spannung des Linearreglers) größer sein als die Versorgungsspannung des µC. Die [[Versorgung aus einer Zelle]] ist ein Thema für Fortgeschrittene.<br />
<br />
=== Der ISP-Programmierer (In-System-Programmer)===<br />
<br />
[[Bild:Mikrocontroller.gif|framed|right|ISP Programmierer]]<br />
Dann braucht man nur noch den '''ISP-Programmieradapter''', über den man die Programme vom PC in den Controller übertragen kann. Eine Übersicht über mögliche ISP-Programmer Varianten findet sich im Artikel [[AVR_In_System_Programmer]].<br />
<br />
Fertige ISP-Programmer zum Anschluss an den Parallelport oder USB gibt es z.B. auf http://shop.mikrocontroller.net/. <br />
<br />
Eine Bauanleitung gibt es u.a. auf [http://rumil.de/hardware/avrisp.html http://rumil.de/hardware/avrisp.html].<br />
<br />
Den ISP-Adapter schließt man an den Parallelport an und verbindet ihn mit der Stiftleiste SV1 über ein 6-adriges Kabel (siehe Schaltplan).<br />
<br />
=== Sonstiges ===<br />
<br />
Wer vorausschauend kauft, kauft mehr als einen Mikrocontroller. Bis der erste Controller defekt ist oder man durch Austauschen sicher gehen möchte, ob der Fehler im Programm oder im Controller ist, vergeht nur wenig Zeit.<br />
<br />
Für die anderen Teile des Tutorials sollte man sich noch die folgenden Bauteile besorgen: <br />
<br />
---------------------------<br />
Teil 2 (I/O-Grundlagen)<br />
* 5 LEDs 5mm<br />
* 5 Taster<br />
* 5 Widerstände 1k<br />
* 5 Widerstände 10k<br />
<br />
---------------------------<br />
Teil 6 (LC-Display)<br />
* 1 Potentiometer 10k<br />
* 1 HD44780-kompatibles LCD, z.B. 4x20 oder 2x16 Zeichen<br />
<br />
---------------------------<br />
Teil 10 (Der UART)<br />
* 1 Pegelwandler MAX232, MAX232'''A''' oder MAX202<br />
* 5 Kondensatoren<br />
** Bei einem MAX232: je 1µF Elektrolytkondensator<br />
** Bei einem MAX202 oder MAX232'''A''': je 100nF Keramik- oder Elektrolytkondensator<br />
:Die Kondensatoren dürfen auch größer sein. Ist man sich nicht sicher, welchen MAX232 man hat (A oder nicht A), dann die größeren Kondensatoren 1µF nehmen, die funktionieren auch beim MAX232A oder MAX202.<br />
* 1 9-polige SUBD-Buchse (female)<br />
* 1 dazu passendes Modem(nicht Nullmodem!)-Kabel<br />
<br />
---------------------------<br />
Teil 14 (ADC)<br />
* 1 Kondensator 100n<br />
* 1 Potentiometer 10k<br />
* nach Lust und Laune temperatur- oder lichtabhängige Widerstände und jeweils einen Widerstand in der gleichen Größenordnung wie der Sensor<br />
<br />
---------------------------<br />
Teil 17 (Schieberegister)<br />
* 2 Schieberegister 74HC595<br />
* einige LED, damit man an die Schieberegister auch etwas anschliessen kann, samt passenden Vorwiderständen<br />
<br />
---------------------------<br />
Teil 19 (7-Segmentanzeige)<br />
* 4 7-Segmentanzeigen mit gemeinsamer Anode<br />
* 4 PNP Transistoren BC338<br />
* 4 Widerstände 1k<br />
* 7 Widerstände 100Ohm<br />
<br />
Für weitere Bauteile, die man als angehender µC Bastler auch des Öfteren mal benötigt, empfiehlt sich ein Blick in die Liste der [[Standardbauelemente]] bzw. in die [[Absolute_beginner|Grundausstattung]]. Wenn ihr Händler Großpackungen (zb. 100 Stück) von 100n Kondensatoren, 10k, 1k oder 100Ohm Widerständen anbietet, sollten sie deren Erwerb in Erwägung ziehen. Diese Bauteile benötigt man oft und derartige Großpackungen sind oft nicht teurer, als wennn man einige wenige Exemplare einzeln kauft. Dies hängt damit zusammen, daß das Herauszählen von 9 Bauteilen für den Verkäufer teurer kommt, als 100 Bauteile abgepackt aus dem Regal zu nehmen.<br />
<br />
== Software ==<br />
<br />
In diesem Tutorial wird nur auf die Programmierung in Assembler eingegangen, da Assembler für das Verständnis der Hardware am besten geeignet ist.<br />
<br />
=== Assembler ===<br />
<br />
Zuerst braucht man einen '''Assembler''', der in Assemblersprache geschriebene Programme in Maschinencode übersetzt. Windows-User können das [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 AVR-Studio] von Atmel verwenden, das neben dem Assembler auch einen Simulator enthält, mit dem sich die Programme vor der Übertragung in den Controller testen lassen; für Linux gibt es [http://www.tavrasm.org/ tavrasm], [http://avra.sourceforge.net/ avra] und [http://avr-asm-tutorial.net/gavrasm/index_de.html gavrasm]. <br />
<br />
Um die vom Assembler erzeugte ".hex"-Datei über den ISP-Adapter in den Mikrocontroller zu programmieren, kann man unter Windows z.B. das Programm [http://www.myplace.nu/avr/yaap/ yaap] verwenden, für Linux gibt es [http://savannah.nongnu.org/projects/uisp/ uisp], für beide avrdude.<br />
<br />
=== C ===<br />
Wer in C programmieren möchte, kann den kostenlosen GNU-C-Compiler AVR-GCC (unter Windows "WinAVR") ausprobieren. Dieser C-Compiler kann auch in das für Assembler-Programmierung notwendige AVR-Studio integriert werden. In der Artikelsammlung gibt es ein umfangreiches [[AVR-GCC-Tutorial|Tutorial]] zu diesem Compiler;<br />
<br />
Wer unter Windows und Linux gleichermassen kostenlos entwickeln will, der sollte sich die [http://www.eclipse.org/ IDE Eclipse for C/C++ Developers] und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin ] ansehen, beide sind unter Windows und Linux einfach zu installieren. Hier wird auch der AVR-GCC benutzt. In der Artikelsammlung gibt es ein umfangreiches [[AVR Eclipse|AVR Eclipse Tutorial]] zu dieser IDE.<br />
Ebenfalls unter Linux und Windows verfügbar ist die Entwicklungsumgebung [http://www.codeblocks.org/ Code::Blocks] (aktuelle, stabile Versionen sind als Nightly Builds regelmäßig im [http://forums.codeblocks.org/ Forum] verfügbar). Innerhalb dieser Entwicklungsumgebung können ohne die Installation zusätzlicher Plugins "AVR-Projekte" angelegt werden.<br />
<br />
Fragen dazu stellt man am besten hier im [http://www.mikrocontroller.net/forum/list-2-1.html GCC-Forum].<br />
<br />
=== Pascal ===<br />
Wer in Pascal programmieren muss, kann [http://www.e-lab.de AVRPascal] ausprobieren. Dieser Pascalcompiler ist kostenfrei bis 4kb Code und bietet viele ausgereifte Bibliotheken. [http://www.e-lab.de E-LAB].<br />
<br />
=== Basic ===<br />
Auch Basic-Fans kommen nicht zu kurz, für die gibt es z.B. [[Bascom AVR]] ($69, Demo verfügbar).<br />
<br />
=== Forth ===<br />
Wer einen direkten und interaktiven Zugang zum Controller haben will, sollte sich [http://amforth.sourceforge.net Forth] anschauen. Voraussetzung ist ein serieller Anschluß (Max232), also etwas mehr als die Minimalbeschaltung.<br />
<br />
== Literatur ==<br />
Bevor man anfängt, sollte man sich die folgenden PDF-Dateien runterladen und zumindest mal reinschauen:<br />
<br />
* [http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf Datenblatt des ATmega8 (4,54 MB)]<br />
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf Befehlssatz der AVRs (1,27 MB)]<br />
* oder [http://www.avr-roboter.de/controller/befehle/befehle.html Befehlssatz in deutscher Übersetzung online]<br />
<br />
Das Datenblatt eines Controllers ist das wichtigste Dokument für einen Entwickler. Es enthält Informationen über die Pinbelegung, Versorgungsspannung, Beschaltung, Speicher, die Verwendung der IO-Komponenten und vieles mehr.<br />
<br />
Im Befehlssatz sind alle Assemblerbefehle der AVR-Controllerfamilie aufgelistet und erklärt.<br />
<br />
{{Navigation_hochvor| <br />
hochtext=Inhaltsverzeichnis| <br />
hochlink=AVR-Tutorial| <br />
vortext=I/O Grundlagen| <br />
vorlink=AVR-Tutorial: IO-Grundlagen}} <br />
<br />
[[Category:AVR-Tutorial]]</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37756Code::Blocks2009-07-13T18:14:43Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb|Oberfläche von Code::Blocks]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Es wird davon ausgegangen, dass der [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc] bereits installiert ist.<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk<br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD".<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb|Dialog für Compiler-Einstellungen]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37755Code::Blocks2009-07-13T18:12:58Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
[[Bild:Codeblocks_overview.png|thumb]]<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Es wird davon ausgegangen, dass der [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc] bereits installiert ist.<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk<br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD".<br />
<br />
[[Bild:Codeblocks_compiler_settings.png|thumb]]<br />
Nach der Installation der Entwicklungsumgebung ist unter "Settings->Compiler and Debugger" für den GNU AVR GCC Compiler der Pfad zu den Compiler-Binaries einzustellen. Diese Einstellung ist in dem Dialog unter dem Reiter "Toolchain executables" vorzunehmen. Dabei ist darauf zu achten, dass bei "Selected Compiler" der "GNU AVR GCC Compiler" eingestellt ist. Falls notwendig, können hier auch andere Standard-Einstellungen für diesen Compiler vorgenommen werden.</div>Mskhttps://www.mikrocontroller.net/index.php?title=Datei:Codeblocks_compiler_settings.png&diff=37754Datei:Codeblocks compiler settings.png2009-07-13T18:11:21Z<p>Msk: Dialog für die Compilereinstellungen von Codeblocks
(Quelle: selbst erstellt)</p>
<hr />
<div>Dialog für die Compilereinstellungen von Codeblocks<br />
(Quelle: selbst erstellt)</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37753Code::Blocks2009-07-13T17:42:25Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
[[Bild:Codeblocks_overview.png|thumb]]<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Es wird davon ausgegangen, dass der [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc] bereits installiert ist.<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk<br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD".</div>Mskhttps://www.mikrocontroller.net/index.php?title=Code::Blocks&diff=37752Code::Blocks2009-07-13T17:40:03Z<p>Msk: </p>
<hr />
<div>Dieser Artikel beschreibt die Installation und den Umgang mit der Entwicklungsumgebung Code::Blocks und deren Unterstützung für AVR-Projekte.<br />
<br />
== Allgemeines zu Code::Blocks ==<br />
<br />
Code::Blocks ist eine freie Entwicklungsumgebung, die neben der normalen C/C++-Entwicklung auch Unterstützung für AVR-Projekte bietet. Sie ist für Linux, Windows und auch Mac OS verfügbar und basiert auf dem freien Cross-Plattform-Toolkit [http://www.wxwidgets.org wxWidgets].<br />
<br />
[[Bild:Codeblocks_overview.png]]<br />
<br />
<br />
== Installation von Code::Blocks ==<br />
<br />
Auf der Webseite des Projektes ist ein Release der Entwicklungsumgebung verfügbar. Dieses ist jedoch in der Regel nicht sehr aktuell. Es ist auf alle Fälle empfehlenswert, eines der in der Regel sehr stabilen und aktuellen "Nightly Builds" zu nutzen. In den folgenden Abschnitten ist beschrieben, wie man das Nightly Build für das jeweilige Betriebssystem erhalten kann.<br />
<br />
<br />
===Installation unter Windows===<br />
<br />
<br />
<br />
===Installation unter Linux===<br />
<br />
Es wird davon ausgegangen, dass der [http://www.mikrocontroller.net/articles/AVR-GCC avr-gcc] bereits installiert ist.<br />
Wenn verfügbar, kann Code::Blocks über das der Distribution eigene Paketverwaltungssystem installiert werden. Falls nicht, muss die Entwicklungsumgebung aus den Quellen erstellt werden. Aktuelle Versionen sind dabei per Kommandozeilen-Befehl:<br />
<br />
svn checkout http://svn.berlios.de/svnroot/repos/codeblocks/trunk<br />
<br />
verfügbar (siehe auch [http://www.codeblocks.org/downloads/7 SVN]). Es wird ein Verzeichnis "trunk" angelegt, in dem sich die Quellen befinden. Eine Anleitung zur Installation befindet sich in der Datei "BUILD".</div>Mskhttps://www.mikrocontroller.net/index.php?title=Datei:Codeblocks_overview.png&diff=37751Datei:Codeblocks overview.png2009-07-13T17:38:32Z<p>Msk: Screenshot der Programmoberfläche von Code::Blocks
(Quelle: selbst erstellt)</p>
<hr />
<div>Screenshot der Programmoberfläche von Code::Blocks<br />
(Quelle: selbst erstellt)</div>Msk