Mikrocontroller.net - Benutzerbeiträge [de]

RFM69

2014-05-29T08:28:29Z

Hugstuart: /* Ansteuerung */

[[Datei:rf69cw.png|thumb|300px|RFM69CW, Pinkompatibel zum RFM12]]
Beschreibung des Funkmoduls RFM69 von HopeRF.
== Ausführungen ==
* RFM69HCW, mit zusätzlicher PA, 20 dBm
* RFM69HW, mit zusätzlicher PA, 20 dBm
* RFM69CW, Pinkompatibel zum RFM12B
* RFM69W

Die CW-Variante hat 2 Pins weniger (es fehlt der Pin DIO4), und ist Pinkompatibel zum Vorgänger RFM12B.
Es kann ohne Änderung am Layout oder der Schaltung ausgetauscht werden. Lediglich die Software muss angepasst werden.

== Ausstattung ==
* Betriebsspannung 1,8 - 3,6 V
* SPI Schnittstelle
* FSK und OOK Modulation
* Eingebauter Manchesterde- und encoder
* Frequenzbereiche 315, 433, 868, 915 MHz
* Max. Datenrate 300 kbit/s
* Ausgangsleistung +13 dBm (rund 20 mW)
* Stromaufnahme 45 mA senden (13 dBm), 16 mA empfangen, 0,1 µA stand by
* Integrierte Packetengine für Synchronwort, CRC, Scrambling und AES-Verschlüsselung
* 66 Byte FIFO

== Vergleich zum RFM12B ==

{| class="wikitable"
|-
! !! RFM12B !! RFM69(C)W
|-
| Versorgungsspannung || 2,2 - 3,8 V || 1,8 - 3,6 V
|-
| Max. Datenrate || 115,2 kbit/s || 300 kbit/s
|-
| Sendeleistung || 5 dBm || 13 dBm
|-
| Empfindlichkeit || -105 dB || -120 dB
|-
| Stromaufnahme || 22 mA/11 mA/0,3 µA || 45 mA/16 mA/0,1 µA
|-
| FIFO Größe || 16 Bit || 66 Bytes
|}

== Ansteuerung ==
Das Funkmodul kommuniziert über die SPI Schnittstelle mit dem µC. Im einfachsten Fall werden SCK, MISO, MOSI und NSS benötigt. Am besten führt man auch noch DIO0 zum Prozessor. Dieser Pin kann softwareseitig so konfiguriert werden, dass er anzeigt, wenn ein Packet vollständig gesendet oder ein neues Packet empfangen wurde. Ist das Modul in Minimalkonfiguration angeschlossen, müssen dazu die Statusregister RegIrqFlags1 (0x27) oder RegIrqFlags2 (0x28) ausgelesen werden.

Die SPI-Ansteuerung erfolgt im Modus CPOL=0, CPHA=0, wobei jeweils 16-bit vom µC zum Modul geschickt werden:
Das erste Bit teilt dem Modul mit, ob es sich um einen Lese- (Bitwert 0) oder Schreibvorgang (Bitwert 1) handelt, die restlichen sieben Bit des ersten Bytes geben die Registeradresse an. Mit den zweiten acht Bit wird im Schreibmodus der zu übertragende Befehl an das Modul übermittelt, im Lesemodus kann eine beliebige Bitfolge gesendet werden. Während des zweite Bit gesendet wird, empfängt der µC sowohl im Lese- als auch im Schreibmodus den Inhalt des angesprochenen Registers vor dem aktuellen Zugriff.

Werden nach dem Adressbyte mehrere Bytes empfangen oder gelesen, wird der Adresszeiger im RFM69 automatisch inkrementiert, so dass in einem einzigen Burst mehrere Register gelesen werden können. Zu beachten ist dabei dass in Registern die mehr als 8 Bit breit sind (Frequenz, Bitrate, ...) das höchstwertige Byte zu erst geschrieben/gelesen wird (big endian). Wird das FIFO Register gelesen/geschrieben, wird der Adresszeiger nicht inkrementiert, so dass auf das FIFO in einem Burst zugegriffen werden kann.

== Pinbelegung RFM69(H)CW ==
{| class="wikitable"
|-
! Pinnummer !! Name !! Richtung !! Beschreibung !! Pin am RFM12
|-
| 1 || ANA || || Antennenanschluss || ANT
|-
| 2 || 3.3V || || Versorgungsspannung || VDD
|-
| 3 || GND || || || GND
|-
| 4 || DIO3 || || FifoFull PllLock Rssi SyncAdress TXReady || nINT/VDI
|-
| 5 || MOSI || || SPI Daten Eingang || SDI
|-
| 6 || SCK || || SPI Takt || SCK
|-
| 7 || NSS || || Chip select || nSEL
|-
| 8 || MISO || || SPI Daten Ausgang || SDO
|-
| 9 || DIO0 || || PllLock (FS, TX) CrcOK (RX) PayloadReady (RX) SyncAddress (RX) Rssi (RX) PacketSent (TX) TxReady (TX) || nIRQ
|-
| 10 || DIO2 || || FifoNotEmpty (Sleep, Stdby, FS, RX, TX) AutoMode(Sleep, Stdby, FS, RX, TX) Data (RX, TX) || FSK/DATA/nFFS
|-
| 11 || DIO1 || || FifoLevel (Sleep, Stdby, FS, RX, TX) FifoFull (Sleep, Stdby, FS, RX, TX) FifoNotEmpty (Sleep, Stdby, FS, RX, TX) PllLock (FS, TX) Timeout (RX) || DCLK/CFIL/FFIT
|-
| 12 || DIO5 || || ModeReady ClkOut (Stdby, FS, RX, TX) Data (RX, TX) || CLK
|-
| 13 || RESET || || || nRES
|-
| 14 || GND || || || GND
|}

== Register ==
{| class="wikitable"
|-
! Adresse !! Registername !! Beschreibung !! Beispiel
|-
| 0x00 || RegFifo || Zugriff auf das FIFO Register
|-
| 0x01 || RegOpMode || Betriebsart (senden, empfangen, ...) || 0x04 = Empfangen
|-
| 0x02 || RegDataModule || Modulationsart &-shaping, Packetengine || 0x00 = FSK, Packetengine aktiv
|-
| 0x03 - 0x04|| RegBitrate || = FXOSC/Bitrate || 0x1A0B = 6667 -> 4,8 kbit/s
|-
| 0x05 - 0x06 || RegFdev || Frequenzabweichung (Hub * 2) || 0x52 = 82 -> 5 kHz
|-
| 0x07 - 0x09 || RegFrf || Mittenfrequenz || 0xD91333 = 14226227 -> 868,300 MHz
|-
| 0x11|| RegPaLevel || Sendeleistung || 0x12 = 18 -> 0 dBm
|-
| 0x19|| RegRxBw || Filterbandbreite || 0b01001 -> 200 kHz
|-
| 0x25|| RegDioMapping1 || DIO Funktionen ||
|-
| 0x27|| RegIrqFlags1 || Statusflags || 0xD0 -> Empfänger bereit zum Datenempfang
|-
| 0x28|| RegIrqFlags2 || Statusflags || 0x03 -> Daten mit erfolgreichem CRC empfangen
|-
| 0x2C - 0x2D|| RegPreamble || Preamblelänge ||
|-
| 0x2E || RegSyncConfig || Synchronworteinstellungen ||
|-
| 0x2F - 0x36 || RegSyncValue || Synchronwort || 0x2DD4
|-
| 0x37 || RegPacketConfig1 || Einstellungen Packetengine ||
|-
| 0x38 || RegPayloadLength || Datenpacketgröße ||
|}

== Projekte ==
=== FS20 Funksteckdosen schalten ===
Da das RFM69 OOK modulieren kann, können damit die FS20 Funksteckdosen geschaltet werden. FS20 verwendet allerdings eine Art Pulsdauermodulation; eine 1 wird mit 600 µS Träger an gefolgt von 600 µS Träger aus, und eine 0 mit 400 µS an gefolgt von 400 µS aus übertragen. Man teilt einfach das Signal in 200 µS Schlitze ein (OOK-Datenrate 5 kbit/s), und sendet für eine 1 die Folge 111000 und für eine 0 die Folge 1100. Im FS20 Protokoll wird ein 13 Bit langer Header (0000000000001) übertragen, diesen kann man umrechnen und im RFM69 als Syncword einstellen. So wird der Header vom RFM69 bei jeder Übertragung automatisch vorweg ausgesendet.

== Bezugsquellen ==
[http://shop.seegel-systeme.de/Bauelemente/Funkmodul-RFM69CW-REV-V1-0-868-MHz-SMD.html Seegel Systeme]

== Links ==
* [http://www.hoperf.com/upload/rf/RFM69CW-V1.1.pdf Datenblatt RFM69CW]
* [http://www.hoperf.com/upload/rf/RFM69W-V1.3.pdf Datenblatt RFM69W]
* [http://www.mikrocontroller.net/topic/332579 Thread im Forum: Wer verwendet RFM69]

AVR-GCC-Tutorial

2010-07-21T13:34:47Z

Hugstuart: /* Ganzzahlige (Integer) Datentypen */

= Vorwort =

Dieses Tutorial soll den Einstieg in die Programmierung von Atmel [[AVR]]-Mikrocontrollern in der Programmiersprache [[C]] mit dem freien C-Compiler [[AVR-GCC]] aus der [http://gcc.gnu.org/ GNU Compiler Collection] erleichtern.

Vorausgesetzt werden Grundkenntnisse der Progammiersprache C. Diese Kenntnisse kann man sich online erarbeiten, z. B. mit dem [http://www.schellong.de/c.htm C Tutorial von Helmut Schellong] ([[C|Liste von C-Tutorials]]). Nicht erforderlich sind Vorkenntnisse in der Programmierung von Mikrocontrollern, weder in Assembler noch in einer anderen Sprache.

In diesem Text wird häufig auf die Standardbibliothek avr-libc verwiesen, für die es eine [http://www.nongnu.org/avr-libc/user-manual/index.html Online-Dokumentation] gibt, in der sich auch viele nützliche Informationen zum Compiler und zur Programmierung von AVR Controllern finden. Bei WinAVR gehört die avr-libc Dokumentation zum Lieferumfang und wird mitinstalliert.

Der Compiler und die Standardbibliothek avr-libc werden stetig weiterentwickelt. Erläuterungen und Beispiele beziehen sich auf den C-Compiler avr-gcc ab Version 3.4 und die avr-libc ab Version 1.4.3. Die Unterschiede zu älteren Versionen werden im Haupttext und Anhang zwar erläutert, Anfängern sei jedoch empfohlen, die aktuellen Versionen zu nutzen (für MS-Windows: aktuelle Version des [[WinAVR]]-Pakets; für Linux: siehe Artikel [[AVR und Linux]]).

Das ursprüngliche Tutorial stammt von Christian Schifferle, viele neue Abschnitte und aktuelle Anpassungen von Martin Thomas.

Dieses Tutorial ist in PDF-Form hier erhältlich (nicht immer auf aktuellem Stand):
[[Media:AVR-GCC-Tutorial.pdf]]

= Siehe auch =

Um diese riesige Seite etwas überschaubarer zu gestalten, wurden einige Kapitel ausgelagert, die nicht unmittelbar mit den Grundlagen von avr-gcc in Verbindung stehen. All diese Seiten gehören zur [[:Kategorie:avr-gcc Tutorial]].
* → [[AVR-GCC-Tutorial/Der UART|Der UART]]
* → [[AVR-GCC-Tutorial/Der Watchdog|Der Watchdog]]
* → [[AVR-GCC-Tutorial/Die Timer und Zähler des AVR|Die Timer und Zähler des AVR]]
* → [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]]
* → [[AVR-GCC-Tutorial/LCD-Ansteuerung|LCD-Ansteuerung]]

= Benötigte Werkzeuge =

Um eigene Programme für AVRs mittels avr-gcc/avr-libc zu erstellen und zu testen, wird folgende Hard- und Software benötigt:

* Platine oder Versuchsaufbau für die Aufnahme eines AVR Controllers, der vom avr-gcc Compiler unterstützt wird (alle ATmegas und die meisten AT90, siehe Dokumentation der avr-libc für unterstützte Typen). Dieses Testboard kann durchaus auch selbst gelötet oder auf einem Steckbrett aufgebaut werden. Einige Registerbeschreibungen dieses Tutorials beziehen sich auf den inzwischen veralteten AT90S2313. Der weitaus größte Teil des Textes ist aber für alle Controller der AVR-Familie gültig. Brauchbare Testplattformen sind auch das [[STK500]] und der [[AVR Butterfly]] von Atmel. Weitere Infos findet man in den Artikeln [[AVR#Starterkits|AVR Starterkits]] und [[AVR-Tutorial: Equipment]].

* Der avr-gcc Compiler und die avr-libc. Kostenlos erhältlich für nahezu alle Plattformen und Betriebssysteme. Für MS-Windows im Paket [[WinAVR]]; für Unix/Linux siehe auch Hinweise im Artikel [[AVR-GCC]] und im Artikel [[AVR und Linux]].

* Programmiersoftware und -[[AVR In System Programmer |hardware]] z. B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], Atmel AVRISP, [[AVR-Studio]]).

* Nicht unbedingt erforderlich, aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]]).

* Wer unter Windows und Linux gleichermassen 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 gibt es auch einen [[AVR_Eclipse|Artikel AVR Eclipse]] in dieser Wiki. 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. Für Linux gibt es auch noch das [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=25220&postdays=0&postorder=asc&start=0 KontrollerLab].

= Was tun, wenn's nicht "klappt"? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder nur die eigenen C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.

* Die [[AVR Checkliste]] durcharbeiten.

* Die '''[http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc]''' lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/'''Frequently Asked Questions''' = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.

* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.

* Das [http://www.mikrocontroller.net/forum/gcc GCC-Forum auf www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.

* Das avr-gcc-Forum bei [http://www.avrfreaks.net AVRfreaks] nach vergleichbaren Problemen absuchen.

* Das [http://lists.gnu.org/archive/html/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.

* Nach Beispielcode suchen. Vor allem im ''Projects''-Bereich von [http://www.avrfreaks.net AVRfreaks] (anmelden).

* Google oder yahoo befragen schadet nie.

* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal). Datenblätter sind auf den [http://www.atmel.com Atmel Webseiten] als pdf-Dateien verfügbar. Das komplette Datenblatt (complete) und nicht die Kurzfassung (summary) verwenden.

* Die Beispieleprogramme im [[AVR-Tutorial]] sind zwar in AVR-Assembler verfasst, Erläuterungen und Vorgehensweisen sind aber auch auf C-Programme übertragbar.

* Einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei möglichst viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode oder besser ein [http://www.mikrocontroller.net/topic/72767#598986 Testprojekt] mit allen notwendigen Dateien, um das Problem nachzuvollziehen, sowie genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z. B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: '''[http://www.tty1.net/smart-questions_de.html "Wie man Fragen richtig stellt"]'''.

= Erzeugen von Maschinencode =

Aus dem C-Quellcode erzeugt der avr-gcc Compiler (zusammen mit Hilfsprogrammen wie z. B. Präprozessor, Assembler und Linker) Maschinencode für den AVR-Controller. Üblicherweise liegt dieser Code dann im Intel Hex-Format vor ("Hex-Datei"). Die Programmiersoftware (z. B. [[AVRDUDE]], PonyProg oder AVRStudio/STK500-plugin) liest diese Datei ein und überträgt die enthaltene Information (den Maschinencode) in den Speicher des Controllers. Im Prinzip sind also "nur" der avr-gcc-Compiler (und wenige Hilfsprogramme) mit den "richtigen" Optionen aufzurufen, um aus C-Code eine "Hex-Datei" zu erzeugen. Grundsätzlich stehen dazu zwei verschiedene Ansätze zur Verfügung:

* Die Verwendung einer integrierten Entwicklungsumgebung (IDE = '''I'''ntegrated '''D'''evelopment '''E'''nvironment), bei der alle Einstellungen z. B. in Dialogboxen durchgeführt werden können. Unter Anderem kann AVRStudio ab Version 4.12 (kostenlos auf [http://www.atmel.com/ atmel.com]) zusammen mit WinAVR als integrierte Entwicklungsumgebung für den Compiler avr-gcc genutzt werden (dazu müssen AVRStudio und WinAVR auf dem Rechner installiert sein). Weitere IDEs (ohne Anspruch auf Vollständigkeit): [http://www.eclipse.org/ Eclipse for C/C++ Developers] (d.h. inkl. CDT) und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin] (für diverse Plattformen, u.a. Linux und MS Windows, IDE und Plugin kostenlos), [http://sourceforge.net/projects/kontrollerlab KontrollerLab] (Linux/KDE, kostenlos). [http://www.atmanecl.com/EnglishSite/SoftwareEnglish.htm AtmanAvr] (MS Windows, relativ günstig), KamAVR (MS-Windows, kostenlos, wird augenscheinlich nicht mehr weiterentwickelt), [http://www.amctools.com/vmlab.htm VMLab] (MS Windows, ab Version 3.12 ebenfalls kostenlos). Integrierte Entwicklungsumgebungen unterscheiden sich stark in Ihrer Bedienung und stehen auch nicht für alle Plattformen zur Verfügung, auf denen der Compiler ausführbar ist (z. B. AVRStudio nur für MS-Windows). Zur Anwendung des avr-gcc Compilers mit IDEs sei hier auf deren Dokumentation verwiesen.

* Die Nutzung des Programms make mit passenden Makefiles. In den folgenden Abschnitten wird die Generierung von Maschinencode für einen AVR ("hex-Datei") aus C-Quellcode ("c-Dateien") anhand von "make" und den "Makefiles" näher erläutert. Viele der darin beschriebenen Optionen findet man auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio (AVRStudio generiert ein makefile in einem Unterverzeichnis des Projektverzeichnisses).

Beim Wechsel vom makefile-Ansatz nach WinAVR-Vorlage zu AVRStudio ist darauf zu achten, dass AVRStudio (Stand: AVRStudio Version 4.13) bei einem neuen Projekt die Optimierungsoption (vgl. Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|AVR-GCC-Tutorial/Exkurs: Makefiles]], typisch: -Os) nicht einstellt und die mathematische Bibliothek der avr-libc (libm.a, Linker-Option -lm) nicht einbindet. (Hinweis: Bei Version 4.16 wird beides bereits gesetzt). Beides ist Standard bei Verwendung von makefiles nach WinAVR-Vorlage und sollte daher auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio "manuell" eingestellt werden, um auch mit AVRStudio kompakten Code zu erzeugen.

= Einführungsbeispiel =

Zum Einstieg ein kleines Beispiel, an dem die Nutzung des Compilers und der Hilfsprogramme (der sogenannten ''Toolchain'') demonstriert wird. Detaillierte Erläuterungen folgen in den weiteren Abschnitten dieses Tutorials.

Das Programm soll auf einem AVR Mikrocontroller einige Ausgänge ein- und andere ausschalten. Das Beispiel ist für einen ATmega16 programmiert ([http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf Datenblatt]), kann aber sinngemäß für andere Controller der AVR-Familie modifiziert werden.

Zunächst der Quellcode der Anwendung, der in einer Text-Datei mit dem Namen ''main.c'' abgespeichert wird.

<c>
/* Alle Zeichen zwischen Schrägstrich-Stern
und Stern-Schrägstrich sind lediglich Kommentare */

// Zeilenkommentare sind ebenfalls möglich
// alle auf die beiden Schrägstriche folgenden
// Zeichen einer Zeile sind Kommentar

#include <avr/io.h> // (1)

int main (void) { // (2)

DDRB = 0xff; // (3)
PORTB = 0x03; // (4)

while(1) { // (5a)
/* "leere" Schleife*/ // (5b)
} // (5c)

/* wird nie erreicht */
return 0; // (6)
}
</c>

* In der mit (1) markierten Zeile wird eine so genannte Header-Datei eingebunden. In io.h sind die Registernamen definiert, die im späteren Verlauf genutzt werden.

* Bei (2) beginnt das eigentliche Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion main.

* (3) Die Anschlüsse eines AVR ("Beinchen") werden zu Blöcken zusammengefasst, einen solchen Block bezeichnet man als Port. Beim ATmega16 hat jeder Port 8 Anschlüsse, bei kleineren AVRs können einem Port auch weniger als 8 Anschlüsse zugeordnet sein. Da per Definition (Datenblatt) alle gesetzten Bits in einem Datenrichtungsregister den entsprechenden Anschluss auf Ausgang schalten, werden mit DDRB=0xff alle Anschlüsse des Ports B als Ausgänge eingestellt.

* (4) stellt die Werte der Ausgänge ein. Die den ersten beiden Bits des Ports zugeordneten Anschlüsse (PB0 und PB1) werden 1, alle anderen Anschlüsse des Ports B (PB2-PB7) zu 0. Aktivierte Ausgänge (logisch 1 oder "high") liegen auf Betriebsspannung (VCC, meist 5 Volt), nicht aktivierte Ausgänge führen 0 Volt (GND, Bezugspotential). Es ist sinnvoll sich möglichst frühzeitig eine alternative Schreibweise beizubringen, die wegen der leichteren Überprüfbarkeit und Portierbarkeit oft im weiteren Tutorial und in Forenbeiträgen benutzt wird. Die Zuordnung sieht in diesem Fall so aus:

:<c>
PORTB = (1<<PB1) | (1<<PB0);
:</c>
:Näheres dazu im Artikel [[Bitmanipulation]].

* (5) ist die so genannte Hauptschleife (main-loop). Dies ist eine Programmschleife, welche kontinuierlich wiederkehrende Befehle enthält. In diesem Beispiel ist sie leer. Der Controller durchläuft die Schleife immer wieder, ohne dass etwas passiert (außer das Strom verbraucht wird). Eine solche Schleife ist notwendig, da es auf dem Controller kein Betriebssystem gibt, das nach Beendigung des Programmes die Kontrolle übernehmen könnte. Ohne diese Schleife wäre der Zustand des Controllers nach dem Programmende undefiniert.

* (6) wäre das Programmende. Die Zeile ist nur aus Gründen der C-Kompatibilität enthalten: int main(void) besagt, dass die Funktion einen Wert zurückgibt. Die Anweisung wird aber nicht erreicht, da das Programm die Hauptschleife nie verlässt.

Um diesen Quellcode in ein auf dem Controller lauffähiges Programm zu übersetzen, wird hier ein Makefile genutzt. Das verwendete Makefile findet sich auf der Seite [[Beispiel Makefile]] und basiert auf der Vorlage, die in WinAVR mitgeliefert wird und wurde bereits angepasst (Controllertyp ATmega16). Man kann das Makefile bearbeiten und an andere Controller anpassen oder sich mit dem Programm MFile menügesteuert ein Makefile "zusammenklicken". Das Makefile speichert man unter dem Namen Makefile (ohne Endung) im selben Verzeichnis, in dem auch die Datei main.c mit dem Programmcode abgelegt ist. Detailliertere Erklärungen zur Funktion von Makefiles finden sich im Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]].

<pre>
D:\tmp\gcc_tut\quickstart>dir

Verzeichnis von D:\tmp\gcc_tut\quickstart

28.11.2006 22:53 <DIR> .
28.11.2006 22:53 <DIR> ..
28.11.2006 20:06 118 main.c
28.11.2006 20:03 16.810 Makefile
2 Datei(en) 16.928 Bytes
</pre>

Nun gibt man ''make all'' ein. Falls das mit WinAVR installierte Programmers Notepad genutzt wird, gibt es dazu einen Menüpunkt im Tools Menü. Sind alle Einstellungen korrekt, entsteht eine Datei main.hex, in der der Code für den AVR enthalten ist.

<pre>
D:\tmp\gcc_tut\quickstart>make all

-------- begin --------
avr-gcc (GCC) 3.4.6
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Compiling C: main.c
avr-gcc -c -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -f
unsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef
-Wa,-adhlns=obj/main.lst -std=gnu99 -Wundef -MD -MP -MF .dep/main.o.d main.c -
o obj/main.o

Linking: main.elf
avr-gcc -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -funs
igned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef -W
a,-adhlns=obj/main.o -std=gnu99 -Wundef -MD -MP -MF .dep/main.elf.d obj/main.o
--output main.elf -Wl,-Map=main.map,--cref -lm

Creating load file for Flash: main.hex
avr-objcopy -O ihex -R .eeprom main.elf main.hex

[...]
</pre>

Der Inhalt der hex-Datei kann nun zum Controller übertragen werden. Dies kann z. B. über In-System-Programming (ISP) erfolgen, das im [[AVR-Tutorial: Equipment]] beschrieben ist. Makefiles nach der WinAVR/MFile-Vorlage sind für die Nutzung des Programms [[AVRDUDE]] vorbereitet. Wenn man den Typ und Anschluss des Programmiergerätes richtig eingestellt hat, kann mit ''make program'' die Übertragung mittels AVRDUDE gestartet werden. Jede andere Software, die hex-Dateien lesen und zu einem AVR übertragen kann (z. B. [[Pony-Prog_Tutorial|Ponyprog]], yapp, AVRStudio), kann natürlich ebenfalls genutzt werden.

Startet man nun den Controller (Reset-Taster oder Stromzufuhr aus/an), werden vom Programm die Anschlüsse PB0 und PB1 auf 1 gesetzt. Man kann mit einem Messgerät nun an diesem Anschluss die Betriebsspannung messen oder eine LED leuchten lassen (Anode an den Pin, Vorwiderstand nicht vergessen). An den Anschlüssen PB2-PB7 misst man 0 Volt. Eine mit der Anode mit einem dieser Anschlüsse verbundene LED leuchtet nicht.

= Ganzzahlige (Integer) Datentypen =

Bei der Programmierung von Mikrokontrollern ist die Definition einiger ganzzahliger Datentypen sinnvoll, an denen eindeutig die Bit-Länge abgelesen werden kann.

Standardisierte Datentypen werden in der Header-Datei stdint.h definiert.
Zur Nutzung der standardisierten Typen bindet man die "Definitionsdatei" wie folgt ein:

<c>
// ab avr-libc Version 1.2.0 möglich und empfohlen:
#include <stdint.h>

// veraltet: #include <inttypes.h>
</c>

Einige der dort definierten Typen (avr-libc Version 1.0.4):

<c>
typedef signed char int8_t;
typedef unsigned char uint8_t;

typedef short int16_t;
typedef unsigned short uint16_t;

typedef long int32_t;
typedef unsigned long uint32_t;

typedef long long int64_t;
typedef unsigned long long uint64_t;
</c>

* int8_t steht für einen 8-Bit Integer mit einem Wertebereich -128 bis +127.

* uint8_t steht für einen 8-Bit Integer ohne Vorzeichen (unsigned int) mit einem Wertebereich von 0 bis 255

* int16_t steht für einen 16-Bit Integer mit einem Wertebereich -32768 bis +32767.

* uint16_t steht für einen 16-Bit Integer ohne Vorzeichen (unsigned int) mit einem Wertebereich von 0 bis 65535.

Die Typen ohne vorangestelltes ''u'' werden als vorzeichenbehaftete Zahlen abgespeichert. Typen mit vorgestelltem ''u'' dienen der Ablage von positiven Zahlen (inkl. 0). Siehe dazu auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/(Standard) Integer Types.

= Bitfelder =

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bits breit ist.

Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in eine einzelne Bytevariable zusammenfassen und (fast) wie
8 einzelne Variablen ansprechen können. Die Rede ist von so genannten Bitfeldern. Diese werden als Strukturelemente definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<c>
struct {
unsigned bStatus_1:1; // 1 Bit für bStatus_1
unsigned bStatus_2:1; // 1 Bit für bStatus_2
unsigned bNochNBit:1; // Und hier noch mal ein Bit
unsigned b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</c>

Der Zugriff auf ein solches Feld erfolgt nun wie beim Strukturzugriff bekannt
über den Punkt- oder den Dereferenzierungs-Operator:

<c>
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</c>

Bitfelder sparen Platz im RAM, zu Lasten von Platz im Flash, verschlechtern aber unter Umständen die Les- und Wartbarkeit des Codes. Anfängern wird deshalb geraten, ein "ganzes" Byte (uint8_t) zu nutzen, auch wenn nur ein Bitwert gespeichert werden soll.

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat:

[[Image:Sequentielle Programme.gif]]

== Interruptgesteuerter Programmablauf ==

Bei dieser Methode werden beim Programmstart zuerst die gewünschten Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher Dinge erledigt werden können, welche nicht zeitkritisch sind. Wenn ein Interrupt ausgelöst wird, so wird automatisch die zugeordnete Interruptfunktion ausgeführt.

[[Image:Interrupt Programme.gif]]

= Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heißt, das Programm kann die
Inhalte der Register sowohl auslesen als auch beschreiben.

Register haben einen besonderen Stellenwert bei den AVR Controllern. Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir die 8-Bit Register.

Einzelne Register sind bei allen AVRs vorhanden, andere wiederum nur bei bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff auf den UART notwendig sind, selbstverständlich nur bei denjenigen Modellen vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden AVR-Typen definiert. Dazu muss man den Namen der controllerspezifischen Headerdatei nicht kennen. Es reicht aus, die allgemeine Headerdatei ''avr/io.h'' einzubinden:

<c>
#include <avr/io.h>
</c>

Ist im Makefile der MCU-Typ z. B. mit dem Inhalt atmega8 definiert (und wird somit per -mmcu=atmega8 an den Compiler übergeben), wird beim Einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit den Register-Definitionen für den ATmega8 eingelesen.


Intern wird diese "Automatik" wie folgt realisiert: Der Controllertyp wird dem Compiler als Parameter übergeben (vgl. ''avr-gcc -c -mmcu=atmega16 [...]'' im Einführungsbeispiel). Wird ein Makefile nach der WinAVR/mfile-Vorlage verwendet, setzt man die Variable ''MCU'', der Inhalt dieser Variable wird dann an passender Stelle für die Compilerparameter verwendet. Der Compiler definiert intern eine dem mmcu-Parameter zugeordnete "Variable" (genauer: ein Makro) mit dem Namen des Controllers, vorangestelltem ''__AVR_'' und angehängten Unterstrichen (z. B. wird bei ''-mmcu=atmega16'' das Makro ''__AVR_ATmega16__'' definiert). Beim Einbinden der Header-Datei ''avr/io.h'' wird geprüft, ob das jeweilige Makro definiert ist und die zum Controller passende Definitionsdatei eingelesen. Zur Veranschaulichung einige Ausschnitte aus einem Makefile:

<pre>
[...]
# MCU Type ("name") setzen:
MCU = atmega16
[...]

[...]
## Verwendung des Inhalts von MCU (hier atmega16) fuer die
## Compiler- und Assembler-Parameter
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
[...]

[...]
## Aufruf des Compilers:
## mit den Parametern ($(ALL_CFLAGS) ist -mmcu=$(MCU)[...] = -mmcu=atmega16[...]
$(OBJDIR)/%.o : %.c
@echo
@echo $(MSG_COMPILING) $<
$(CC) -c $(ALL_CFLAGS) $< -o $@
[...]
</pre>

Da --mmcu=atmega16 übergeben wurde, wird __AVR_ATmega16__ definiert und kann in avr/io.h zur Fallunterscheidung genutzt werden:

<c>
// avr/io.h
// (bei WinAVR-Standardinstallation in C:\WinAVR\avr\include\avr)
[...]
#if defined (__AVR_AT94K__)
# include <avr/ioat94k.h>
// [...]
#elif defined (__AVR_ATmega16__)
// da __AVR_ATmega16__ definiert ist, wird avr/iom16.h eingebunden:
# include <avr/iom16.h>
// [...]
#else
# if !defined(__COMPILING_AVR_LIBC__)
# warning "device type not defined"
# endif
#endif
</c>

Die Beispiele in den folgenden Abschnitten demonstrieren den Zugriff auf Register anhand der Register für I/O-Ports (PORTx, DDRx, PINx), die Vorgehensweise ist jedoch für alle Register (z. B. die des UART, ADC, SPI) analog.

== Schreiben in Register ==

Zum Schreiben kann man Register einfach wie eine Variable setzen. In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Schreibzugriff über die Funktion outp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt, outp() ist nicht mehr erforderlich.

Beispiel:

<c>
#include <avr/io.h>

...

int main(void)
{
/* Setzt das Richtungsregister des Ports A auf 0xff
(alle Pins als Ausgang, vgl. Abschnitt Zugriff auf Ports): */
DDRA = 0xff;

/* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low": */
PORTA = 0x03;
...

// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
DDRB = 0x1F; /* direkte Zuweisung - unübersichtlich */

/* Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
aber übersichtlicher und selbsterklärend: */
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);
}
</c>

Die ausführliche Schreibweise sollte bevorzugt verwendet werden, da dadurch die Zuweisungen selbsterklärend sind und somit der Code leichter nachvollzogen werden kann. Atmel verwendet sie auch bei Beispielen in Datenblätten und in den allermeisten Quellcodes zu Application-Notes. Mehr zu der Schreibweise mit "|" und "<<" findet man im Artikel [[Bitmanipulation]].

Der gcc C-Compiler (genauer der Präprozessor) unterstützt ab Version 4.3.0 Konstanten im Binärformat, z. B. DDRB = 0b00011111 (für WinAVR wurden schon ältere Versionen des gcc entsprechend angepasst). Diese Schreibweise ist jedoch nicht standardkonform und man sollte sie daher insbesondere dann nicht verwenden, wenn Code mit anderen ausgetauscht oder mit anderen Compilern bzw. älteren Versionen des gcc genutzt werden soll.

== Verändern von Registerinhalten ==

Einzelne Bits setzt und löscht man "Standard-C-konform" mittels logischer (Bit-) Operationen.

<c>
x |= (1 << Bitnummer); // Hiermit wird ein Bit in x gesetzt
x &= ~(1 << Bitnummer); // Hiermit wird ein Bit in x geloescht
</c>

Es wird jeweils nur der Zustand des angegebenen Bits geändert, der vorherige Zustand der anderen Bits bleibt erhalten.

Beispiel:
<c>
#include <avr/io.h>
...
#define MEINBIT 2
...
PORTA |= (1 << MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1 << MEINBIT); /* loescht Bit 2 an PortA */
</c>

Mit dieser Methode lassen sich auch mehrere Bits eines Registers gleichzeitig setzen und löschen.

Beispiel:
<c>
#include <avr/io.h>
...
DDRA &= ~( (1<<PA0) | (1<<PA3) ); /* PA0 und PA3 als Eingaenge */
PORTA |= (1<<PA0) | (1<<PA3); /* Interne Pull-Up fuer beide einschalten */
</c>

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind nicht mehr erforderlich.

Siehe auch:
* [[Bitmanipulation]]
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

== Lesen aus Registern ==

Zum Lesen kann man auf Register einfach wie auf eine Variable zugreifen. In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Lesezugriff über die Funktion inp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt und inp() ist nicht mehr erforderlich.

Beispiel:

<c>
#include <avr/io.h>
#include <stdint.h>

uint8_t foo;

//...

int main(void)
{
/* kopiert den Status der Eingabepins an PortB
in die Variable foo: */
foo = PINB;
//...
}
</c>

Die Abfrage der Zustände von Bits erfolgt durch Einlesen des gesamten Registerinhalts und ausblenden der Bits deren Zustand nicht von Interesse ist. Einige Beispiele zum Prüfen ob Bits gesetzt oder gelöscht sind:

<c>
#define MEINBIT0 0
#define MEINBIT2 2

uint8_t i;

extern test1();

// Funkion test1 aufrufen, wenn Bit 0 in Register PINA gesetzt (1) ist
i = PINA; // Inhalt in Arbeitsvariable
i = i & 0x01; // alle Bits bis auf Bit 0 ausblenden (logisches und)
// falls das Bit gesetzt war, hat i den Inhalt 1
if ( i != 0 ) { // Ergebnis ungleich 0 (wahr)?
test1(); // dann muss Bit 0 in i gesetzt sein -> Funktion aufrufen
}
// verkürzt:
if ( ( PINA & 0x01 ) != 0 ) {
test1();
}
// nochmals verkürzt:
if ( PINA & 0x01 ) {
test1();
}
// mit definierter Bitnummer:
if ( PINA & ( 1 << MEINBIT0 ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 oder Bit 2 gesetzt ist. (Bit 0 und 2 also Wert 5)
// (Bedenke: Bit 0 hat Wert 1, Bit 1 hat Wert 2 und Bit 2 hat Wert 4)
if ( PINA & 0x05 ) {
test1(); // Vergleich <> 0 (wahr), also muss Bit 0 oder 2 gesetzt sein
}
// mit definierten Bitnummern:
if ( PINA & ( ( 1 << MEINBIT0 ) | ( 1 << MEINBIT2 ) ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 und Bit 2 gesetzt sind
if ( ( PINA & 0x05 ) == 0x05 ) { // nur wahr, wenn beide Bits gesetzt
test1();
}

// Funktion test2() aufrufen, wenn Bit 0 gelöscht (0) ist
i = PINA; // einlesen in temporäre Variable
i = i & 0x01; // maskieren von Bit 0
if ( i == 0 ) { // Vergleich ist wahr, wenn Bit 0 nicht gesetzt ist
test2();
}
// analog mit !-Operator (not)
if ( !i ) {
test2();
}
// nochmals verkürzt:
if ( !( PINA & 0x01 ) ) {
test2();
}
</c>

Die AVR-Bibliothek (avr-libc) stellt auch Funktionen (Makros) zur Abfrage eines einzelnen Bits eines Registers zur Verfügung, diese sind bei anderen Compilern meist nicht verfügbar (können aber dann einfach durch Makros "nachgerüstet" werden).

;bit_is_set (<Register>,<Bitnummer>): Die Funktion ''bit_is_set'' prüft, ob ein Bit gesetzt ist. Wenn das Bit gesetzt ist, wird ein Wert ungleich 0 zurückgegeben. Genau genommen ist es die Wertigkeit des abgefragten Bits, also 1 für Bit0, 2 für Bit1, 3 für Bit2 etc.

;bit_is_clear (<Register>,<Bitnummer>): Die Funktion ''bit_is_clear'' prüft, ob ein Bit gelöscht ist. Wenn das Bit gelöscht ist, also auf 0 ist, wird ein Wert ungleich 0 zurückgegeben.

Die Funktionen (eigentlich Makros) bit_is_clear bzw. bit_is_set sind nicht erforderlich, man kann und sollte C-Syntax verwenden, die universell verwendbar und portabel ist. Siehe auch [[Bitmanipulation]].

== Warten auf einen bestimmten Zustand ==

Es gibt in der Bibliothek avr-libc Funktionen, die warten, bis ein bestimmter Zustand eines Bits erreicht ist. Es ist allerdings normalerweise eine eher unschöne Programmiertechnik, da in diesen Funktionen "blockierend" gewartet wird. Der Programmablauf bleibt also an dieser Stelle stehen, bis das maskierte Ereignis erfolgt ist. Setzt man den Watchdog ein, muss man darauf achten, dass dieser auch noch getriggert wird (Zurücksetzen des Watchdogtimers).

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits gesetzt ist, wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT PA2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1 << WARTEBIT)) ) ;
...
</c>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits gelöscht ist, wird die Funktion sofort wieder verlassen.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT PB4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// gesetzt (1) ist
while ( WARTEPIN & (1<<WARTEBIT) ) ;
...
</c>

Universeller und auch auf andere Plattformen besser übertragbar ist die Verwendung von C-Standardoperationen.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]

== 16-Bit Register (ADC, ICR1, OCR1x, TCNT1, UBRR) ==

Einige der Portregister in den AVR-Controllern sind 16 Bit breit. Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (LSB) und "H" (MSB) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese kann direkt zugewiesen bzw. zugegriffen werden. Die Konvertierung von 16-bit Wort nach 2*8-bit Byte erfolgt intern.

<c>
#include <avr/io.h>
#include <stdint.h>
...
uint16_t foo;

foo=ADC; /* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
</c>

Falls benötigt, kann eine 16-Bit Variable auch recht einfach manuell in ihre zwei 8-Bit Bestandteile zerlegt werden. Folgendes Beispiel demonstriert dies anhand des pseudo- 16-Bit Registers UBRR.

<c>
/* Diese Variante ist normal am effizientesten */
#include <avr/io.h>
#include <stdint.h>
#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

typedef union {
uint16_t i16;
struct {
uint8_t i8l;
uint8_t i8h;
};
} convert16to8;

...
convert16to8 baud;
baud.i16 = F_CPU / (UART_BAUD_RATE * 16L) -1;
UBRRH = baud.i8h;
UBRRL = baud.i8l;
...

/* Alternative 1:*/
#include <inttypes.h>

uint16_t wFoo16;
uint8_t bFooLow, bFooHigh;

...

wFoo16 = 0xAA55; /* zu "zerlegende" 16Bit-Integer */
bFooHigh = (uint8_t)(wFoo16 >> 8); /* MS-Byte */
bFooLow = (uint8_t)(wFoo16); /* LS-Byte */

/* Alternative 2:*/

#define us0(Data) (*((unsigned char *)(&Data)))
#define us1(Data) (*((unsigned char *)((&Data)+1)))
bFooHigh = us1(wFoo16);
bFoolow = us0(wFoo16);
...
</c>

Bei einigen AVR-Typen (z. B. ATmega8, ATMega16) teilen sich UBRRH und UCSRC die gleiche Memory-Adresse. Damit der AVR trotzdem zwischen den beiden Registern unterscheiden kann, bestimmt das Bit7 (URSEL) welches Register tatsächlich beschrieben werden soll. ''1000 0011'' (0x83) adressiert demnach UCSRC und übergibt den Wert ''3'' und ''0000 0011'' (0x3) adressiert UBRRH und übergibt ebenfalls den Wert ''3''.

Speziell bei den '''16-Bit-Timern''' und auch beim '''ADC''' ist es bei allen Zugriffen auf Datenregister erforderlich, dass diese Daten synchronisiert sind. Wenn z. B. bei einem 16-Bit-Timer das High-Byte des Zählregisters gelesen wurde und vor dem Lesezugriff auf das Low-Byte ein Überlauf des Low-Bytes stattfindet, erhält man einen völlig unsinnigen Wert. Auch die Compare-Register müssen synchron geschrieben werden, da es ansonsten zu unerwünschten Compare-Ereignissen kommen kann.

Beim ADC besteht das Problem darin, dass zwischen den Zugriffen auf die beiden Teilregister eine Wandlung beendet werden kann und der ADC ein neues Ergebnis in ADCL und ADCH schreiben will, wodurch High- und Low-Byte nicht zusammenpassen.

Um diese Datenmüllproduktion zu verhindern, gibt es in beiden Fällen eine Synchronisation, die jeweils durch den Zugriff auf das Low-Byte ausgelöst wird:
* Bei den Timer-Registern (das gilt für alle TCNT-, OCR- und ICR-Register bei den 16-Bit-Timern) wird bei einem '''Lesezugriff''' auf das Low-Byte automatisch das High-Byte in ein temporäres Register, das ansonsten nach außen nicht sichtbar ist, geschoben. Greift man nun ''anschließend'' auf das High-Byte zu, dann wird eben dieses temporäre Register gelesen.
* Bei einem '''Schreibzugriff''' auf eines der genannten Register wird das High-Byte in besagtem temporären Register zwischengespeichert und erst beim Schreiben des Low-Bytes werden ''beide'' gleichzeitig in das eigentliche Register übernommen.

Das bedeutet für die Reihenfolge beim '''Lesezugriff: Erst Low-Byte, dann High-Byte''' und für den '''Schreibzugriff: Erst High-Byte, dann Low-Byte'''.

Des weiteren ist zu beachten, dass es für all diese 16-Bit-Register nur ein einziges temporäres Register gibt, so dass das Auftreten eines Interrupts, in dessen Handler ein solches Register manipuliert wird, bei einem durch ihn unterbrochenen Zugriff i.d.R. zu Datenmüll führt. '''16-Bit-Zugriffe sind generell nicht atomar!''' Wenn mit '''Interrupts''' gearbeitet wird, kann es erforderlich sein, vor einem solchen Zugriff auf ein 16-Bit-Register die Interrupt-Bearbeitung zu deaktivieren.

Beim ADC-Datenregister ADCH/ADCL ist die Synchronisierung anders gelöst. Hier wird beim Lesezugriff (ADCH/ADCL sind logischerweise Read-only) auf das Low-Byte ADCL beide Teilregister für Zugriffe seitens des ADC so lange gesperrt, bis das High-Byte ADCH ausgelesen wurde. Dadurch kann der ADC nach einem Zugriff auf ADCL keinen neuen Wert in ADCH/ADCL ablegen, bis ADCH gelesen wurde. Ergebnisse von Wandlungen, die zwischen einem Zugriff auf ADCL und ADCH beendet werden, gehen verloren!

'''Nach einem Zugriff auf ADCL muss grundsätzlich ADCH gelesen werden!'''

In beiden Fällen (also sowohl bei den Timern als auch beim ADC) werden vom C-Compiler 16-Bit-Pseudo-Register zur Verfügung gestellt (z. B. TCNT1H/TCNT1L -> TCNT1, ADCH/ADCL -> ADC bzw. ADCW), bei deren Verwendung der Compiler automatisch die richtige Zugriffsreihenfolge regelt. '''In C-Programmen sollten grundsätzlich diese 16-Bit-Register verwendet werden'''. Sollte trotzdem ein Zugriff auf ein Teilregister erforderlich sein, sind obige Angaben zu berücksichtigen.

Es ist darauf zu achten, dass auch ein Zugriff auf die 16-Bit-Register vom Compiler in zwei 8-Bit-Zugriffe aufgeteilt wird und dementsprechend genauso nicht-atomar ist wie die Einzelzugriffe. Auch hier gilt, dass u.U. die Interrupt-Bearbeitung gesperrt werden muss, um Datenmüll zu vermeiden.

Beim ADC gibt es für den Fall, dass eine Auflösung von 8 Bit ausreicht, die Möglichkeit, das Ergebnis "linksbündig" in ADCH/ADCL auszurichten, so dass die relevanten 8 MSB in ADCH stehen. In diesem Fall muss bzw. sollte nur ADCH ausgelesen werden.

ADC und ADCW sind unterschiedliche Bezeichner für das selbe Registerpaar. Üblicherweise kann man in C-Programmen ADC verwenden, was analog zu den anderen 16-Bit-Registern benannt ist. ADCW (ADC Word) existiert nur deshalb, weil die Headerdateien auch für Assembler vorgesehen sind und es bereits einen Assembler-Befehl namens ''adc'' gibt.

Im Umgang mit 16-Bit Registern siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8
* Datenblatt Abschnitt ''Accessing 16-bit Registers''

== IO-Register als Parameter und Variablen ==

Um Register als Parameter für eigene Funktionen übergeben zu können, muss man sie als einen volatile uint8_t Pointer übergeben. Zum Beispiel:

<c>
#include <avr/io.h>
#include <util/delay.h>

uint8_t key_pressed(const volatile uint8_t *inputreg, uint8_t inputbit)
{
static uint8_t last_state = 0;

if ( last_state == ( *inputreg & (1<<inputbit) ) ) {
return 0; /* keine Änderung */
}

/* Wenn doch, warten bis etwaiges Prellen vorbei ist: */
_delay_ms(20);

/* Zustand für nächsten Aufruf merken: */
last_state = ( *inputreg & (1<<inputbit) );

/* und den entprellten Tastendruck zurückgeben: */
return ( *inputreg & (1<<inputbit) );
}

/* Beispiel für einen Funktionsaufruf: */

//...
uint8_t i;
//...
i = key_pressed( &PINB, PB1 );
//...
</c>

Ein Aufruf der Funktion mit call by value würde Folgendes bewirken: Beim Funktionseintritt wird nur eine Kopie des momentanen Portzustandes angefertigt, die sich unabhängig vom tatsächlichen Zustand das Ports nicht mehr ändert, womit die Funktion wirkungslos wäre. Die Übergabe eines Zeigers wäre die Lösung, wenn der Compiler nicht optimieren würde. Denn dadurch wird im Programm nicht von der Hardware gelesen, sondern wieder nur von einem Abbild im Speicher. Das Ergebnis wäre das gleiche wie oben. Mit dem Schlüsselwort volatile sagt man nun dem Compiler, dass die entsprechende Variable entweder durch andere Softwareroutinen (Interrupts) oder durch die Hardware verändert werden kann.

Im Übrigen können mit volatile gekennzeichnete Variablen auch als const deklariert werden, um sicherzustellen, dass sie nur noch von der Hardware änderbar sind.

= Zugriff auf IO-Ports =

Jeder AVR implementiert eine unterschiedliche Menge an GPIO-Registern
(GPIO - General Purpose Input/Output). Diese Register dienen dazu:
* einzustellen welche der Anschlüsse ("Beinchen") des Controllers als Ein- oder Ausgänge dienen
* bei Ausgängen deren Zustand festzulegen
* bei Eingängen deren Zustand zu erfassen

Mittels GPIO werden digitale Zustände gesetzt und erfasst, d.h. die Spannung an einem Ausgang wird ein- oder ausgeschaltet und an einem Eingang wird erfasst, ob die anliegende Spannung über oder unter einem bestimmten Schwellwert liegt. Im Datenblatt Abschnitt Electrical Characteristics/DC Characteristics finden sich die Spannungswerte (V_OL, V_OH für Ausgänge, V_IL, V_IH für Eingänge).

Die Verarbeitung von analogen Eingangswerten und die Ausgabe von Analogwerten wird in Kapitel [[AVR-GCC-Tutorial#Analoge_Ein-_und_Ausgabe|Analoge Ein- und Ausgabe]] behandelt.

Alle Ports der AVR-Controller werden über Register gesteuert. Dazu sind jedem Port 3 Register zugeordnet:

{| class="wikitable"
|-
! DDRx
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (abhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
! PINx
| Eingangsadresse für Port'''x'''.
Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der als Eingang definierten Portpins. Bit 1 wenn Pin "high", Bit 0 wenn Portpin low.
|-
! PORTx
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Bei Pins, die mittels DDRx auf Eingang geschaltet wurden, können über PORTx
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|}

Die folgenden Beispiele gehen von einem AVR aus, der sowohl Port A als auch Port B besitzt. Sie müssen für andere AVRs (zum Beispiel ATmega8/48/88/168) entsprechend angepasst werden.

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.

Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Beispiel:
Angenommen am Port B sollen die Pins 0 bis 4 als Ausgänge definiert werden, die noch verbleibenden Pins 5 bis 7 sollen als Eingänge fungieren. Dazu ist es daher notwendig, im für das Port B zuständigen Datenrichtungsregister DDRB folgende Bitkonfiguration einzutragen

+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+
7 6 5 4 3 2 1 0

In C liest sich das dann so:

<c>
// in io.h wird u.a. DDRB definiert:
#include <avr/io.h>

...

int main()
{
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
DDRB = 0x1F; /* direkte Zuweisung - unübersichtlich */

// übersichtliche Alternative - Binärschreibweise
DDRB = 0b00011111; /* direkte Zuweisung - übersichtlich */

/* Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
aber übersichtlicher und selbsterklärend: */
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);

...
</c>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet. Weitere Beispiele:

<c>
// Alle Pins des Ports B als Ausgang definieren:
DDRB = 0xff;
// Pin0 wieder auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~( 1 << DDB0 );
// Pin 3 und 4 auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~( ( 1 << DDB3 ) | ( 1<<DDB4) );
// Pin 0 und 3 wieder auf Ausgang und andere im ursprünglichen Zustand belassen:
DDRB |= ( 1 << DDB0) | ( 1 << DDB3 );
// Alle Pins auf Eingang:
DDRB = 0x00;
</c>

== Vordefinierte Bitnummern für I/O-Register ==

Die Bitnummern (z. B. PCx, PINCx und DDCx für den Port C) sind in den io*.h-Dateien der avr-libc definiert und dienen lediglich der besseren Lesbarkeit. Man muss diese Definitionen nicht verwenden oder kann auch einfach "immer" PAx, PBx, PCx usw. nutzen, auch wenn der Zugriff auf Bits in DDRx- oder PINx-Registern erfolgt. Für den Compiler sind die Ausdrücke (1<<PC7), (1<<DDC7) und (1<<PINC7) identisch zu (1<<7) (genauer: der Präprozessor ersetzt die Ausdrücke (1<<PC7),... zu (1<<7)). Ein Ausschnitt der Definitionen für Port C eines ATmega32 aus der iom32.h-Datei zur Verdeutlichung (analog für die weiteren Ports):

<c>
...
/* PORTC */
#define PC7 7
#define PC6 6
#define PC5 5
#define PC4 4
#define PC3 3
#define PC2 2
#define PC1 1
#define PC0 0

/* DDRC */
#define DDC7 7
#define DDC6 6
#define DDC5 5
#define DDC4 4
#define DDC3 3
#define DDC2 2
#define DDC1 1
#define DDC0 0

/* PINC */
#define PINC7 7
#define PINC6 6
#define PINC5 5
#define PINC4 4
#define PINC3 3
#define PINC2 2
#define PINC1 1
#define PINC0 0
</c>

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen bzw. auszugeben.

== Ausgänge ==
Will man als Ausgang definierte Pins (entsprechende DDRx-Bits = 1) auf Logisch 1 setzen, setzt man die entsprechenden Bits im Portregister.

Mit dem Befehl
<c>
#include <avr/io.h>
...
PORTB = 0x04; /* besser PORTB=(1<<PB2) */

// übersichtliche Alternative - Binärschreibweise
PORTB = 0b00000100; /* direkte Zuweisung - übersichtlich */

</c>
wird also der Ausgang an Pin PB2 gesetzt (Beachte, dass die Bits immer ''von 0 an'' gezählt werden, das niederwertigste Bit ist also Bitnummer 0 und nicht etwa Bitnummer 1).

Man beachte, dass bei der Zuweisung mittels '''=''' immer alle Pins gleichzeitig angegeben werden. Man sollte also, wenn nur bestimmte Ausgänge geschaltet werden sollen, zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfließen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an Port B auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<c>
#include <avr/io.h>
...
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<PB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<PB2);

/* auch mehrere "gleichzeitig": */
PORTB |= (1<<PB4) | (1<<PB5); /* Pins PB4 und PB5 "high" */
</c>

"Ausschalten", also Ausgänge auf "low" setzen, erfolgt analog:

<c>
#include <avr/io.h>
...
PORTB &= ~(1<<PB2); /* löscht Bit 2 in PORTB und setzt damit Pin PB2 auf low */
PORTB &= ~( (1<<PB4) | (1<<PB5) ); /* Pin PB4 und Pin PB5 "low" */
</c>
Siehe auch [[Bitmanipulation]]

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind in aktuellen Versionen der avr-libc nicht mehr enthalten und auch nicht mehr erforderlich.

''Falls der Anfangszustand von Ausgängen kritisch ist, muss die Reihenfolge beachtet werden, mit der die Datenrichtung (DDRx) eingestellt und der Ausgabewert (PORTx) gesetzt wird:''

Für Ausgangspins, die mit Anfangswert "high" initialisiert werden sollen:
* zuerst die Bits im PORTx-Register setzen
* anschließend die Datenrichtung auf Ausgang stellen

Daraus ergibt sich die Abfolge für einen Pin, der bisher als Eingang mit abgeschaltetem Pull-Up konfiguriert ware:
* setze PORTx: interner Pull-Up aktiv
* setze DDRx: Ausgang ("high")

Bei der Reihenfolge erst DDRx und dann PORTx, kann es zu einem kurzen "low-Puls" kommen, der auch externe Pull-Up-Widerstände "überstimmt". Die (ungünstige) Abfolge: Eingang -> setze DDRx: Ausgang (auf "low", da PORTx nach Reset 0) -> setze PORTx: Ausgang auf high. Vergleiche dazu auch das Datenblatt Abschnitt ''Configuring the Pin''.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wir den Pegel über entsprechende Hardware (z. B. Optokoppler, [[Widerstand#Spannungsteiler|Spannungsteiler]], "Levelshifter" aka [[Pegelwandler]]) anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unseres Controllers eine logische 1 (Spannung größer ca. 0,7*Vcc) oder eine logische 0 (Spannung kleiner ca. 0,2*Vcc) anliegt. Detaillierte Informationen darüber, ab welcher Spannung ein Eingang als 0 ("low") bzw. 1 ("high") erkannt wird, liefert die Tabelle DC Characteristics im Datenblatt des genutzten Controllers.

{| class="wikitable" style="text-align:center"
|+ '''Spannungstabelle''' (ca. Grenzwerte)
|
! Low || High
|-
! bei 5 V
| 1 V || 3,5 V
|-
! bei 3,3 V
| 0,66 V || 2,31 V
|-
! bei 1,8 V
| 0,36 V || 1,26 V
|}

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.

{{Warnung|Dabei ist wichtig, zur Abfrage der Eingänge ''nicht'' etwa Portregister '''PORTx''' zu verwenden, sondern Eingangsregister '''PINx'''. Ansonsten liest man nicht den Zustand der Eingänge, sondern den Status der internen Pull-Up-Widerstände. Die Abfrage der Pinzustände über PORTx statt PINx ist ein häufiger Fehler beim AVR-"Erstkontakt".}}

Will man also die aktuellen Signalzustände von Port D abfragen und in eine Variable namens bPortD abspeichern, schreibt man folgende Befehlszeilen:

<c>
#include <avr/io.h>
#include <stdint.h>
...
uint8_t bPortD;
...
bPortD = PIND;
...
</c>

Mit den C-Bitoperationen kann man den Status der Bits abfragen.

<c>
#include <avr/io.h>
...
/* Fuehre Aktion aus, wenn Bit Nr. 1 (das "zweite" Bit) in PINC gesetzt (1) ist */
if ( PINC & (1<<PINC1) ) {
/* Aktion */
}

/* Fuehre Aktion aus, wenn Bit Nr. 2 (das "dritte" Bit) in PINB geloescht (0) ist */
if ( !(PINB & (1<<PINB2)) ) {
/* Aktion */
}
...
</c>
Siehe auch [[Bitmanipulation#Bits_prüfen]]

=== Interne Pull-Up Widerstände ===

Portpins für Ein- und Ausgänge (GPIO) eines AVR verfügen über zuschaltbare interne Pull-Up Widerstände (nominal mehrere 10kOhm, z. B. ATmega16 20-50kOhm). Diese können in vielen Fällen statt externer Widerstände genutzt werden.

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang''' geschaltet ist.

Wird der Wert des entsprechenden Portpins auf 1 gesetzt, so ist der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up Widerstand nicht aktiv. Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand verwenden, aber nicht beide zusammen.

Im Beispiel werden alle Pins des Ports D als Eingänge geschaltet und alle Pull-Up Widerstände aktiviert. Weiterhin wird Pin PC7 als Eingang geschaltet und dessen interner Pull-Up Widerstand aktiviert, ohne die Einstellungen für die anderen Portpins (PC0-PC6) zu verändern.

<c>
#include <avr/io.h>
...
DDRD = 0x00; /* alle Pins von Port D als Eingang */
PORTD = 0xff; /* interne Pull-Ups an allen Port-Pins aktivieren */
...
DDRC &= ~(1<<DDC7); /* Pin PC7 als Eingang */
PORTC |= (1<<PC7); /* internen Pull-Up an PC7 aktivieren */
</c>

=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller gestaltet sich ebenfalls ganz einfach, wobei wir zwei unterschiedliche Methoden unterscheiden müssen: ''Active Low'' und ''Active High''.

<gallery widths="300" heights="300" caption="Anschluss mechanischer Kontakte an einen µC">
Image:Active Low.gif|'''Active Low:''' Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet. Damit bei offenem Schalter der Controller kein undefiniertes Signal bekommt wird zwischen die Versorgungsspannung und den Eingangspin ein sogenannter '''Pull-Up''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffnetem Schalter auf logisch 1 zu ziehen.
Image:Active High.gif|'''Active High:''' Hier wird der Kontakt zwischen die Versorgungsspannung und den Eingangspin geschaltet. Damit bei offener Schalterstellung kein undefiniertes Signal am Controller ansteht, wird zwischen den Eingangspin und die Masse ein '''Pull-Down''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter Schalterstellung auf logisch 0 zu halten. Der Pull-Down-Widerstand muß extern geschaltet werden.
</gallery>

Der Widerstandswert von Pull-Up- und Pull-Down-Widerständen ist an sich nicht kritisch. Wird er allerdings zu hoch gewählt, ist die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10 kOhm eingebürgert. Die AVRs verfügen an den meisten Pins softwaremäßig über zuschaltbare interne Pull-Up Widerstände (vgl. Abschnitt [[AVR-GCC-Tutorial#Interne Pull-Up Widerstände|Interne Pull-Up Widerstände]]), welche insbesondere wie hier bei Tastern und ähnlichen Bauteilen (z. B. Drehgebern) statt externer Bauteile verwendet werden können.

==== (Tasten-)Entprellung ====

Nun haben alle mechanischen Kontakte, sei es von Schaltern, Tastern oder auch von Relais, die unangenehme Eigenschaft zu prellen. Dies bedeutet, dass beim Schließen des Kontaktes derselbe nicht direkt Kontakt herstellt, sondern mehrfach ein- und ausschaltet bis zum endgültigen Herstellen des Kontaktes.

Soll nun mit einem schnellen Mikrocontroller gezählt werden, wie oft ein solcher Kontakt geschaltet wird, dann haben wir ein Problem, weil das Prellen als mehrfache Impulse gezählt wird. Diesem Phänomen muss beim Schreiben des Programms unbedingt Rechnung getragen werden.

Beim folgenden einfachen Beispiel für eine Entprellung ist zu beachten, dass der AVR im Falle eines Tastendrucks 200ms wartet, also brach liegt. Bei zeitkritische Anwendungen sollte man ein anderes Verfahren nutzen (z. B. Abfrage der Tastenzustände in einer Timer-Interrupt-Service-Routine).

<c>
#include <avr/io.h>
#include <inttypes.h>
#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h> /* bei alter avr-libc: #include <avr/delay.h> */

/* Einfache Funktion zum Entprellen eines Tasters */
inline uint8_t debounce(volatile uint8_t *port, uint8_t pin)
{
if ( ! (*port & (1 << pin)) )
{
/* Pin wurde auf Masse gezogen, 100ms warten */
_delay_ms(50); // max. 262.1 ms / F_CPU in MHz
_delay_ms(50);
if ( *port & (1 << pin) )
{
/* Anwender Zeit zum Loslassen des Tasters geben */
_delay_ms(50);
_delay_ms(50);
return 1;
}
}
return 0;
}

int main(void)
{
DDRB &= ~( 1 << PB0 ); /* PIN PB0 auf Eingang (Taster) */
PORTB |= ( 1 << PB0 ); /* Pullup-Widerstand aktivieren */
...
if (debounce(&PINB, PB0)) /* Falls Taster an PIN PB0 gedrueckt.. */
PORTD = PIND ^ ( 1 << PD7 ); /* ..LED an Port PD7 an-
bzw. ausschalten */
...
}
</c>

Die obige Routine hat leider mehrere Nachteile:
* sie detektiert nur das Loslassen (unergonomisch)
* sie verzögert die Mainloop immer um 100ms bei gedrückter Taste
* sie verliert Tastendrücke, je mehr die Mainloop zu tun hat.

Eine ähnlich einfach zu benutzende Routine, aber ohne all diese Nachteile findest Du hier:
[http://www.mikrocontroller.net/topic/164194#new Entprellung für Anfänger]

Zum Thema Entprellen siehe auch:
* Artikel [[Entprellung]]

= Analoge Ein- und Ausgabe =

Analoge Eingangswerte werden in der Regel über den AVR Analog-Digital-Converter (AD-Wandler, ADC) eingelesen, der in vielen Typen verfügbar ist (typisch 10bit Auflösung). Durch diesen werden analoge Signale (Spannungen) in digitale Zahlenwerte gewandelt. Bei AVRs, die über keinen internen AD-Wandler verfügen (z. B. ATmega162), kann durch externe Beschaltung (R/C-Netzwerk und "Zeitmessung") die Funktion des AD-Wandlers "emuliert" werden.

Es existieren keine AVRs mit eingebautem Digital-Analog-Konverter (DAC). Diese Funktion muss durch externe Komponenten nachgebildet werden (z. B. PWM und "Glättung").

Unabhängig davon besteht natürlich immer die Möglichkeit, spezielle Bausteine zur Analog-Digital- bzw. Digital-Analog-Wandlung zu nutzen und diese über eine digitale Schnittstelle (z.b. SPI oder I2C) mit einem AVR anzusteuern.

== AC (Analog Comparator) ==

Der Comparator vergleicht 2 Spannungen an den Pins AIN0 und AIN1 und gibt einen Status aus welche der beiden Spannungen größer ist. AIN0 Dient dabei als Referenzspannung (Sollwert) und AIN1 als Vergleichsspannung (Istwert). Als Referenzspannung kann auch alternativ eine interne Referenzspannung ausgewählt werden.

Liegt die Vergleichsspannung (IST) unter der der Referenzspannung (SOLL) gibt der Comperator eine logische 1 aus. Ist die Vergleichsspannung hingegen größer als die Referenzspannung wird eine logische 0 ausgegeben.

Der Comparator arbeitet völlig autark bzw. parallel zum Prozessor. Für mobile Anwendungen empfiehlt es sich ihn abzuschalten sofern er nicht benötigt wird, da er ansonsten Strom benötigt. Der Comparator kann Interruptgesteuert abgefragt werden oder im Pollingbetrieb.

Das Steuer- bzw. Statusregister ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|+ '''ACSR - Analog Comparator Status Register'''
|-
! Bit
| 7|| 6|| 5|| 4|| 3|| 2|| 1|| 0
|-
! Name
| '''ACD'''|| '''ACBG'''|| '''ACO'''|| '''ACI'''|| '''ACIE'''|| '''ACIC'''|| '''ACIS1'''|| '''ACIS0'''
|-
! R/W
| R/W|| R/W|| R|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| n/a|| 0|| 0|| 0|| 0|| 0
|}

;Bit 7 ACD: Analog Comparator Disable: 0 = Comparator ein, 1 = Comparator aus. Wird dieses Bit geändert kann ein Interrupt ausgelöst werden. Soll dies vermieden werden muß das Bit 3 ACIE ggf. abgeschaltet werden.

;Bit 6 ACBG: Analog Comparator Bandgap Select: Ermöglicht das umschalten zwischen interner und externer Referenzspannung. 1 = interne (~1,3 Volt), 0 = externe Referenzspannung (an Pin AIN0)

;Bit 5 ACO: Analog Comparator Output: Hier wird das Ergebnis des Vergleichs angezeigt. Es liegt typischerweise nach 1-2 Taktzyklen vor.
:: IST < SOLL → 1
:: IST > SOLL → 0

;Bit 4 ACI: Analog Comparator Interrupt Flag: Dieses Bit wird von der Hardware gesetzt wenn ein Interruptereignis das in Bit 0 und 1 definiert ist eintritt. Dieses Bit löst noch keinen Interrupt aus! Die Interruptroutine wird nur dann ausgeführt wenn das Bit 3 ACIE gesetzt ist und global Interrupts erlaubt sind (I-Bit in SREG=1). Das Bit 4 ACI wird wieder gelöscht wenn die Interruptroutine ausgeführt wurde oder wenn manuell das Bit auf 1 gesetzt wird. Das Bit kann für Abfragen genutzt werden, steuert oder konfiguriert aber nicht den Comparator.

;Bit 3 ACIE: Analog Comparator Interrupt Enable: Ist das Bit auf 1 gesetzt wird immer ein Interrupt ausgelöst wenn das Ereignis das in Bit 1 und 0 definiert ist eintritt.

;Bit 2 ACIC: Analog Comparator Input Capture Enable: Wird das Bit gesetzt wird der Comparatorausgang intern mit dem Counter 1 verbunden. Es könnten damit z.b. die Anzahl der Vergleiche im Counter1 gezählt werden. Um den Comparator an den Timer1 Input Capture Interrupt zu verbinden muß im Timerregister das TICIE1 Bit auf 1 gesetzt werden. Der Trigger wird immer dann ausgelöst wenn das in Bit 1 und 0 definierte Ereignis eintritt.

;Bit 1,0 ACIS1,ACIS0: Analog Comparator Interrupt select: Hier wird definiert welche Ereignisse einen Interrupt auslösen sollen:
:* 00 = Interrupt auslösen bei jedem Flankenwechsel
:* 10 = Interrupt auslösen bei fallender Flanke
:* 11 = Interrupt auslösen bei steigender Flanke

Werden diese Bit geändert kann ein Interrupt ausgelöst werden. Soll dies vermieden werden muß das Bit 3 gelöscht werden.

== ADC (Analog Digital Converter) ==

Der Analog-Digital-Konverter (ADC) wandelt analoge Signale in digitale Werte um, welche vom Controller interpretiert werden können. Einige AVR-Typen haben bereits einen mehrkanaligen Analog-Digital-Konverter eingebaut. Die Genauigkeit, mit welcher ein analoges Signal aufgelöst werden kann, wird durch die Auflösung des ADC in Anzahl Bits angegeben, man hört bzw. liest jeweils von 8-Bit-ADC oder 10-Bit-ADC oder noch höher. ADCs die in AVRs enthalten sind haben zur Zeit eine maximale Auflösung von 10-Bit.

Ein ADC mit 8 Bit Auflösung kann somit das analoge Signal mit einer Genauigkeit von 1/256 des Maximalwertes darstellen. Wenn wir nun mal annehmen, wir hätten eine Spannung zwischen 0 und 5 Volt und eine Auflösung von 3 Bit, dann könnten
die Werte 0V, 0.625V, 1.25, 1.875V, 2.5V, 3.125V, 3.75, 4.375, 5V
daherkommen, siehe dazu folgende Tabelle:

::{| class="wikitable" style="text-align:center"
! Eingangsspannung am ADC [V] || Entsprechender Messwert
|-
| 0–0.625 || 0
|-
| 0.625–1.25 || 1
|-
| 1.25–1.875 || 2
|-
| 1.875–2.5 || 3
|-
| 2.5–3.125 || 4
|-
| 3.125–3.75 || 5
|-
| 3.75–4.375 || 6
|-
| 4.375–5 || 7
|}

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des Analog-Digital-Konverters ist, also je mehr Bits er hat, um so genauer kann der Wert erfasst werden.

=== Der interne ADC im AVR ===

Wenn es einmal etwas genauer sein soll, dann müssen wir auf einen AVR mit eingebautem Analog-Digital-Wandler (ADC) zurückgreifen, die über mehrere Kanäle verfügen. Kanäle heißt in diesem Zusammenhang, dass zwar bis zu zehn analoge Eingänge am AVR verfügbar sind, aber nur ein "echter" Analog-Digital-Wandler zur Verfügung steht, vor der eigentlichen Messung ist also einzustellen, welcher Kanal ("Pin") mit dem Wandler verbunden und gemessen wird.

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung, die 10uH und 100nF vorsieht.

Das Ergebnis der Analog-Digital-Wandlung wird auf eine Referenzspannung bezogen. Aktuelle AVRs bieten 3 Möglichkeiten zur Wahl dieser Spannung:

* Eine externe Referenzspannung von maximal '''Vcc''' am Anschlusspin '''AREF'''. Die minimale (externe) Referenzspannung darf jedoch nicht beliebig niedrig sein, vgl. dazu das (aktuellste) Datenblatt des verwendeten Controllers.

* Verfügt der AVR über eine interne Referenzspannung, kann diese genutzt werden. Alle aktuellen AVRs mit internem AD-Wandler sollten damit ausgestattet sein (vgl. Datenblatt: 2,56V oder 1,1V je nach Typ). Das Datenblatt gibt auch über die Genauigkeit dieser Spannung Auskunft.

* Es kann die Spannung AVcc als Referenzspannung herangezogen werden

Bei Nutzung von AVcc oder der internen Referenz wird empfohlen, einen Kondensator zwischen dem AREF-Pin und GND anzuordnen. Die Festlegung, welche Spannungsreferenz genutzt wird, erfolgt z. B. beim ATmega16 mit den Bits REFS1/REFS0 im ADMUX-Register. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden:

; Einfache Wandlung (Single Conversion) : In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestoßen für jeweils eine Messung.

; Frei laufend (Free Running) : In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register. Im Folgenden die Registerbeschreibung eines ATMega16, welcher über 8 ADC-Kanäle verfügt. Die Register unterscheiden sich jedoch nicht erheblich von denen anderer AVRs (vgl. Datenblatt).

{| class="wikitable"
|-
| '''ADCSRA   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister A. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7|| 6|| 5|| 4|| 3|| 2|| 1|| 0
|-
! Name
| '''ADEN'''|| '''ADSC'''|| '''ADFR'''|| '''ADIF'''|| '''ADIE'''|| '''ADPS2'''|| '''ADPS1'''|| '''ADPS0'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt ist, können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''F'''ree '''R'''un select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Ist das Bit auf 1 gesetzt arbeitet der ADC im Freerunning Modus. Dabei wird das Datenregister permanent aktualisiert. Ist das Bit hingegen auf 0 gesetzt macht der ADC nur eine Single Conversion.

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, sobald eine Umwandlung erfolgt ist und das '''ADC Data Register''' aktualisiert wurde. Das Bit wird bei lesendem Zugriff auf '''ADC(L,H)''' automatisch (d.h. durch die Hardware) gelöscht.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische 1 in das Register geschrieben wird.

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz sein.
:Der Vorteiler muss also so eingestellt werden, dass die CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert zwischen 50-200kHz ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200\,\mathrm{kHz}}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50\,\mathrm{kHz}}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.

:{| class="wikitable" style="text-align:center"
|-
! '''ADPS2'''|| '''ADPS1'''|| '''ADPS0'''|| '''Teilungsfaktor'''
|-
| 0|| 0|| 0|| 2
|-
| 0|| 0|| 1|| 2
|-
| 0|| 1|| 0|| 4
|-
| 0|| 1|| 1|| 8
|-
| 1|| 0|| 0|| 16
|-
| 1|| 0|| 1|| 32
|-
| 1|| 1|| 0|| 64
|-
| 1|| 1|| 1|| 128
|}

|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden, und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<c>
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
// C-Operatorpriorität sichergestellt)
</c>

oder

<c>
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</c>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7|| 6|| 5|| 4|| 3|| 2|| 1|| 0
|-
! Name
| '''REFS1'''|| '''REFS0'''|| '''ADLAR'''|| '''MUX4'''|| '''MUX3'''|| '''MUX2'''|| '''MUX1'''|| '''MUX0'''
|-
! '''R/W'''
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''REFS1...REFS0''' ('''Ref'''erence'''S'''election Bits)
:Mit diesen Bits kann die Referenzspannung eingestellt werden. Bei der Umstellung sind Wartezeiten zu beachten, bis die ADC-Hardware einsatzfähig ist (Datenblatt und [http://www.mikrocontroller.net/topic/165513]):

{| class="wikitable" style="text-align:center"
|-
! '''REFS1'''|| '''REFS0'''|| '''Referenzspanung'''
|-
| 0|| 0|| Externes AREF
|-
| 0|| 1|| AVCC als Referenz
|-
| 1|| 0|| Reserviert
|-
| 1|| 1|| Interne 2,56 Volt
|}

'''ADLAR''' ('''ADC ''' '''L'''eft '''A'''djust '''R'''esult)
:Das ADLAR Bit verändert das Aussehen des Ergebnisses der AD-Wandlung. Bei einer logischen 1 wird das Ergebnis linksbündig ausgegeben, bei einer 0 rechtsbündig. Eine Änderung in diesem Bit beeinflusst das Ergebnis sofort, ganz egal ob bereits eine Wandlung läuft.

'''MUX4...MUX0'''
:Mit diesen 5 Bits wird der zu messende Kanal bestimmt. Wenn man einen einfachen 1-kanaligen ADC verwendet wird einfach die entsprechende Pinnummer des Ports in die Bits 0...2 eingeschrieben.
:Wenn das Register beschrieben wird, während dem eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Eine Empfehlung ist deswegen diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Nutzung des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register setzen. Im gleichen Schritt legen wir auch die Betriebsart fest.

Ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls muss es mit einem [[Spannungsteiler]] verringert werden. Das Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1023 für V_ref-Volt.

In der praktischen Anwendung wird man zum Programmstart den ADC erst einmal grundlegend konfigurieren und dann auf verschiedenen Kanälen messen. Diese beiden Dinge sollte man meist trennen, denn das Einschalten des ADC und vor allem der Referenzspannung dauert ein paar Dutzend Mikrosekunden. Ausserdem ist das erste Ergebnis nach dem Einschalten ungültig und muss verworfen werden.

<c>

/* ADC initialisieren */
void ADC_Init(void) {

uint16_t result;

ADMUX = (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen
ADCSRA = (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler
ADCSRA |= (1<<ADEN); // ADC aktivieren

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

ADCSRA |= (1<<ADSC); // eine ADC-Wandlung
while (ADCSRA & (1<<ADSC) ); // auf Abschluss der Konvertierung warten
/* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
Wandlung nicht übernommen. */
result = ADCW;
}

/* ADC Einzelmessung */
uint16_t ADC_Read(uint8_t channel)
{
// Kanal waehlen, ohne andere Bits zu beeinflußen
ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while (ADCSRA & (1<<ADSC) ); // auf Abschluss der Konvertierung warten
return ADCW; // ADC auslesen und zurückgeben
}

/* ADC Mehrfachmessung mit Mittelwertbbildung */
uint16_t ADC_Read_Avg(uint8_t channel, uint8_t average)
{
uint32_t result;

// Kanal waehlen, ohne andere Bits zu beeinflußen
ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);

/* Eigentliche Messung - Mittelwert aus 'average' aufeinanderfolgenden Wandlungen */
result = 0;

for (uint8_t i = average; i>0; i-- ) {
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while (ADCSRA & (1<<ADSC) ); // auf Abschluss der Konvertierung warten
result += ADCW; // Wandlungsergebnisse aufaddieren
}

result /= average; // arithmethischer Mittelwert
return (uint16_t)result;
}

...

/* Beispielaufrufe: */

void foo(void)
{
uint16_t adcval;
ADC_Init();

adcval = ADC_Read(0); // Kanal 0
adcval = ADC_Read_Avg(2, 4); // Kanal 2, Mittelwert aus 4 Messungen
}

</c>

Im Beispiel läuft der ADC ständig. Wenn man diesen Strom sparen will, z.B. bei Verwendung des [[Sleep Mode]]s, muss man den ADC nach jeder Messung abschalten und vor der nächsten Messung wieder einschalten, wobei auch dann wieder eine kleine Pause und Anfangswandlung nötig sind.



=== Analog-Digital-Wandlung ohne internen ADC ===

==== Messen eines Widerstandes ====

[[Image:Poti.gif|framed|right]]
Analoge Werte lassen sich ohne Analog-Digital-Wandler auch indirekt ermitteln. Im Folgenden wird die Messung des an einem Potentiometer eingestellten Widerstands anhand der Ladekurve eines Kondensators erläutert. Bei dieser Methode wird nur ein Portpin benötigt, ein Analog-Digital-Wandler oder Analog-Comparator ist nicht erforderlich. Es wird dazu ein Kondensator und der Widerstand (das Potentiometer) in Reihe zwischen Vorsorgungsspannung und Masse/GND geschaltet (sogen. RC-Netzwerk). Zusätzlich wird eine Verbindung der Leitung zwischen Kondensator und Potentiometer zu einem Portpin des Controllers hergestellt. Die folgende Abbildung verdeutlicht die erforderliche Schaltung.

Wird der Portpin des Controllers auf Ausgang konfiguriert (im Beispiel ''DDRD |= (1<<PD2)'') und dieser Ausgang auf Logisch 1 ("High", ''PORTD |= (1<<PD2)'') geschaltet, liegt an beiden "Platten" des Kondensators das gleiche Potential '''VCC''' an und der Kondensator somit entladen. (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen).

Nach einer gewissen Zeit ist der Kondensator entladen und der Portpin wird als Eingang konfiguriert (''DDRD &= ~(1<<PD2); PORTD &= ~(1<<PD2)''), wodurch dieser hochohmig wird. Der Status des Eingangspin (in PIND) ist Logisch 1 (High). Der Kondensator lädt sich jetzt über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti unter die Thresholdspannung des Eingangspins (2/5 Vcc, also ca. 2V), wird das Eingangssignal als LOW erkannt (Bit in PIND wird 0). Die Zeitspanne zwischen der Umschaltung von Entladung auf Aufladung und dem Wechsel des Eingangssignals von High auf Low ist ein Maß für den am Potentiometer eingestellten Widerstand. Zur Zeitmessung kann einer der im Controller vorhandenen Timer genutzt werden. Der 220 Ohm Widerstand dient dem Schutz des Controllers. Es würde sonst bei Maximaleinstellung des Potentionmeters (hier 0 Ohm) ein zu hoher Strom fließen, der die Ausgangsstufe des Controllers zerstört.

Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B: 0...100 % oder so) umzurechnen.



==== ADC über Komparator ====

[[Image:ADC ueber Komparator.gif|framed|right]]
Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert.
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen und
zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit
direkt Spannungen gemessen werden können.

== DAC (Digital Analog Converter) ==

Mit Hilfe eines Digital-Analog-Konverters ('''DAC''') können wir nun auch Analogsignale ausgeben. Es gibt hier mehrere Verfahren. 

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie [[PWM]] eigentlich funktioniert.

Wie wir alle wissen, ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen HIGH und LOW umschalten? - Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen arithmetischen Mittelwert,
der je nach Pulsbreite kleiner oder größer ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein RC-Glied filtern/"glätten", dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVRs können wir direkt PWM-Signale erzeugen.
Dazu dient der 16-Bit Zähler, welcher im sogenannten PWM-Modus betrieben werden kann.

;Hinweis: In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt, weshalb ein Blick ins entsprechende Datenblatt dringend angeraten wird.

Um den PWM-Modus zu aktivieren, müssen im Timer/Counter1 Control
Register A TCCR1A die Pulsweiten-Modulatorbits PWM10 bzw. PWM11 entsprechend nachfolgender Tabelle gesetzt werden:

{| class="wikitable" style="text-align:center"
|-
! PWM11 || PWM10 || Bedeutung
|-
| 0 || 0 || PWM-Modus des Timers ist nicht aktiv
|-
| 0 || 1 || 8-Bit PWM
|-
| 1 || 0 || 9-Bit PWM
|-
| 1 || 1 || 10-Bit PWM
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben.
Die Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| class="wikitable"
|-
! Auflösung || Obergrenze || Frequenz
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| class="wikitable"
|-
! COM1A1 || COM1A0 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl, um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden, heißt dann:

alte Schreibweise (PWMxx wird nicht mehr akzeptiert)
<c>
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</c>
neue Schreibweise
<c>
TCCR1A = (1<<WGM11)|(1<<WGM10)|(1<<COM1A1);
</c>

Damit der Timer/Counter überhaupt läuft, müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorteiler) einstellen und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| class="wikitable"
|-
! CS12 || CS11 || CS10 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<c>
TCCR1B = (1<<CS12) | (1<<CS10);
</c>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<c>
OCR1A = xxx;
</c>

Die folgende Grafik soll den Zusammenhang zwischen dem Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch beim AT90S2313 nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren. Andere AVR-Typen verfügen über bis zu vier PWM-Ausgänge. Zu beachten ist außerdem, das wenn der OC Pin aktiviert ist, er nichtmehr wie üblich funktioniert und z. B. nicht einfach über PINx ausgelesen werden kann.

Ein Programm, welches an einem ATmega8 den Fast-PWM Modus verwendet, den Modus 14, könnte so aussehen
<C>
#include <avr/io.h>

int main()
{
// OC1A auf Ausgang
DDRB = (1 << PB1 ); //ATMega8
// DDRD = (1 << PD5 ); //ATMega16
//
// Timer 1 einstellen
//
// Modus 14:
// Fast PWM, Top von ICR1
//
// WGM13 WGM12 WGM11 WGM10
// 1 1 1 0
//
// Timer Vorteiler: 1
// CS12 CS11 CS10
// 0 0 1
//
// Steuerung des Ausgangsport: Set at BOTTOM, Clear at match
// COM1A1 COM1A0
// 1 0

TCCR1A = (1<<COM1A1) | (1<<WGM11);
TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS10);

// den Endwert (TOP) für den Zähler setzen
// der Zähler zählt bis zu diesem Wert

ICR1 = 0x6FFF;

// der Compare Wert
// Wenn der Zähler diesen Wert erreicht, wird mit
// obiger Konfiguration der OC1A Ausgang abgeschaltet
// Sobald der Zähler wieder bei 0 startet, wird der
// Ausgang wieder auf 1 gesetzt
//
// Durch Verändern dieses Wertes, werden die unterschiedlichen
// PWM Werte eingestellt.

OCR1A = 0x3FFF;

while( 1 )
;
}
</C>

{| class="wikitable" style="text-align:center"
|+ '''PWM-Mode Tabelle aus dem Datenblatt des ATmega8515'''
|-
!Mode || WGM13 || WGM12 || WGM11 || WGM10 || Timer/Counter Mode of Operation
! TOP|| Update of OCR1x at || TOV1 Flag set on
|-
! 0
| 0
| 0
| 0
| 0
| Normal
| 0xFFFF
| Immediate
| MAX
|-
! 1
| 0
| 0
| 0
| 1
| PWM, Phase Correct, 8-Bit
| 0x00FF
| TOP
| BOTTOM
|-
! 2
| 0
| 0
| 1
| 0
| PWM, Phase Correct, 9-Bit
| 0x01FF
| TOP
| BOTTOM
|-
! 3
| 0
| 0
| 1
| 1
| PWM, Phase Correct, 10-Bit
| 0x03FF
| TOP
| BOTTOM
|-
! 4
| 0
| 1
| 0
| 0
| CTC
| OCR1A
| Immediate
| MAX
|-
! 5
| 0
| 1
| 0
| 1
| Fast PWM, 8-Bit
| 0x00FF
| BOTTOM
| TOP
|-
! 6
| 0
| 1
| 1
| 0
| Fast PWM, 9-Bit
| 0x01FF
| BOTTOM
| TOP
|-
! 7
| 0
| 1
| 1
| 1
| Fast PWM, 10-Bit
| 0x03FF
| BOTTOM
| TOP
|-
! 8
| 1
| 0
| 0
| 0
| PWM, Phase an Frequency Correct
| ICR1
| BOTTOM
| BOTTOM
|-
! 9
| 1
| 0
| 0
| 1
| PWM, Phase an Frequency Correct
| OCR1A
| BOTTOM
| BOTTOM
|-
! 10
| 1
| 0
| 1
| 0
| PWM, Phase Correct
| ICR1
| TOP
| BOTTOM
|-
! 11
| 1
| 0
| 1
| 1
| PWM, Phase an Frequency Correct
| OCR1A
| TOP
| BOTTOM
|-
! 12
| 1
| 1
| 0
| 0
| CTC
| ICR1
| Immediate
| MAX
|-
! 13
| 1
| 1
| 0
| 1
| Reserved
| -
| -
| -
|-
! 14
| 1
| 1
| 1
| 0
| Fast PWM
| ICR1
| BOTTOM
| TOP
|-
! 15
| 1
| 1
| 1
| 1
| Fast PWM
| OCR1A
| BOTTOM
| TOP
|}

Für Details der PWM Möglichkeiten, muß immer das jeweilge Datenblatt des Prozessors konsultiert werden, da sich die unterschiedlichen Prozessoren in ihren Möglichkeiten doch stark unterscheiden. Auch muß man aufpassen, welches zu setzende Bit in welchem Register ist. Auch hier kann es sein, dass gleichnamige Konfigurationsbits in unterschiedlichen Konfigurationsregistern (je nach konkretem Prozessortyp) sitzen.

= Warteschleifen (delay.h) =

Der Programmablauf kann verschiedene Arten von Wartefunktionen erfordern:

* Warten im Sinn von Zeitvertrödeln
* Warten auf einen bestimmten Zustand an den I/O-Pins
* Warten auf einen bestimmten Zeitpunkt (siehe Timer)
* Warten auf einen bestimmten Zählerstand (siehe Counter)

Der einfachste Fall, das Zeitvertrödeln, kann in vielen Fällen und mit großer Genauigkeit anhand der avr-libc Bibliotheksfunktionen _delay_ms() und _delay_us() erledigt werden. Die Bibliotheksfunktionen sind einfachen Zählschleifen (Warteschleifen) vorzuziehen, da leere Zählschleifen ohne besondere Vorkehrungen sonst bei eingeschalteter Optimierung vom avr-gcc-Compiler wegoptimiert werden. Weiterhin sind die Bibliotheksfunktionen bereits darauf vorbereitet, die in F_CPU definierte Taktfrequenz zu verwenden. Ausserdem sind die Funktionen der Bibliothek wirklich getestet.

Einfach!? Schon, aber während gewartet wird, macht der µC nichts anderes mehr. Die Wartefunktion blockiert den Programmablauf. Möchte man einerseits warten, um z. B. eine LED blinken zu lassen und gleichzeitig andere Aktionen ausführen z. B. weitere LED bedienen, sollten die Timer/Counter des AVR verwendet werden.

Die Bibliotheksfunktionen funktionieren allerdings nur dann korrekt, wenn sie mit zur Übersetzungszeit (beim Compilieren) bekannten konstanten Werten aufgerufen werden. Der Quellcode muss mit eingeschalteter Optimierung übersetzt werden, sonst wird sehr viel Maschinencode erzeugt und die Wartezeiten stimmen nicht mehr mit dem Parameter überein.

Abhängig von der Version der Bibliothek verhalten sich die Bibliotheksfunktionen etwas unterschiedlich.

== avr-libc Versionen kleiner 1.6 ==

Die Wartezeit der Funktion _delay_ms() ist auf 262,14ms/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 13,1ms warten. Die Wartezeit der Funktion _delay_us() ist auf 768us/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 38,4us warten. Längere Wartezeiten müssen dann über einen mehrfachen Aufruf in einer Schleife gelöst werden.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z. B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h> /* in älteren avr-libc Versionen <avr/delay.h> */

/*
lange, variable Verzögerungszeit, Einheit in Millisekunden

Die maximale Zeit pro Funktionsaufruf ist begrenzt auf
262.14 ms / F_CPU in MHz (im Beispiel:
262.1 / 3.6864 = max. 71 ms)

Daher wird die kleine Warteschleife mehrfach aufgerufen,
um auf eine längere Wartezeit zu kommen. Die zusätzliche
Prüfung der Schleifenbedingung lässt die Wartezeit geringfügig
ungenau werden (macht hier vielleicht 2-3ms aus).
*/

void long_delay(uint16_t ms)
{
for(; ms>0; ms--) _delay_ms(1);
}

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) // Endlosschleife
{
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z. B. angeschlossene LED
long_delay(1000); // Eine Sekunde warten...
}

return 0;
}
</c>

== avr-libc Versionen ab 1.6 ==

_delay_ms() kann mit einem Argument bis 6553,5 ms (= 6,5535 Sekunden) benutzt werden. Wird die früher gültige Grenze von 262,14 ms/F_CPU (in MHz) überschritten, so arbeitet _delay_ms() einfach etwas ungenauer und zählt nur noch mit einer Auflösung von 1/10 ms. Eine Verzögerung von 1000,10 ms ließe sich nicht mehr von einer von 1000,19 ms unterscheiden. Ein Verlust, der sich im Allgemeinen verschmerzen lässt. Dem Programmierer wird keine Rückmeldung gegeben, dass die Funktion ggf. gröber arbeitet, d.h. wenn es darauf ankommt, bitte den Parameter wie bisher geschickt wählen.

Die Funktion _delay_us() wurde ebenfalls erweitert. Wenn deren maximal als genau behandelbares Argument überschritten wird, benutzt diese intern _delay_ms(). Damit gelten in diesem Fall die _delay_ms() Einschränkungen.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus, avr-libc ab Version 1.6
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z. B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h>

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z. B. angeschlossene LED
_delay_ms(1000); // Eine Sekunde +/-1/10000 Sekunde warten...
// funktioniert nicht mit Bibliotheken vor 1.6

}
return 0;
}
</c>

= Programmieren mit Interrupts =

<div style="float:right; margin:2em;">
[[Image:Interrupt Programme.gif]]
</div>
Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

Siehe auch

* [http://www.mikrocontroller.net/forum/read-1-235092.html#new Ausführlicher Thread im Forum]
* Artikel [[Interrupt]]
* Artikel [[Multitasking]]
{{Clear}}

== Anforderungen an Interrupt-Routinen ==

Um unliebsamen Überraschungen vorzubeugen, sollten einige Grundregeln bei der Implementierung der Interruptroutinen beachtet werden. Interruptroutinen sollten möglichst kurz und schnell abarbeitbar sein, daraus folgt:

* Keine umfangreichen Berechnungen innerhalb der Interruptroutine. (*)
* Keine langen Programmschleifen.
* Obwohl es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen, wird davon ohne genaue Kenntnis der internen Abläufe dringend abgeraten.

Interruptroutinen (ISRs) sollten also möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

(*)
Hinweis:
Es gibt allerdings die seltene Situation, dass man gerade eingelesene
ADC-Werte sofort verarbeiten muss. Besonders dann, wenn man mehrere Werte sehr
schnell hintereinander bekommt. Dann bleibt einem nichts anderes übrig, als die
Werte noch in der ISR zu verarbeiten. Kommt aber sehr selten vor und sollte
durch geeignete Wahl des Systemtaktes bzw. Auswahl des Controllers vermieden werden!

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf einem AVR AT90S2313 auslösen, wobei die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

Die Anzahl der möglichen Interruptquellen variiert zwischen den verschiedenen Typen. Im Zweifel hilft ein Blick ins Datenblatt ("Interrupt Vectors").

== Register ==

Der AT90S2313 verfügt über 2 Register die mit den
Interrupts zusammen hängen.

{| class="wikitable"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6|| 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INT1''' || '''INT0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INTF1''' || '''INTF0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Kondition, entsprechend der Konfiguration, erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine
MCU-Funktionen.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''-'''|| '''-'''|| '''SE'''|| '''SM'''|| '''ISC11'''|| '''ISC10'''|| '''ISC01'''|| '''ISC00'''
|-
! R/W
| R || R || R/W || R/W || R/W || R/W || R/W || R/W
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0

|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt der Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC11 || ISC10 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}

'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC01 || ISC00 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}

|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem Zeitpunkt bereits wieder das GIE-bit zu setzen, wird dringend davon abgeraten. Dieses wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe, weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.



== Interrupts mit dem AVR GCC Compiler (WinAVR) ==


Funktionen zur Interrupt-Verarbeitung werden in den Includedateien ''interrupt.h'' der avr-libc zur Verfügung gestellt (bei älterem Quellcode zusätzlich ''signal.h'').

<c>
// fuer sei(), cli() und ISR():
#include <avr/interrupt.h>
</c>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status Register gesetzt.

<c>
sei();
</c>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird gelöscht.

<c>
cli();
</c>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf. Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen. Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen Zustands die Interrupts aktivieren, was zu unerwünschten Seiteneffekten führen kann. Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

//...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O" nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern. Dazu ist eine "timed sequence"
einzuhalten (vgl Datenblatt ATmega16, Stand 10/04, S. 229):
Das JTD-Bit muss zweimal innerhalb von 4 Taktzyklen geschrieben
werden. Ein Interrupt zwischen den beiden Schreibzugriffen wuerde
die erforderliche Sequenz "brechen", das JTAG-Interface bliebe
weiterhin aktiv und die IO-Pins weiterhin für JTAG reserviert. */

MCUCSR |= (1<<JTD);
MCUCSR |= (1<<JTD); // 2 mal in Folge ,vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
//...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
//...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichtSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
//...

}
</c>


Zu den aktivierten Interrupts ist eine Funktion zu programmieren, deren Code aufgerufen wird, wenn der betreffende Interrupt auftritt (Interrupt-Handler, Interrupt-Service-Routine). Dazu existiert die Definition (ein Makro) '''ISR'''.

=== ISR ===

(''ISR()'' ersetzt bei neueren Versionen der avr-libc ''SIGNAL()''. SIGNAL sollte nicht mehr genutzt werden, zur Portierung von SIGNAL nach ISR siehe den [[AVR-GCC-Tutorial#Anhang|Anhang]].

<c>
#include <avr/interrupt.h>
//...
ISR(Vectorname) /* vormals: SIGNAL(siglabel) dabei Vectorname != siglabel ! */
{
/* Interrupt Code */
}
</c>

Mit ''ISR'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektors angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Die Bezeichnung entspricht dem Namen aus dem Datenblatt, bei dem die Leerzeichen durch Unterstriche ersetzt sind und ein ''_vect'' angehängt ist.

Als Beispiel ein Ausschnitt aus der Datei für den ATmega8 (bei WinAVR Standardinstallation in C:\WinAVR\avr\include\avr\iom8.h) in der neben den aktuellen Namen für ''ISR'' (*_vect) noch die Bezeichnungen für das inzwischen nicht mehr aktuelle ''SIGNAL'' (SIG_*) enthalten sind.

<c>
//...
/* $Id: iom8.h,v 1.13 2005/10/30 22:11:23 joerg_wunsch Exp $ */

/* avr/iom8.h - definitions for ATmega8 */
//...

/* Interrupt vectors */

/* External Interrupt Request 0 */
#define INT0_vect _VECTOR(1)
#define SIG_INTERRUPT0 _VECTOR(1)

/* External Interrupt Request 1 */
#define INT1_vect _VECTOR(2)
#define SIG_INTERRUPT1 _VECTOR(2)

/* Timer/Counter2 Compare Match */
#define TIMER2_COMP_vect _VECTOR(3)
#define SIG_OUTPUT_COMPARE2 _VECTOR(3)

/* Timer/Counter2 Overflow */
#define TIMER2_OVF_vect _VECTOR(4)
#define SIG_OVERFLOW2 _VECTOR(4)

/* Timer/Counter1 Capture Event */
#define TIMER1_CAPT_vect _VECTOR(5)
#define SIG_INPUT_CAPTURE1 _VECTOR(5)

/* Timer/Counter1 Compare Match A */
#define TIMER1_COMPA_vect _VECTOR(6)
#define SIG_OUTPUT_COMPARE1A _VECTOR(6)

/* Timer/Counter1 Compare Match B */
#define TIMER1_COMPB_vect _VECTOR(7)
#define SIG_OUTPUT_COMPARE1B _VECTOR(7)

//...
</c>


Mögliche Funktionsrümpfe für Interruptfunktionen sind zum Beispiel:

<c>
#include <avr/interrupt.h>
/* veraltet: #include <avr/signal.h> */

ISR(INT0_vect) /* veraltet: SIGNAL(SIG_INTERRUPT0) */
{
/* Interrupt Code */
}

ISR(TIMER0_OVF_vect) /* veraltet: SIGNAL(SIG_OVERFLOW0) */
{
/* Interrupt Code */
}

ISR(USART_RXC_vect) /* veraltet: SIGNAL(SIG_UART_RECV) */
{
/* Interrupt Code */
}

// und so weiter und so fort...
</c>

Auf die korrekte Schreibweise der Vektorbezeichnung ist zu achten. Der gcc-Compiler prüft erst ab Version 4.x, ob ein Signal/Interrupt der angegebenen Bezeichnung tatsächlich in der Includedatei definiert ist und gibt andernfalls eine Warnung aus. Bei WinAVR (ab 2/2005) wurde die Überprüfung auch in den mitgelieferten Compiler der Version 3.x integriert. Aus dem gcc-Quellcode Version 3.x selbst erstellte Compiler enthalten die Prüfung nicht (vgl. [[AVR-GCC]]).

Während der Ausführung der Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== Unterbrechbare Interruptroutinen ===

"Faustregel": im Zweifel '''ISR'''. Die nachfolgend beschriebene Methode nur dann verwenden, wenn man sich über die unterschiedliche Funktionsweise im Klaren ist.

<c>
#include <avr/interrupt.h>

ISR(XXX,ISR_NOBLOCK) /* veraltet: INTERRUPT(SIG_OVERFLOW0) */
{
/* Interrupt-Code */
}
</c>

Hierbei steht XXX für den oben beschriebenen Namen des Vektors (also z. B. ''TIMER0_OVF_vect''). Der Unterschied im Vergleich zu einer herkömmlichen ISR ist, dass hier beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit durch Einfügen einer SEI-Anweisung direkt wieder gesetzt und somit alle Interrupts zugelassen werden – auch XXX-Interrupts.

Bei unsachgemässer Handhabung kann dies zu erheblichen Problemen wie einem Stack-Overflow oder anderen unerwarteten Effekten führen und sollte wirklich nur dann eingesetzt werden, wenn man sich sicher ist, das Ganze auch im Griff zu haben.

Insbesondere sollte möglichst am ISR-Anfang die auslösende IRQ-Quelle deaktiviert und erst am Ende der ISR wieder aktiviert werden. Robuster als die Verwendung einer NOBLOCK-ISR ist daher folgender ISR-Aufbau:

<c>
#include <avr/interrupt.h>

ISR (XXX)
{
// Implementiere die ISR ohne zunaechst weitere IRQs zuzulassen

<<Dektiviere die XXX-IRQ>>

// Erlaube alle Interrupts (ausser XXX)
sei();

//... Code ...

// IRQs global deaktivieren um die XXX-IRQ wieder gefahrlos
// aktivieren zu koennen
cli();

<<Aktiviere die XXX-IRQ>>
}
</c>
Auf diese Weise kann sich die XXX-IRQ nicht selbst unterbrechen, was zu einer Art Endlosschleife führen würde.

Siehe auch: Hinweise in [[AVR-GCC]]

siehe dazu: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

== Datenaustausch mit Interrupt-Routinen ==

Variablen die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)), als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte der Compiler den Code so optimieren, dass der Wert der Variablen nur in Prozessorregistern zwischengespeichert wird, die nichts von der Änderung woanders mitbekommen.

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
//...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z. B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt ISR, wird z.B. alle 10ms ausgefuehrt
ISR(TIMER1_COMPA_vect)
{
// hier wird gKeyCounter veraendert. Die übrigen
// Programmteile müssen diese Aenderung "sehen":
// volatile -> aktuellen Wert immer in den Speicher schreiben
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
}
else {
gKeyCounter = 0;
}
}

//...

int main(void)
{
//...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
//...
// hier wird auf gKeyCounter zugegriffen. Dazu muss der in der
// ISR geschriebene Wert bekannt sein:
// volatile -> aktuellen Wert immer aus dem Speicher lesen
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt" */
}
else {
/* hier: Code fuer "Taste kurz gedrueckt" */
}
}
//...
}
</c>

Wird innerhalb einer ISR mehrfach auf eine mit volatile deklarierte Variable zugegriffen, wirkt sich dies ungünstig auf die Verarbeitungsgeschwindigkeit aus, da bei jedem Zugriff mit dem Speicherinhalt abgeglichen wird. Da bei AVR-Controllern ''innerhalb'' einer ISR keine Unterbrechungen zu erwarten sind, bietet es sich an, einen Zwischenspeicher in Form einer lokalen Variable zu verwenden, deren Inhalt zu Beginn und am Ende mit dem der volatile Variable synchronisiert wird. Lokale Variable werden bei eingeschalteter Optimierung mit hoher Wahrscheinlichkeit in Prozessorregistern verwaltet und der Zugriff darauf ist daher nur mit wenigen internen Operationen verbunden. Die ISR aus dem vorherigen Beispiel lässt sich so optimieren:

<c>
//...
ISR(TIMER1_COMPA_vect)
{
uint8_t tmp_kc;

tmp_kc = gKeyCounter; // Uebernahme in lokale Arbeitsvariable

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (tmp_kc < CNTREPEAT) {
tmp_kc++;
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc; // Zurueckschreiben
}
//...
</c>

Zum Vergleich die Disassemblies (Ausschnitte der "lss-Dateien", compiliert für ATmega162) im Anschluss. Man erkennt den viermaligen Zugriff auf die Speicheraddresse von ''gKeyCounter'' (hier 0x032A) in der ISR ohne "Cache"-Variable und den zweimaligen Zugriff in der Variante mit Zwischenspeicher. Im Beispiel ist der Vorteil gering, bei komplexeren Routinen kann die Zwischenspeicherung in lokalen Variablen jedoch zu deutlicheren Verbesserungen führen.

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
876: ca 99 sbic 0x19, 2 ; 25
878: 0a c0 rjmp .+20 ; 0x88e <__vector_13+0x24>
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
87a: 80 91 2a 03 lds r24, 0x032A
87e: 88 3c cpi r24, 0xC8 ; 200
880: 40 f4 brcc .+16 ; 0x892 <__vector_13+0x28>
882: 80 91 2a 03 lds r24, 0x032A
886: 8f 5f subi r24, 0xFF ; 255
888: 80 93 2a 03 sts 0x032A, r24
88c: 02 c0 rjmp .+4 ; 0x892 <__vector_13+0x28>
}
else {
gKeyCounter = 0;
88e: 10 92 2a 03 sts 0x032A, r1
892: 8f 91 pop r24
894: 0f 90 pop r0
896: 0f be out 0x3f, r0 ; 63
898: 0f 90 pop r0
89a: 1f 90 pop r1
89c: 18 95 reti
</pre>

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
uint8_t tmp_kc;

tmp_kc = gKeyCounter;
876: 80 91 2a 03 lds r24, 0x032A

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
87a: ca 9b sbis 0x19, 2 ; 25
87c: 02 c0 rjmp .+4 ; 0x882 <__vector_13+0x18>
87e: 80 e0 ldi r24, 0x00 ; 0
880: 03 c0 rjmp .+6 ; 0x888 <__vector_13+0x1e>
if (tmp_kc < CNTREPEAT) {
882: 88 3c cpi r24, 0xC8 ; 200
884: 08 f4 brcc .+2 ; 0x888 <__vector_13+0x1e>
tmp_kc++;
886: 8f 5f subi r24, 0xFF ; 255
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc;
888: 80 93 2a 03 sts 0x032A, r24
88c: 8f 91 pop r24
88e: 0f 90 pop r0
890: 0f be out 0x3f, r0 ; 63
892: 0f 90 pop r0
894: 1f 90 pop r1
896: 18 95 reti
</pre>

=== volatile und Pointer ===

Bei '''volatile''' in Verbindung mit Pointern ist zu beachten, ob der Pointer selbst oder die Variable auf die der Pointer zeigt '''volatile''' ist.

<c>
volatile uint8_t *a; // das Ziel von a ist volatile

uint8_t *volatile a; // a selbst ist volatile
</c>

Falls der Pointer volatile ist (zweiter Fall im Beispiel), ist zu beachten, dass der Wert des Pointers, also eine Speicheradresse, intern in mehr als einem Byte verwaltet wird. Lese- und Schreibzugriffe im Hauptprogramm (ausserhalb von Interrupt-Routinen) sind daher so zu implementieren, dass alle Teilbytes der Adresse konsistent bleiben, vgl. dazu den folgenden Abschnitt.

=== Variablen größer 1 Byte ===

Bei Variablen größer ein Byte, auf die in Interrupt-Routinen und im Hauptprogramm zugegriffen wird, muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes außerhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<c>
//...
volatile uint16_t gMyCounter16bit;
//...
ISR(...)
{
//...
gMyCounter16Bit++;
//...
}

int main(void)
{
uint16_t tmpCnt;
//...
// nicht gut: Mglw. hier ein Fehler, wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor dem Kopieren des zweiten Bytes
// ein Interrupt auftritt, der den Inhalt von MyCounter verändert.
tmpCnt = gMyCounter16bit;

// besser: Änderungen "außerhalb" verhindern -> alle "Teilbytes"
// bleiben konsistent
cli(); // Interrupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren

// oder: vorheriger Status des globalen Interrupt-Flags bleibt erhalten
uint8_t sreg_tmp;
sreg_tmp = SREG; /* Sichern */
cli()
tmpCnt = gMyCounter16Bit;
SREG = sreg_tmp; /* Wiederherstellen */

// oder: mehrfach lesen, bis man konsistente Daten hat
uint16_t count1 = gMyCounter16Bit;
uint16_t count2 = gMyCounter16Bit;
while (count1 != count2) {
count1 = count2;
count2 = gMyCounter16Bit;
}
tmpCnt = count1;
//...
}
</c>

Die avr-libc bietet ab Version 1.6.0(?) einige Hilfsfunktionen/Makros, mit der im Beispiel oben gezeigten Funktionalität, die zusätzlich auch so genannte [http://en.wikipedia.org/wiki/Memory_barrier memory barriers] beinhalten. Diese stehen nach #include <util/atomic.h> zur Verfügung.
<c>
//...
#include <util/atomic.h>
//...

// analog zu cli, Zugriff, sei:
ATOMIC_BLOCK(ATOMIC_FORCEON) {
tmpCnt = gMyCounter16Bit;
}

// oder:

// analog zu Sicherung des SREG, cli, Zugriff und Zurückschreiben des SREG:
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
tmpCnt = gMyCounter16Bit;
}

//...
</c>

* siehe auch [http://www.nongnu.org/avr-libc/user-manual/group__util__atomic.html Dokumentation der avr-libc zu atomic.h]

== Interrupt-Routinen und Registerzugriffe ==

Falls Register sowohl im Hauptprogramm als auch in Interrupt-Routinen verändert werden, ist darauf zu achten, dass diese Zugriffe sich nicht überlappen. Nur wenige Anweisungen lassen sich in sogenannte "atomare" Zugriffe übersetzen, die nicht von Interrupt-Routinen unterbrochen werden können.

Zur Veranschaulichung eine Anweisung, bei der ein Bit und im Anschluss drei Bits in einem Register gesetzt werden:

<c>
#include <avr/io.h>

int main(void)
{
//...
PORTA |= (1<<PA0);

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
//...
}
</c>

Der Compiler übersetzt diese Anweisungen für einen ATmega128 bei Optimierungsstufe "S" nach:

<div class="code"><pre>
...
PORTA |= (1<<PA0);
d2: d8 9a sbi 0x1b, 0 ; 27 (a)

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
d4: 8b b3 in r24, 0x1b ; 27 (b)
d6: 8c 61 ori r24, 0x1C ; 28 (c)
d8: 8b bb out 0x1b, r24 ; 27 (d)
...
</pre></div>

Das Setzen des einzelnen Bits wird bei eingeschalteter Optimierung für Register im unteren Speicherbereich in eine einzige Assembler-Anweisung (sbi) übersetzt und ist nicht anfällig für Unterbrechnungen durch Interrupts. Die Anweisung zum Setzen von drei Bits wird jedoch in drei abhängige Assembler-Anweisungen übersetzt und bietet damit zwei "Angriffspunkte" für Unterbrechnungen. Eine Interrupt-Routine könnte nach dem Laden des Ausgangszustands in den Zwischenspeicher (hier Register 24) den Wert des Registers ändern, z. B. ein Bit löschen. Damit würde der Zwischenspeicher nicht mehr mit dem tatsächlichen Zustand übereinstimmen aber dennoch nach der Bitoperation (hier ori) in das Register zurückgeschrieben.

Beispiel: PORTA sei anfangs 0b00000000. Die erste Anweisung (a) setzt Bit 0, PORTA ist danach 0b00000001. Nun wird im ersten Teil der zweiten Anweisung der Portzustand in ein Register eingelesen (b). Unmittelbar darauf (vor (c)) "feuert" ein Interrupt, in dessen Interrupt-Routine Bit 0 von PORTA gelöscht wird. Nach Verlassen der Interrupt-Routine hat PORTA den Wert 0b00000000. In den beiden noch folgenden Anweisungen des Hauptprogramms wird nun der zwischengespeicherte "alte" Zustand 0b00000001 mit 0b00011100 logisch-oder-verknüft (c) und das Ergebnis 0b00011101 in PortA geschrieben (d). Obwohl zwischenzeitlich Bit 0 gelöscht wurde, ist es nach (d) wieder gesetzt.

Lösungsmöglichkeiten:
* Register ohne besondere Vorkehrungen nicht in Interruptroutinen ''und'' im Hauptprogramm verändern.
* Interrupts vor Veränderungen in Registern, die auch in ISRs verändert werden, deaktivieren ("cli").
* Bits einzeln löschen oder setzen. sbi und cbi können nicht unterbrochen werden. Vorsicht: nur Register im unteren Speicherbereich sind mittels sbi/cbi ansprechbar. Der Compiler kann nur für diese sbi/cbi-Anweisungen generieren. Für Register außerhalb dieses Adressbereichs ("Memory-Mapped"-Register) werden auch zur Manipulation einzelner Bits abhängige Anweisungen erzeugt (lds,...,sts).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8. (Stand: avr-libc Vers. 1.0.4)

== Interruptflags löschen ==

Beim Löschen von Interruptflags haben AVRs eine Besonderheit, die auch im Datenblatt beschrieben ist: Es wird zum Löschen eine 1 in das betreffende Bit geschrieben.

Hinweis: Dazu '''nicht''' übliche bitweise VerODERung nehmen, sondern eine direkte Zuweisung machen ([http://www.mikrocontroller.net/topic/171148#1640133 Erklärung]).

== Was macht das Hauptprogramm? ==

Im einfachsten (Ausnahme-)Fall gar nichts mehr. Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der main-Funktion lediglich noch die Interrupts aktiviert und dann in einer Endlosschleife verharrt. Sämtliche Funktionen werden dann in den ISRs abgearbeitet. Diese Vorgehensweise ist jedoch bei den meisten Anwendungen schlecht: man verschenkt eine Verarbeitungsebene und hat außerdem möglicherweise Probleme durch Interruptroutinen, die zu viel Verarbeitungszeit benötigen.

Normalerweise wird man in den Interruptroutinen nur die bei Auftreten des jeweiligen Interruptereignisses unbedingt notwendigen Operationen ausführen lassen. Alle weniger kritischen Aufgaben werden dann im Hauptprogramm abgearbeitet.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Ansteuerung eines LCD =
Siehe: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung

= Timer =
Siehe: [[AVR-GCC-Tutorial/Die Timer und Zähler des AVR]]

= UART =
Siehe: [[AVR-GCC-Tutorial/Der UART]]

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sogenannten ''Sleep-Modes'' ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comparators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrupts den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen (eigentlich Makros) der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

* '''set_sleep_mode(uint8_t mode)'''
:Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z. B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
* '''sleep_enable()'''
:aktiviert den gesetzten Schlafmodus, versetzt den Controller aber noch nicht in den Schlafmodus
* '''sleep_cpu()'''
: Versetzt den Controller in den Schlafmodus (sleep_cpu wird im Prinzip durch die Assembler-Anweisung ''sleep'' ersetzt)
* '''sleep_disable()'''
:deaktiviert den gesetzten Schlafmodus
* '''sleep_mode()'''
:Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus. Das Makro entspricht sleep_enable()+sleep_cpu()+sleep_disable(), beinhaltet also nicht die Aktivierung von Interrupts (besser nicht benutzen).

Bei Anwendung von sleep_cpu() müssen Interrupts also bereits freigeben sein (sei()), da der Controller sonst nicht mehr "aufwachen" kann. sleep_mode() ist nicht geeignet für die Verwendung in ISR Interrupt-Service-Routinen, da bei deren Abarbeitung Interrupts global deaktiviert sind und somit auch die möglichen "Aufwachinterrupts". Abhilfe: stattdessen sleep_enable(), sei(), sleep_cpu(), sleep_disable() und evtl. cli() verwenden (vgl. Dokumentation der avr-libc).

<c>
#include <avr/io.h>
#include <avr/sleep.h>

int main(void)
{
...

while (1) {
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach Auftreten eines entsprechenden
// "Aufwach-Interrupts" verarbeitet
...
}
}
</c>

In älteren Versionenen der avr-libc wurden nicht alle AVR-Controller durch die sleep-Funktionen richtig angesteuert. Mit avr-libc 1.2.0 wurde die Anzahl der unterstützten Typen jedoch deutlich erweitert. Bei nicht-unterstützten Typen erreicht man die gewünschte Funktionalität durch direkte "[[Bitmanipulation]]" der entsprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler oder sleep_cpu():

<c>
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 "manuell" aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep"::); // alternativ sleep_cpu() aus sleep.h
...
</c>

== Sleep Modi ==
Zu beachten ist, dass unterschiedliche Prozessoren aus der AVR Familie unterschiedliche Sleep-Modi unterstützen oder nicht unterstützen. Auskunft über die tatsächlichen Gegebenheiten gibt, wie immer, das zum Prozessor gehörende Datenblatt. Die unterschiedlichen Modi unterscheiden sich dadurch, welche Bereiche des Prozessors abgeschaltet werden. Damit korrespondiert unmittelbar welche Möglichkeiten es gibt, den Prozessor aus den jeweiligen Sleep Modus wieder aufzuwecken.

=== Idle Mode ===
Die CPU kann durch SPI, USART, Analog Comperator, ADC, TWI, Timer, Watchdog und irgendeinen anderen Interrupt wieder aufgeweckt werden.

=== ADC Noise Reduction Mode ===
In diesem Modus liegt das Hauptaugenmerk darauf, die CPU soweit stillzulegen, dass der ADC möglichst keine Störungen aus dem inneren der CPU auffangen kann. Aufwachen aus diesem Modus kann ausgelöst werden durch den ADC, externe Interrupts, TWI, Timer und Watchdog.

=== Power-Down Mode ===
In diesem Modus wird ein externer Oszillator (Quarz, Quarzoszillator) gestoppt.
Geweckt werden kann die CPU durch einen externen Level Interrupt, TWI, Watchdog, Brown-Out-Reset

=== Power-Save-Mode ===
Power-Save ist identisch zu Power-Down mit einer Ausnahme: Ist der Timer 2 auf die Verwendung eines externen Taktes konfiguriert, so läuft dieser Timer auch im Power-Save weiter und kann die CPU mit einem Interrupt aufwecken.

=== Standby-Mode ===
Voraussetzung für den Standby Modus ist die Verwendung eines Quarzes oder eines Quarzoszillators (also einer externen Taktquelle). Ansonsten ist dieser Modus identisch zum Power-Down Modus. Vorteil dieses Modus ist eine kürzere Aufwachzeit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes
* [http://www.mikrocontroller.net/topic/96369#832712 Forenbeitrag] zur "Nichtverwendung" von sleep_mode in ISRs.

= Zeiger =
Zeiger (engl. /pointer/), d.h. Variablen, die die Adresse von Daten oder Funktionen enthalten, belegen 16 bits. Das hängt mit dem addressierbaren Speicherbereich zusammen, und gcc reserviert dann den entsprechenden Platz.
Ggf. ist es also günstiger, Indizes auf Arrays (Listen) zu verwenden, so dass der GCC für die Zeigerarithmetik den erforderlichen RAM nur temporär benötigt.

Siehe auch: [[Zeiger]]

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (genauer statisches RAM/SRAM) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als FLASH-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z. B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin selten sinnvoll ist und auch nur bei einigen RAM-losen Typen nach [http://lightner.net/avr/ATtinyAvrGcc.html "Bastelarbeiten"] möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein. Für die Typen ATtiny2313, ATtiny26 und viele weitere der "ATtiny-Reihe" gelten die Ausführungen ebenfalls.

== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts Besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

Um Speicher dynamisch (während der Laufzeit) zu reservieren, kann '''malloc()''' verwendet werden. malloc(size) "alloziert" (~reserviert) einen gewissen Speicherblock mit '''size''' Bytes. Ist kein Platz für den neuen Block, wird NULL (0) zurückgegeben.

Wird der angelegte Block zu klein (groß), kann die Größe mit realloc() verändert werden. Den allozierten Speicherbereich kann man mit free() wieder freigeben. Wenn das Freigeben eines Blocks vergessen wird spricht man von einem "Speicherleck" (memory leak).

malloc() legt Speicherblöcke im '''Heap''' an, belegt man zuviel Platz, dann wächst der Heap zu weit nach oben und überschreibt den Stack, und der Controller kommt in Teufels Küche. Das kann leider nicht nur passieren wenn man insgesamt zu viel Speicher anfordert, sondern auch wenn man Blöcke unterschiedlicher Größe in ungünstiger Reihenfolge alloziert/freigibt (siehe Artikel [[Heap-Fragmentierung]]). Aus diesem Grund sollte man malloc() auf Mikrocontrollern sehr sparsam (am besten gar nicht) verwenden.

Beispiel zur Verwendung von malloc():
<c>
#include <stdlib.h>

void foo(void) {
// neuen speicherbereich anlegen,
// platz für 10 uint16
uint16_t* pBuffer = malloc(10 * sizeof(uint16_t));

// darauf zugreifen, als wärs ein gewohnter Buffer
pBuffer[2] = 5;

// Speicher (unbedingt!) wieder freigeben
free(pBuffer);
}
</c>

Wenn (wie in obigem Beispiel) dynamischer Speicher nur für die Dauer einer Funktion benötigt und am Ende wieder freigegeben wird, bietet es sich an, statt malloc() '''alloca()''' zu verwenden. Der Unterschied zu malloc() ist, dass der Speicher auf dem Stack reserviert wird, und beim Verlassen der Funktion automatisch wieder freigegeben wird. Es kann somit kein Speicherleck und keine Fragmentierung entstehen.

siehe auch:
* http://www.nongnu.org/avr-libc/user-manual/malloc.html

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich, um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory, bei AVR Controllern mit mehr als 64kB Flash auch elpm). Die Standard-Laufzeitbibliothek des avr-gcc (die avr-libc) stellt diese Funktionen nach Einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Lokale Variablen (eigentlich Konstanten) innerhalb von Funktionen können ebenfalls im Programmspeicher abgelegt werden. Dazu ist bei der Definition jedoch ein ''static'' voranzustellen, da solche "Variablen" nicht auf dem Stack bzw. (bei Optimierung) in Registern verwaltet werden können. Der Compiler "wirft" eine Warnung falls static fehlt.

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

//...

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Feld */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t *pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t *pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray2 };
//...

void foo(void)
{
static /*const*/ uint8_t pgmTestByteLocal PROGMEM = 0x55;
static /*const*/ char pgmTestStringLocal[] PROGMEM = "im Flash";
// so nicht (static fehlt): char pgmTestStringLocalFalsch [] PROGMEM = "so nicht";

// ...

}
</c>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<c>
const uint8_t pgmFooByte PROGMEM = 123;
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };

// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte(&pgmFooByte);
// myByte hat nun den Wert 123

//...

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i=0;i<3;i++) {
myByte = pgm_read_byte(&pgmFooByteArray1[i]);
// mach' was mit myByte....
}
</c>

=== Wort lesen ===

Für "einfache" 16-bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion pgm_read_word.

<c>
const uint16_t pgmFooWort PROGMEM = 12345;

uint16_t myWord;

myWord = pgm_read_word(&pgmFooWort);
</c>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "groß" (Stand avr-gcc 3.4.x). Damit ist der mögliche Speicherbereich für "Flash-Konstanten" auf 64kB begrenzt. 

<c>
uint8_t *ptrToArray;

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerToArray1));
// ptrToArray enthält nun die Startadresse des Byte-Arrays pgmFooByteArray1
// Allerdings würde ein direkter Zugriff mit diesem Pointer (z. B. temp=*ptrToArray)
// '''nicht''' den Inhalt von pgmFooByteArray1[0] liefern, sondern von einer Speicherstelle
// im '''RAM''', die die gleiche Adresse hat wie pgmFooByteArray1[0]
// Daher muss nun die Funktion pgm_read_byte() benutzt werden, die die in ptrToArray
// enthaltene Adresse benutzt und auf das Flash zugreift.

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (18, 3, 70)
}

ptrToArray = (uint8_t*)(pgm_read_word(&pgmPointerArray[1]));

// ptrToArray enthält nun die Adresse des ersten Elements des Byte-Arrays pgmFooByteArray2
// da im zweiten Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmFooByteArray2 abgelegt ist

for (i=0;i<3;i++) {
myByte = pgm_read_byte(ptrToArray+i);
// mach' was mit myByte... (30, 7, 79)
}
</c>

=== Strings lesen ===
Strings sind in C ja nichts anderes als eine Abfolge von Zeichen. Der prinzipielle Weg ist daher identisch zu "Bytes lesen" wobei allerdings auf die [http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F Besonderheiten von Strings] (0-Terminierung) geachtet werden muss, bzw. diese zur Steuerung einer Schleife über die Zeichen im String ausgenutzt werden kann

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hallo world";

int main()
{
char c;
const char* addr;

...

addr = pgmString;
while( ( c = pgm_read_byte( addr++ ) ) != '\0' ) {
// mach was mit c
}
}
</c>

Zur Unterstützung des Programmierers steht das Repertoir der str... Funktionen auch in jeweils eine Variante zur Verfügung, die mit dem Flash Speicher arbeiten kann. Die Funktionsnamen wurden dabei um ein '_P' ergänzt.

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hallo world";

int main()
{
char string[40];

...

strcpy_P( string, pgmString );
}
</c>

=== Float lesen ===

Auch um floats zu lesen gibt es ein Makro in avr/pgmspace.h. Ein Beispiel:

<c>
/* Beispiel float aus Flash */

float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};
//...

void egal(void)
{
int i;
float f;

for (i=0; i<3; i++)
{
f = pgm_read_float(&pgmFloatArray[i]); // entspr. "f = pgmFloatArray[i];"
// mach was mit f
}
}
</c>

TODO: Beispiele für structs und pointer aus Flash auf struct im Flash (menues, state-machines etc.). Eine kleine Einleitung insbesondere auch in Bezug auf die auftretenden Schwierigkeiten liefert [http://www.mail-archive.com/avr-gcc-list@nongnu.org/msg05652.html].

=== Array aus Strings im Flash-Speicher ===

Arrays aus Strings im Flash-Speicher werden in zwei Schritten angelegt: Zuerst die einzelnen Elemente des Arrays und im Anschluss ein Array, in dem die Startaddressen der Strings abgelegt werden. Zum Auslesen wird zuerst die Adresse des i-ten Elements aus dem Array im Flash-Speicher gelesen, die im Anschluss dazu genutzt wird, auf das Element (den String) selbst zuzugreifen.

<c>
#include <stdint.h>
#include <avr/pgmspace.h>

const char str1[] PROGMEM = "first_A";
const char str2[] PROGMEM = "second_A";
const char str3[] PROGMEM = "third_A";

const char *strarray1[] PROGMEM = {
str1,
str2,
str3
};

int main(void)
{
int i, j, l;
const char *pstrflash;
char work[20], work2[20];
// fuer Simulation: per volatile Optimierung verhindern,
// da c nicht genutzt
volatile char c;

for ( i = 0; i < (sizeof(strarray1)/sizeof(strarray1[0]) ); i++ ) {

// setze Pointer auf die Addresse des i-ten Elements des
// "Flash-Arrays" (str1, str2, ...)
pstrflash = (const char*)( pgm_read_word( &(strarray1[i]) ) );

// kopiere den Inhalt der Zeichenkette von der
// in pstrflash abgelegten Adresse in das work-Array
// analog zu strcpy( work, strarray1[i]) wenn alles im RAM
strcpy_P( work, pstrflash );
// verkuerzt:
strcpy_P( work2, (const char*)( pgm_read_word( &(strarray1[i]) ) ) );

// Zeichen-fuer-Zeichen
l = strlen_P( pstrflash );
for ( j=0; j < l; j++ ) {
// analog zu c=strarray[i][j] wenn alles im RAM
c = (char)( pgm_read_byte( pstrflash++ ) );
}
}

while (1) { ; }
}
</c>

Siehe dazu auch die avr-libc FAQ: "How do I put an array of strings completely in ROM?" (http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_rom_array)

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"
char StringImRam[MAXLEN];

//...
strcpy(StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P(StringImRam, StringImFlash, 5)) {
// mach' was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else {
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P(StringImRam, PSTR("Mueller-Schmitt"), 5)) {
// der Code hier wuerde ausgefuehrt, die ersten 5 Zeichen stimmen ueberein
}
else {
// wuerde bei nicht-Uebereinstimmung ausgefuehrt
}
//...
</c>

Aber Vorsicht: Ersetzt man zum Beispiel
<c>
const char textImFlashOK[] PROGMEM = "mit[]";
// = Daten im "Flash", textImFlashOK* zeigt auf Flashadresse
</c>
durch
<c>
const char* textImFlashProblem PROGMEM = "mit*";
// Konflikt: Daten im BSS (lies: RAM), textImFlashFAIL* zeigt auf Flashadresse
</c>
dann kann es zu Problemen mit AVR-GCC kommen. Zu erkennen daran, dass der Initialisierungsstring von "textImFlashProblem" zu den Konstanten ans Ende des Programmcodes gelegt wird (BSS), von dem aus er zur Benutzung eigentlich ins RAM kopiert werden sollte (und wird). Da der lesende Code (mittels pgm_read*) trotzdem an einer Stelle vorne im Flash sucht, wird Unsinn gelesen. Dies scheint ein weiters Problem des AVR-GCC (gesehen bei avr-gcc 3.4.1 und 3.4.2) bei der Anpassung an die Harvard-Architektur zu sein (konstanter Pointer auf variable Daten?!). Abhilfe ("Workaround"): Initialisierung bei Zeichenketten mit [] oder gleich im Code PSTR("...") nutzen.

Übergibt man Zeichenketten (genauer: die Adresse des ersten Zeichens), die im Flash abglegt sind an eine Funktion, muss diese entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden, ob es sich um eine Adresse im Flash oder im RAM handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen die Flash-Adressen erwarten mit dem Suffix _p (oder _P) versehen sind.

Eine Funktion, die einen im Flash abgelegten String z. B. an eine UART ausgibt, würde dann so aussehen:

<c>
void uart_puts_p(const char *text)
{
char Zeichen;

while (Zeichen = pgm_read_byte(text))
{ /* so lange, wie mittels pgm_read_byte ein Zeichen vom Flash gelesen
werden konnte, welches nicht das "String-Endezeichen" darstellt */

/* Das gelesene Zeichen über die normalen Kanäle verschicken */
uart_putc(Zeichen);
text++;
}
}
</c>

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<c>
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
//...
extern void lcd_puts_p(const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
//...

// in einer Anwendung (wieauchimmmer.c)
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

char StringImFlash[] PROGMEM = "Erwin Lindemann"; // im "Flash"

//...
lcd_puts_p(StringImFlash);
lcd_puts_P("Dr. Kloebner");
// daraus wird wg. #define lcd_put_P...: lcd_puts_p( PSTR("Dr. Kloebner") );
//...
</c>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option (auch bekannt als Bootloader-Support) können Teile des Flash-Speichers auch vom Anwendungsprogramm selbst beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktionen in einem besonderen Speicherbereich (boot-section) des Programmspeichers/Flash abgelegt sind. Bei wenigen "kleinen" AVRs gibt es keine gesonderte Boot-Section, bei diesen kann der Flashspeicher von jeder Stelle des Programms geschrieben werden. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

Siehe auch:
* Forumsbeitrag [http://www.mikrocontroller.net/topic/163632#1561622 Daten in Programmspeicher speichern]

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so "kompliziert" ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.
Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette (einen Pointer, z. B. 0x01fe), "weiß" die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert (der Zahl) kann nicht geschlossen werden, ob ein "einfaches" zeichen_an_uart(s[i]) oder zeichen_an_uart(pgm_read_byte(&s[i]) genutzt werden muss, um das i-te Zeichen auszugeben.

Einige AVR-Compiler "tricksen" etwas, in dem sie für einen Pointer nicht nur die Adresse anlegen, sondern zusätzlich zu jedem Pointer den Ablageort (Flash oder RAM) intern sichern. Bei Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch nicht nur Vorteile; Erläuterungen warum dies so ist, führen an dieser Stelle zu weit.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z. B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmäßig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, dass vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgegeben sind, die innerhalb weniger Taktzyklen aufeinanderfolgen müssen ("timed sequence"). Auch dies muss bei Nutzung der Funktionen aus der avr-libc/eeprom.h-Datei nicht selbst implementiert werden. Innerhalb der Funktionen werden Interrupts vor der "EEPROM-Sequenz" global deaktiviert und im Anschluss, falls vorher auch schon eingeschaltet, wieder aktiviert.

Bei der Deklaration einer Variable im EEPROM, ist das Attribut für die Section ".eeprom" zu ergänzen. Siehe dazu folgendes Beispiel:

<c>
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <inttypes.h> // wird in aktuellen Versionen der avr-lib mit xx.h eingebunden

// EEMEM wird bei aktuellen Versionen der avr-lib in eeprom.h definiert
// hier: definiere falls noch nicht bekannt ("alte" avr-libc)
#ifndef EEMEM
// alle Textstellen EEMEM im Quellcode durch __attribute__ ... ersetzen
#define EEMEM __attribute__ ((section (".eeprom")))
#endif

//...

/* Byte */
uint8_t eeFooByte EEMEM = 123;

/* Wort */
uint16_t eeFooWord EEMEM = 12345;

/* float */
float eeFooFloat EEMEM;

/* Byte-Feld */
uint8_t eeFooByteArray1[] EEMEM = { 18, 3 ,70 };
uint8_t eeFooByteArray2[] EEMEM = { 30, 7 ,79 };

/* 16-bit unsigned short feld */
uint16_t eeFooWordArray1[4] EEMEM;
//...
</c>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heißt eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<c>
//...
uint8_t myByte;

myByte = eeprom_read_byte(&eeFooByte); // lesen
// myByte hat nun den Wert 123
//...
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben
// der Wert 99 wird im EEPROM an die Adresse der
// 'Variablen' eeFooByte geschrieben
//...
myByte = eeprom_read_byte(&eeFooByteArray1[1]);
// myByte hat nun den Wert 3
//...

// Beispiel zur "Sicherung" gegen leeres EEPROM nach "Chip Erase"
// (z. B. wenn die .eep-Datei nach Programmierung einer neuen Version
// des Programms nicht in den EEPROM uebertragen wurde und EESAVE
// deaktiviert ist (unprogrammed/1)
//
// Vorsicht: wenn EESAVE "programmed" ist, hilft diese Sicherung nicht
// weiter, da die Speicheraddressen in einem neuen/erweiterten Programm
// moeglicherweise verschoben wurden. An der Stelle &eeFooByte steht
// dann u.U. der Wert einer anderen Variable aus einer "alten" Version.

#define EEPROM_DEF 0xFF
uint8_t fooByteDefault = 222;
if ( ( myByte = eeprom_read_byte(&eeFooByte) ) == EEPROM_DEF ) {
myByte = fooByteDefault;
}

</c>

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<c>
//...
uint16_t myWord;

myWord = eeprom_read_word(&eeFooWord); // lesen
// myWord hat nun den Wert 12345
//...
myWord = 2222;
eeprom_write_word(&eeFooWord, myWord); // schreiben
//...
</c>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen ''eeprom_read_block()'' bzw. ''eeprom_write_block()''. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes (size_t).

TODO: '''Vorsicht!''' die folgenden Beispiele sind noch nicht geprüft, erstmal nur als Hinweis auf "das Prinzip". Evtl. fehlen "casts" und möglicherweise noch mehr.

<c>
//...
uint8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

/* Datenblock aus EEPROM LESEN */

/* liest 3 Bytes ab der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block(myByteBuffer,eeFooByteArray1,3);

/* dito etwas anschaulicher aber "unnütze Tipparbeit": */
eeprom_read_block(&myByteBuffer[0],&eeFooByteArray1[0],3);

/* dito mit etwas Absicherung betr. der Länge */
eeprom_read_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));

/* und nun mit "16bit" */
eeprom_read_block(myWordBuffer,eeFooWordArray1,sizeof(myWordBuffer));

/* Datenblock in EEPROM SCHREIBEN */
eeprom_write_block(myByteBuffer,eeFooByteArray1,sizeof(myByteBuffer));
eeprom_write_block(myWordBuffer,eeFooWordArray1,sizeof(myWordBuffer));
//...
</c>

"Nicht-Integer"-Datentypen wie z. B. Fließkommazahlen lassen sich recht praktisch über eine ''union'' in "Byte-Arrays" konvertieren und wieder "zurückwandeln". Dies erweist sich hier (aber nicht nur hier) als nützlich.

<c>
//...
float myFloat = 12.34;

union {
float r;
uint8_t i[sizeof(float)];
} u;

u.r = myFloat;

/* float in EEPROM */
eeprom_write_block(&(u.i),&eeFooFloat,sizeof(float));

/* float aus EEPROM */
eeprom_read_block(&(u.i),&eeFooFloat,sizeof(float));
/* u.r wieder 12.34 */

//...
</c>

Auch zusammengesetzte Typen lassen sich mit den Block-Routinen verarbeiten.

<c>
//...
typedef struct {
uint8_t label[8];
uint8_t rom_code[8];
} tMyStruct;

#define MAXSENSORS 3
tMyStruct eeMyStruct[MAXSENSORS] EEMEM;

//...

void egal(void)
{
tMyStruct work;

strcpy(work.label,"Flur");
GetRomCode(work.rom_code); // Dummy zur Veranschaulichung - setzt rom-code

/* Sichern von "work" im EEPROM */
eeprom_write_block(&work,&eeMyStruct[0],sizeof(tMyStruct)); // f. Index 0
strcpy(work.label,"Bad");
GetRomCode(work.rom_code);
eeprom_write_block(&work,&eeMyStruct[1],sizeof(tMyStruct)); // f. Index 1
//...
/* Lesen der Daten EEPROM Index 0 in "work" */
eeprom_read_block(&work,&eeMyStruct[0],sizeof(tMyStruct));
// work.label hat nun den Inhalt "Flur"
//...
}
//...
</c>

=== EEPROM-Speicherabbild in .eep-Datei ===

Mit den zum Compiler gehörenden Werkzeugen kann der aus den Variablendeklarationen abgeleitete EEPROM-Inhalt in eine Datei geschrieben werden (übliche Dateiendung: .eep, Daten im Intel Hex-Format). Damit können recht elegant Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden. Makefiles nach WinAVR/MFile-Vorlage enthalten bereits die notwendigen Einstellungen (siehe dazu die Erläuterungen im Abschnitt Exkurs: Makefiles). Der Inhalt der eep-Datei muss ebenfalls zum Mikrocontroller übertragen werden (Write EEPROM), wenn die Initialisierungswerte aus der Deklaration vom Programm erwartet werden. Ansonsten enthält der EEPROM-Speicher nach der Übertragung des Programmers mittels ISP abhängig von der Einstellung der EESAVE-Fuse (vgl. Datenblatt Abschnitt Fuse Bits) die vorherigen Daten (EESAVE programmed = 0), deren Position möglicherweise nicht mehr mit der Belegung im aktuellen Programm übereinstimmt oder den Standardwert nach "Chip Erase": 0xFF (EESAVE unprogrammed = 1). Als Sicherung kann man im Programm nochmals die Standardwerte vorhalten, beim Lesen auf 0xFF prüfen und gegebenfalls einen Standardwert nutzen.



=== EEPROM-Variable auf feste Adressen legen ===

Gleich zu Beginn möchte ich darauf hinweisen, dass dieses Verfahren nur ein Workaround ist, mit dem man das Problem der anscheinend "zufälligen" Verteilung
der EEPROM-Variablen durch den Compiler etwas in den Griff bekommen kann.

Hilfreich kann dies vor allem dann sein, wenn man z. B. über einen Kommandointerpreter (o.ä. Funktionen) direkt bestimmte EEPROM-Adressen manipulieren möchte. Auch wenn man über einen JTAG-Adapter (mk I oder mkII) den Programmablauf manipulieren möchte, indem man die EEPROM-Werte direkt ändert, kann diese Technik hilfreich sein.

Im folgenden nun zwei Sourcelistings mit einem Beispiel:

<c>
/////////////////////////////////////////////////
// Datei "eeprom.h" eines eigenen Projektes
/////////////////////////////////////////////////

#include <avr/eeprom.h> // Die EEPROM-Definitionen/Macros der avr-libc einbinden

#define EESIZE 512 // Maximale Größe des EEPROMS

#define EE_DUMMY 0x000 // Dummyelement (Adresse 0 sollte nicht genutzt werden)
#define EE_VALUE1 0x001 // Eine Bytevariable
#define EE_WORD1L 0x002 // Eine Wordvariable (Lowbyte)
#define EE_WORD1H 0x003 // Eine Wordvariable (Highbyte)
#define EE_VALUE2 0x004 // Eine weitere Bytevariable
</c>

Mit den Macros '''#define EE_VALUE1''' legt man den Namen und die Adresse der
'Variablen' fest.

WICHTIG:Die Adressen sollten fortlaufend, zumindest aber aufsteigend sortiert sein! Ansonsten besteht die Gefahr, daß man sehr schnell ein Durcheinander im EEPROM Speicher veranstaltet.

WICHTIG:Für den Compiler sind das lediglich Speicher-Adressen, über die auf das EEPROM zugegriffen wird. Der Compiler sieht nichts davon als eine echte Variable an und stößt sich daher auch nicht daran, wenn 2 Makros mit der gleichen Speicheradresse, bzw. überlappenden Speicherbereichen definiert werden. Es liegt einzig und alleine in der Hand des Programmierers, hier keinen Fehler zu machen.

<c>
/////////////////////////////////////////////////
// Datei "eeprom.c" eines eigenen Projektes
/////////////////////////////////////////////////

#include "eeprom.h" // Eigene EEPROM-Headerdatei einbinden

uint8_t ee_mem[EESIZE] EEMEM =
{
[EE_DUMMY] = 0x00,
[EE_VALUE1] = 0x05,
[EE_WORD1L] = 0x01,
[EE_WORD1H] = 0x00,
[EE_VALUE2] = 0xFF
};

</c>

Durch die Verwendung eines Array, welches das gesamte EEPROM umfasst, bleibt
dem Compiler nicht anderes übrig, als das Array so zu platzieren, dass Element 0
des Arrays der Adresse 0 des EEPROMs entspricht. (''Ich hoffe nur, dass die Compilerbauer daran nichts ändern!'')

Wie man in dem obigen Codelisting auch sehen kann, hat das Verfahren einen kleinen Haken. Variablen die größer sind als 1 Byte, müssen etwas umständlicher
definiert werden. Benötigt man keine Initialisierung durch das Programm (was der Normalfall sein dürfte), dann kann man das auch so machen:

Möchte man im EEPROM hintereinander beispielsweise Variablen, mit den Namen '''Wert''', '''Anzahl''', '''Name''' und '''Wertigkeit''' definieren, wobei Wert und Wertigkeit 1 Byte belegen sollen, Anzahl als 1 Wort (also 2 Bytes) und Name mit 10 Bytes reserviert werden soll, so geht auch folgendes:

<c>
#define EE_DUMMY 0x000
#define EE_WERT ( 0x000 + sizeof( uint8_t ) )
#define EE_ANZAHL ( EE_WERT + sizeof( uint8_t ) )
#define EE_NAME ( EE_ANZAHL + sizeof( uint16_t ) )
#define EE_WERTIGKEIT ( EE_NAME + 10 * sizeof( uint8_t ) )
#define EE_LAST ( EE_WERTIGKEIT + sizeof( uint8_t ) )
</c>

Jedes Makro definiert also seine Startadresse durch die Startadresse der unmittelbar vorhergehende 'Variablen' plus der Anzahl der Bytes die von der vorhergehenden 'Variablen' verbraucht werden. Dadurch ist man zumindest etwas auf der sicheren Seite, dass keine 2 'Variablen' im EEPROM überlappend definiert werden. Möchte man eine weitere 'Variable' hinzufügen, so wird deren
Name, einfach anstelle der EE_LAST eingesetzt und eine neue Zeile für EE_LAST eingefügt, in der dann die Größe der 'Variablen' festgelegt wird. Zb.

<c>
#define EE_DUMMY 0x000
#define EE_WERT ( 0x000 + sizeof( uint8_t ) )
#define EE_ANZAHL ( EE_WERT + sizeof( uint8_t ) )
#define EE_NAME ( EE_ANZAHL + sizeof( uint16_t ) )
#define EE_WERTIGKEIT ( EE_NAME + 10 * sizeof( uint8_t ) )
#define EE_PROZENT ( EE_WERTIGKEIT + sizeof( uint8_t ) )
#define EE_LAST ( EE_PROZENT + sizeof( double ) )
</c>

EE_PROZENT legt die Startadresse für eine neue 'Variable' des Datentyps double fest.

Der Zugriff auf die EEPROM Werte kann dann z. B.so erfolgen:
<c>
uint8_t temp1;
uint16_t temp2;

temp1 = eeprom_read_byte(EE_VALUE1);
temp2 = eeprom_read_word(EE_WORD1L);
</c>

Ob die in der avr-libc vorhandenen Funktionen dafür verwendet werden können, weiß ich nicht. Aber in einigen Fällen muss man sich sowieso eigene Funktionen
bauen, welche die spezifischen Anforderungen (Interrupt - Atom Problem, etc.)
erfüllen.

Die oben beschriebene Möglichkeit ist nur eine Möglichkeit, wie man dies realisieren kann. Sie bietet einem eine relativ einfache Art die EEPROM-Werte
auf beliebige Adressen zu legen oder Adressen zu ändern. Die Andere Möglichkeit besteht darin, die EEPROM-Werte wie folgt zu belegen:

<c>
/////////////////////////////////////////////////
// Datei "eeprom.c" eines eigenen Projektes
/////////////////////////////////////////////////

#include "eeprom.h" // Eigene EEPROM-Headerdatei einbinden

uint8_t ee_mem[EESIZE] EEMEM =
{
0x00, // ee_dummy
0x05, // ee_value1
0x01, // ee_word1L
0x00, // (ee_word1H)
0xFF // ee_value2
};
</c>

Hierbei kann man Variablen, die größer sind als 1 Byte einfacher definieren und
man muss nur die Highbyte- oder Lowbyte-Adresse in der "eeprom.h" definieren.
Allerdings muss man hier höllisch aufpassen, dass man nicht um eine oder mehrere
Positionen verrutscht!

Welche der beiden Möglichkeiten man einsetzt, hängt vor allem davon ab, wieviele
Byte, Word und sonstige Variablen man benutzt. Gewöhnen sollte man sich an beide Varianten können ;)

Kleine Schlussbemerkung:

* Der avr-gcc unterstützt die Variante 1 und die Variante 2
* Der icc-avr Compiler unterstützt nur die Variante 2!

=== Direkter Zugriff auf EEPROM-Adressen ===

Will man direkt auf bestimmte EEPROM Adressen zugreifen, dann sind folgende Funktionen hilfreich, um sich die Typecasts zu ersparen:

<c>
#include <avr/eeprom.h>

// Byte aus dem EEPROM lesen
uint8_t EEPReadByte(uint16_t addr)
{
return eeprom_read_byte((uint8_t *)addr);
}

// Byte in das EEPROM schreiben
void EEPWriteByte(uint16_t addr, uint8_t val)
{
eeprom_write_byte((uint8_t *)addr, val);
}
</c>

oder als Makro:

<c>
#define EEPReadByte(addr) eeprom_read_byte((uint8_t *)addr)
#define EEPWriteByte(addr, val) eeprom_write_byte((uint8_t *)addr, val)
</c>

Verwendung:

<c>
EEPWriteByte(0x20, 128); // Byte an die Adresse 0x20 schreiben
...
Val=EEPReadByte(0x20); // EEPROM-Wert von Adresse 0x20 lesen
</c>

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Bei alten Versionen der avr-libc wurden nicht alle AVR Controller unterstützt. Z.B. bei der avr-libc Version 1.2.3 insbesondere bei AVRs "der neuen Generation" (ATmega48/88/168/169) funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register). In neueren Versionen (z. B. avr-libc 1.4.3 aus WinAVR 20050125) wurde die Zahl der unterstüzten Controller deutlich erweitert und eine Methode zur leichten Anpassung an zukünftige Controller eingeführt.

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Will oder kann man nicht auf die neue Version aktualisieren, kann der dort gezeigte Code auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste", gegebenfalls Schutz vor Unterbrechnung/Interrupt ergänzen ''uint8_t sreg; sreg=SREG; cli(); [EEPROM-Code] ; SREG=sreg; return;'', siehe Abschnitt Interrupts). Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

=== EEPROM Register ===
Um das EEPROM anzusteuern sind drei Register von Bedeutung:
;EEAR: Hier werden die Adressen eingetragen zum Schreiben oder Lesen. Dieses Register unterteilt sich nochmal in EEARH und EEARL da in einem 8 Bit Register keine 512 Adressen adressiert werden können
;EEDR: Hier werden die Daten eingetragen die geschrieben werden sollen bzw. es enthält die gelesenen Daten
;EECR: Ist das Kontrollregister für das EEPROM

Das EECR steuert den Zugriff auf das EEPROM und ist wie folgt aufgebaut:

:{| class="wikitable" style="text-align:center"
|+ '''Aufbau des EECR-Registers'''
|-
!Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| - || - || - ||- || EERIE || EEMWE || EEWE || EERE
|-
! Read/Write
| R || R || R || R || R/W || R/W || R/W || R/W
|-
!Init Value
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''Bedeutung der Bits'''

;Bit 4-7: nicht belegt

;Bit 3 (EERIE): ''EEPROM Ready Interrupt Enable'': Wenn das Bit gesetzt ist und globale Interrupts erlaubt sind in Register SREG (Bit 7) wird ein Interrupt ausgelöst nach Beendigung des Schreibzyklus (EEPROM Ready Interrupt). Ist einer der beiden Bits 0 wird kein Interrupt ausgelöst.

;Bit 2 EEMWE): ''EEPROM Master Write Enable'': Dieses Bit bestimmt, daß wenn EEWE = 1 gesetzt wird (innerhalb von 4 Taktzyklen), das EEPROM beschrieben wird mit den Daten in EEDR bei Adresse EEAR. Wenn EEMWE =0 ist und EEWE = 1 gesetzt wird hat das keine Auswirkungen. Der Schreibvorgang wird dann nicht ausgelöst. Nach 4 Taktzyklen wird das Bit EEMWE automatisch wieder auf 0 gesetzt. Dieses Bit löst den Schreibvorgang nicht aus, es dient sozusagen als Sicherungsbit für EEWE.

;Bit 1 (EEWE): ''EEPROM Write Enable'': Dieses Bit löst den Schreibvorgang aus wenn es auf 1 gesetzt wird, sofern vorher EEMWE gesetzt wurde und seitdem nicht mehr als 4 Taktzyklen vergangen sind. Wenn der Schreibvorgang abgeschlossen ist wird dieses Bit automatisch wieder auf 0 gesetzt und sofern EERIE gesetzt ist ein Interrupt ausgelöst. Ein Schreibvorgang sieht typischerweise wie folgt aus:
:# EEPROM Bereitschaft abwarten (EEWE=0)
:# Adresse übergeben an EEAR
:# Daten übergeben an EEDR
:# Schreibvorgang auslösen in EECR mit Bit EEMWE=1 und EEWE=1
:# (Optional) Warten bis Schreibvorgang abgeschlossen ist

;Bit 0 EERE: ''EEPROM Read Enable'': Wird dieses Bit auf 1 gesetzt wird das EEPROM an der Adresse in EEAR ausgelesen und die Daten in EEDR gespeichert. Das EEPROM kann nicht ausgelesen werden wenn bereits eine Schreiboperation gestartet wurde. Es ist daher zu empfehlen die Bereitschaft vorher zu prüfen. Das EEPROM ist lesebereit wenn das Bit EEWE=0 ist. Ist der Lesevorgang abgeschlossen wird das Bit wieder auf 0 gesetzt und das EEPROM ist für neue Lese/Schreibbefehle wieder bereit. Ein typischer Lesevorgang kann wie folgt aufgebaut sein:
:# Bereitschaft zum lesen prüfen (EEWE=0)
:# Adresse übergeben an EEAR
:# Lesezyklus auslösen mit EERE = 1
:# Warten bis Lesevorgang abgeschlossen EERE = 0
:# Daten abholen aus EEDR

= Die Nutzung von sprintf und printf =

Um komfortabel, d.h. formatiert, Ausgaben auf ein Display oder die serielle Schnittstelle zu tätigen, bieten sich '''sprintf''' oder '''printf''' an.

Alle *printf-Varianten sind jedoch ziemlich speicherintensiv und der Einsatz in einem Mikrocontroller mit knappem Speicher muss sorgsam abgewogen werden.

Bei '''sprintf''' wird die Ausgabe zunächst in einem Puffer vorbereitet und anschliessend mit einfachen Funktionen zeichenweise ausgegeben. Es liegt in der Verantwortung des Programmierers genügend Platz im Puffer für die erwarteten Zeichen bereitzuhalten.

<c>
#include <stdio.h>
#include <stdint.h>

// ...
// nicht dargestellt: Implementierung von uart_puts (vgl. Abschnitt UART)
// ...

uint16_t counter;

// Ausgabe eines unsigned Integerwertes
void uart_puti( uint16_t value )
{
uint8_t puffer[20];

sprintf( puffer, "Zählerstand: %u", value );
uart_puts( puffer );
}

int main()
{
counter = 5;

uart_puti( counter );
uart_puti( 42 );
}
</c>

Eine weitere elegante Möglichkeit besteht darin, den STREAM stdout (Standardausgabe) auf eine eigene Ausgabefunktion umzuleiten. Dazu wird dem Ausgabemechanismus der C-Bibliothek eine neue Ausgabefunktion bekannt gemacht, deren Aufgabe es ist, ein einzelnes Zeichen auszugeben. Wohin die Ausgabe dann tatsächlich stattfindet, ist Sache der Ausgabefunktion. Im Beispiel unten wird auf UART ausgegeben. Alle anderen, höheren Funktionen wie z. B. '''printf''' greifen letztendlich auf diese primitive Ausgabefunktion zurück.

<c>
#include <avr/io.h>
#include <stdio.h>

void uart_init(void);

// a. Deklaration der primitiven Ausgabefunktion
int uart_putchar(char c, FILE *stream);

// b. Umleiten der Standardausgabe stdout (Teil 1)
static FILE mystdout = FDEV_SETUP_STREAM( uart_putchar, NULL, _FDEV_SETUP_WRITE );

// c. Definition der Ausgabefunktion
int uart_putchar( char c, FILE *stream )
{
if( c == '\n' )
uart_putchar( '\r', stream );

loop_until_bit_is_set( UCSRA, UDRE );
UDR = c;
return 0;
}

void uart_init(void)
{
/* hier µC spezifischen Code zur Initialisierung */
/* des UART einfügen... s.o. im AVR-GCC-Tutorial */

// Beispiel:
//
// myAVR Board 1.5 mit externem Quarz Q1 3,6864 MHz
// 9600 Baud 8N1

#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

// Hilfsmakro zur UBRR-Berechnung ("Formel" laut Datenblatt)
#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)

UCSRB |= (1<<TXEN) | (1<<RXEN); // UART TX und RX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); // Asynchron 8N1

UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );
UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );
}

int main(void)
{
int16_t antwort = 42;
uart_init();

// b. Umleiten der Standardausgabe stdout (Teil 2)
stdout = &mystdout;

// Anwendung
printf( "Die Antwort ist %d.\n", antwort );
return 0;
}

// Quelle: avr-libc-user-manual-1.4.3.pdf, S.74
// + Ergänzungen
</c>

Sollen Fließkommazahlen ausgegeben werden, muss im Makefile eine andere (größere) Version der [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|printflib]] eingebunden werden.

= Assembler und Inline-Assembler =

Gelegentlich erweist es sich als nützlich, C- und Assembler-Code in einer Anwendung zu nutzen. Typischerweise wird das Hauptprogramm in C verfasst und wenige, extrem zeitkritische oder hardwarenahe Operationen in Assembler.

Die "gnu-Toolchain" bietet dazu zwei Möglichkeiten:

* Inline-Assembler: Die Assembleranweisungen werden direkt in den C-Code integriert. Eine Quellcode-Datei enthält somit C- und Assembleranweisungen
* Assembler-Dateien: Der Assemblercode befindet sich in eigenen Quellcodedateien. Diese werden vom gnu-Assembler (avr-as) zu Object-Dateien assembliert ("compiliert") und mit den aus dem C-Code erstellten Object-Dateien zusammengebunden (gelinkt).

== Inline-Assembler ==

Inline-Assembler bietet sich an, wenn nur wenig Assembleranweisungen benötigt werden. Typische Anwendung sind kurze Codesequenzen für zeitkritische Operationen in Interrupt-Routinen oder sehr präzise Warteschleifen (z. B. 1-Wire). Inline-Assembler wird mit '''asm volatile''' eingeleitet, die Assembler-Anweisungen werden in einer Zeichenkette zusammengefasst, die als "Parameter" übergeben wird. Durch Doppelpunkte getrennt werden die Ein- und Ausgaben sowie die "Clobber-Liste" angegeben.

Ein einfaches Beispiel für Inline-Assembler ist das Einfügen einer NOP-Anweisung (NOP steht für No Operation). Dieser Assembler-Befehl benötigt genau einen Taktzyklus, ansonsten "tut sich nichts". Sinnvolle Anwendungen für NOP sind genaue Delay(=Warte)-Funktionen.

<c>
...
/* Verzögern der weiteren Programmausführung um
genau 3 Taktzyklen */
asm volatile ("nop");
asm volatile ("nop");
asm volatile ("nop");
...
</c>

Weiterhin kann mit einem NOP verhindert werden, dass leere Schleifen, die als Warteschleifen gedacht sind, wegoptimiert werden. Der Compiler erkennt ansonsten die vermeintlich nutzlose Schleife und erzeugt dafür keinen Code im ausführbaren Programm.

<c>
...
uint16_t i;

/* leere Schleife - wird bei eingeschalteter Compiler-Optimierung wegoptimiert */
for (i = 0; i < 1000; i++)
;

...

/* Schleife erzwingen (keine Optimierung): "NOP-Methode" */
for (i = 0; i < 1000; i++)
asm volatile("NOP");

...

/* alternative Methode (keine Optimierung): */
volatile uint16_t j;
for (j = 0; j < 1000; j++)
;
</c>

Ein weiterer nützlicher "Assembler-Einzeiler" ist der Aufruf von sleep (''asm volatile ("sleep");''), da hierzu in älteren Versionen der avr-libc keine eigene Funktion existiert (in neueren Versionen ''sleep_cpu()'' aus sleep.h).

Als Beispiel für mehrzeiligen Inline-Assembler eine präzise Delay-Funktion. Die Funktion erhält ein 16-bit Wort als Parameter, prüft den Parameter auf 0 und beendet die Funktion in diesem Fall oder durchläuft die folgende Schleife sooft wie im Wert des Parameters angegeben. Inline-Assembler hat hier den Vorteil, dass die Laufzeit unabhängig von der Optimierungsstufe (Parameter -O, vgl. makefile) und der Compiler-Version ist.

<c>
static inline void delayloop16 (uint16_t count)
{
asm volatile ("cp %A0, __zero_reg__ \n\t"
"cpc %B0, __zero_reg__ \n\t"
"breq 2f \n\t"
"1: \n\t"
"sbiw %0,1 \n\t"
"brne 1b \n\t"
"2: "
: "=w" (count)
: "0" (count)
);
}
</c>

* Jede Anweisung wird mit '''\n\t''' abgeschlossen. Der Zeilenumbruch teilt dem Assembler mit, dass ein neuer Befehl beginnt.
* Als Sprung-Marken (Labels) werden Ziffern verwendet. Diese speziellen Labels sind mehrfach im Code verwendbar. Gesprungen wird jeweils zurück (b) oder vorwärts (f) zum nächsten auffindbaren Label.

Das Resultat zeigt ein Blick in die Assembler-Datei, die der Compiler mit der option <tt>-save-temps</tt> nicht löscht:

<avrasm>
cp r24, __zero_reg__ ; count
cpc r25, __zero_reg__ ; count
breq 2f
1:
sbiw r24,1 ; count
brne 1b
2:
</avrasm>

Detaillierte Ausführungen zum Thema Inline-Assembler finden sich in der Dokumentation der avr-libc im Abschnitt [http://www.nongnu.org/avr-libc/user-manual/inline_asm.html Related Pages/Inline Asm].

Siehe auch:
* [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf AVR Assembler-Anweisungsliste]
* [http://www.roboternetz.de/wissen/index.php/Inline-Assembler_in_avr-gcc Deutsche Einführung in Inline-Assembler]

== Assembler-Dateien ==

Assembler-Dateien erhalten die Endung .S (''grosses'' S) und werden im makefile nach WinAVR/mfile-Vorlage hinter ''ASRC='' durch Leerzeichen getrennt aufgelistet.

Wenn man mit dem AVR Studio arbeitet, kann alternativ auch das standardmäßig erstellte Makefile bearbeitet und folgende Zeilen eingefügt werden:

<div class="code"><pre>
## Objects that must be built in order to link
OBJECTS = (alte Dateien...) useful.o

## Compile
## Hier folgt eine Liste der gelinkten Dateien, darunter einfügen:
useful.o: ../useful.S
$(CC) $(INCLUDES) $(ASMFLAGS) -c $<

</pre></div>
Das war es schon. Allerdings gilt es zu beachten, dass das makefile über "Project -> Configuration options" selbst einzubinden ist, sonst wird es natürlich wieder überschrieben.

Im Beispiel eine Funktion ''superFunc'', die alle Pins des Ports D auf "Ausgang" schaltet, eine Funktion ''ultraFunc'', die die Ausgänge entsprechend des übergebenen Parameters schaltet, eine Funktion ''gigaFunc'', die den Status von Port A zurückgibt und eine Funktion ''addFunc'', die zwei Bytes zu einem 16-bit-Wort addiert. Die Zuweisungen im C-Code (PORTx = ...) verhindern, dass der Compiler die Aufrufe wegoptimiert und dienen nur zur Veranschaulichung der Parameterübergaben.

Zuerst der Assembler-Code. Der Dateiname sei useful.S:

<avrasm>
#include "avr/io.h"

//; Arbeitsregister (ohne "r")
workreg = 16
workreg2 = 17

//; Konstante:
ALLOUT = 0xff

//; ** Setze alle Pins von PortD auf Ausgang **
//; keine Parameter, keine Rückgabe
.global superFunc
.func superFunc
superFunc:
push workreg
ldi workreg, ALLOUT
out _SFR_IO_ADDR(DDRD), workreg // beachte: _SFR_IO_ADDR()
pop workreg
ret
.endfunc

//; ** Setze PORTD auf übergebenen Wert **
//; Parameter in r24 (LSB immer bei "graden" Nummern)
.global ultraFunc
.func ultraFunc
ultraFunc:
out _SFR_IO_ADDR(PORTD), 24
ret
.endfunc

//; ** Zustand von PINA zurückgeben **
//; Rückgabewerte in r24:r25 (LSB:MSB), hier nur LSB genutzt
.global gigaFunc
.func gigaFunc
gigaFunc:
in 24, _SFR_IO_ADDR(PINA)
ret
.endfunc

//; ** Zwei Bytes addieren und 16-bit-Wort zurückgeben **
//; Parameter in r24 (Summand1) und r22 (Summand2) -
//; Parameter sind Word-"aligned" d.h. LSB immer auf "graden"
//; Registernummern. Bei 8-Bit und 16-Bit Paramtern somit
//; beginnend bei r24 dann r22 dann r20 etc.
//; Rückgabewert in r24:r25
.global addFunc
.func addFunc
addFunc:
push workreg
push workreg2
clr workreg2
mov workreg, 22
add workreg, 24
adc workreg2, 1 // r1 - assumed to be always zero ...
movw r24, workreg
pop workreg2
pop workreg
ret
.endfunc

//; oh je - sorry - Mein AVR-Assembler ist eingerostet, hoffe das stimmt so...

.end
</avrasm>

Im Makefile ist der Name der Assembler-Quellcodedatei einzutragen:

<div class="code"><pre>
ASRC = useful.S
</pre></div>

Der Aufruf erfolgt dann im C-Code so:

<c>

#include <stdint.h>
#include <avr/io.h>

extern void superFunc(void);
extern void ultraFunc(uint8_t setVal);
extern uint8_t gigaFunc(void);
extern uint16_t addFunc(uint8_t w1, uint8_t w2);

int main(void)
{
[...]
superFunc();

ultraFunc(0x55);

PORTD = gigaFunc();

PORTA = (addFunc(0xF0, 0x11) & 0xff);
PORTB = (addFunc(0xF0, 0x11) >> 8);
[...]
}
</c>

Das Ergebnis wird wieder in der lss-Datei ersichtlich:

<div class="code"><pre>
[...]
superFunc();
148: 0e 94 f6 00 call 0x1ec

ultraFunc(0x55);
14c: 85 e5 ldi r24, 0x55 ; 85
14e: 0e 94 fb 00 call 0x1f6

PORTD = gigaFunc();
152: 0e 94 fd 00 call 0x1fa
156: 82 bb out 0x12, r24 ; 18

PORTA = (addFunc(0xF0, 0x11) & 0xff);
158: 61 e1 ldi r22, 0x11 ; 17
15a: 80 ef ldi r24, 0xF0 ; 240
15c: 0e 94 ff 00 call 0x1fe
160: 8b bb out 0x1b, r24 ; 27
PORTB = (addFunc(0xF0, 0x11) >> 8);
162: 61 e1 ldi r22, 0x11 ; 17
164: 80 ef ldi r24, 0xF0 ; 240
166: 0e 94 fc 00 call 0x1f8
16a: 89 2f mov r24, r25
16c: 99 27 eor r25, r25
16e: 88 bb out 0x18, r24 ; 24

[...]
000001ec <superFunc>:
// setze alle Pins von PortD auf Ausgang
.global superFunc
.func superFunc
superFunc:
push workreg
1ec: 0f 93 push r16
ldi workreg, ALLOUT
1ee: 0f ef ldi r16, 0xFF ; 255
out _SFR_IO_ADDR(DDRD), workreg
1f0: 01 bb out 0x11, r16 ; 17
pop workreg
1f2: 0f 91 pop r16
ret
1f4: 08 95 ret

000001f6 <ultraFunc>:
.endfunc

// setze PORTD auf übergebenen Wert
.global ultraFunc
.func ultraFunc
ultraFunc:
out _SFR_IO_ADDR(PORTD), 24
1f6: 82 bb out 0x12, r24 ; 18
ret
1f8: 08 95 ret

000001fa <gigaFunc>:
.endfunc

// Zustand von PINA zurückgeben
.global gigaFunc
.func gigaFunc
gigaFunc:
in 24, _SFR_IO_ADDR(PINA)
1fa: 89 b3 in r24, 0x19 ; 25
ret
1fc: 08 95 ret

000001fe <addFunc>:
.endfunc

// zwei Bytes addieren und 16-bit-Wort zurückgeben
.global addFunc
.func addFunc
addFunc:
push workreg
1fe: 0f 93 push r16
push workreg2
200: 1f 93 push r17
clr workreg2
202: 11 27 eor r17, r17
mov workreg, 22
204: 06 2f mov r16, r22
add workreg, 24
206: 08 0f add r16, r24
adc workreg2, 1 // r1 - assumed to be always zero ...
208: 11 1d adc r17, r1
movw r24, workreg
20a: c8 01 movw r24, r16
pop workreg2
20c: 1f 91 pop r17
pop workreg
20e: 0f 91 pop r16
ret
210: 08 95 ret

[...]
</pre></div>

Die Zuweisung von Registern zu Parameternummer und die Register für die Rückgabewerte sind in den "Register Usage Guidelines" der avr-libc-Dokumentation erläutert.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/assembler.html avr-libc-Dokumentation: Related Pages/avr-libc and assembler programs]
* [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_reg_usage avr-libc-Dokumentation: Related Pages/FAQ/"What registers are used by the C compiler?"]

== Globale Variablen für Datenaustausch ==

Oftmals kommt man um globale Variablen nicht herum, z. B. um den Datenaustausch zwischen Hauptprogramm und Interrupt-Routinen zu realisieren.
Hierzu muss man im Assembler wissen, wo genau die Variable vom C-Compiler abgespeichert wird.

Hierzu muss die Variable, hier "zaehler" genannt, zuerst im C-Code als Global definiert werden, z. B. so:

<c>
#include <avr/io.h>

volatile uint8_t zaehler;

int16_t main (void)
{
// irgendein Code, in dem zaehler benutzt werden kann

}
</c>

Im folgenden Assembler-Beispiel wird der Externe Interrupt0 verwendet, um den Zähler hochzuzählen. Es fehlen die Initialisierungen des Interrupts und die Interrupt-Freigabe, so richtig sinnvoll ist der Code auch nicht, aber er zeigt (hoffentlich) wie es geht.

Im Umgang mit Interrupt-Vektoren gilt beim GCC-Assembler das Gleiche, wie bei C: Man muss die exakte Schreibweise beachten, ansonsten wird nicht der Interrupt-Vektor angelegt, sondern eine neue Funktion - und man wundert sich, dass nichts funktionert (vgl. das AVR-GCC-Handbuch).

<avrasm>
#include "avr/io.h"

temp = 16

.extern zaehler

.global INT0_vect
INT0_vect:

push temp //; wichtig: Benutzte Register und das
in temp,_SFR_IO_ADDR(SREG) //; Status-Register (SREG) sichern!
push temp

lds temp,zaehler //; Wert aus dem Speicher lesen
inc temp //; bearbeiten
sts zaehler,temp //; und wieder zurückschreiben

pop temp //; die benutzten Register wiederherstellen
out _SFR_IO_ADDR(SREG),temp
pop temp
reti

.end
</avrasm>

=== Globale Variablen im Assemblerfile anlegen ===

Alternativ können Variablen aber auch im Assemblerfile angelegt werden. Dadurch kann auf eine .c-Datei verzichtet werden. Für das obige Beispiel könnte der Quelltext dann die Dateien zaehl_asm.S und zaehl_asm.h abgelegt werden, so dass nur noch zaehl_asm.S mit kompiliert werden müsste.

Anstatt im Assemblerfile über das Schlüsselwort ''.extern '' auf eine vorhandene Variable zu verweisen, wird dazu mit dem Schlüsselwort ''.comm'' die benötigte Anzahl von Bytes für eine Variable reserviert.

'''zaehl_asm.S'''
<avrasm>
#include "avr/io.h"

temp = 16

//; 1 Byte im RAM für den Zähler reservieren
.comm zaehler, 1

.global INT0_vect
INT0_vect:

...
</avrasm>

In der Headerdatei wird dann auf die Variable nur noch verwiesen (Schlüsselwort ''extern''):

'''zaehl_asm.h'''
<c>
#ifndef ZAEHL_ASM_H
#define ZAEHL_ASM_H

extern volatile uint8_t zaehler;

#endif
</c>

Im Gegensatz zu globalen Variablen in C werden so angelegte Variablen nicht automatisch mit dem Wert 0 initialisiert.

=== Variablen größer als 1 Byte ===

Variablen, die größer als '''ein''' Byte sind, können in Assembler auf ähnliche Art angesprochen werden. Hierzu müssen nur genug Bytes angefordert werden, um die Variable aufzunehmen. Soll z. B. für den Zähler eine Variable vom Typ ''unsigned long'', also ''uint32_t'' verwendet werden, so müssen 4 Bytes reserviert werden:

<avrasm>
...
// 4 Byte im RAM für den Zähler reservieren
.comm zaehler, 4
...
</avrasm>

Die dazugehörige Deklaration im Headerfile wäre dann:
<c>
...
extern volatile uint32_t zaehler;
...
</c>

Bei Variablen, die größer als ein Byte sind, werden die Werte beginnend mit dem niederwertigsten Byte im RAM abgelegt. Das folgende Codeschnippsel zeigt, wie unter Assembler auf die einzelnen Bytes zugegriffen werden kann. Dazu wird im Interrupt nun ein 32-Bit Zähler erhöht:

<avrasm>
#include "avr/io.h"

temp = 16

// 4 Byte im RAM für den Zähler reservieren
.comm zaehler, 4

.global INT0_vect
INT0_vect:

push temp // wichtig: Benutzte Register und das
in temp,_SFR_IO_ADDR(SREG) // Status-Register (SREG) sichern !
push temp

// 32-Bit-Zähler incrementieren
lds temp, (zaehler + 0) // 0. Byte (niederwertigstes Byte)
inc temp
sts (zaehler + 0), temp
brne RAUS

lds temp, (zaehler + 1) // 1. Byte
inc temp
sts (zaehler + 1), temp
brne RAUS

lds temp, (zaehler + 2) // 2. Byte
inc temp
sts (zaehler + 2), temp
brne RAUS

lds temp, (zaehler + 3) // 3. Byte (höchstwertigstes Byte)
inc temp
sts (zaehler + 3), temp
brne RAUS

RAUS:
pop temp // die benutzten Register wiederherstellen
out _SFR_IO_ADDR(SREG),temp
pop temp
reti

.end
</avrasm>

'''TODO:''' 16-Bit / 32-Bit Variablen, Zugriff auf Arrays (Strings)

= Anhang =

== Besonderheiten bei der Anpassung bestehenden Quellcodes ==

Einige Funktionen aus früheren Versionen der avr-libc werden inzwischen als veraltet angesehen. Sie sind nicht mehr vorhanden oder als ''deprecated'' (missbilligt) ausgewiesen und Definitionen in <compat/deprecated.h> verschoben. Es empfiehlt sich, vorhandenen Code zu portieren und die alten Funktionen nicht mehr zu nutzen, auch wenn diese noch zur Verfügung stehen.

=== Veraltete Funktionen zur Deklaration von Interrupt-Routinen ===

Die Funktionen (eigentlich Makros) ''SIGNAL'' und ''INTERRUPT'' zur Deklaration von Interruptroutinen sollten nicht mehr genutzt werden.

In aktuellen Versionen der avr-libc (z. B. avr-libc 1.4.3 aus WinAVR 20060125) werden Interruptroutinen, die '''nicht''' durch andere Interrupts '''unterbrechbar''' sind, mit ISR deklariert (siehe Abschnitt im Hauptteil). Auch die Benennung wurden vereinheitlicht und an die üblichen Bezeichnungen in den AVR Datenblättern angepasst. In der Dokumentation der avr-libc sind alte und neue Bezeichnungen in der Tabelle gegenübergestellt. Die erforderlichen Schritte zur Portierung:

* #include von avr/signal.h entfernen
* SIGNAL durch ISR ersetzen
* Name des Interrupt-Vektors anpassen (SIG_* durch entsprechendes *_vect)

Als Beispiel für die Anpassung zuerst ein "alter" Code:

<c>
#include <avr/interrupt.h>
#include <avr/signal.h>

...

/* Timer2 Output Compare bei einem ATmega8 */
SIGNAL(SIG_OUTPUT_COMPARE2)
{
...
}
</c>

Im Datenblatt wird der Vektor mit TIMER2 COMP bezeichnet. Die Bezeichnung in der avr-libc entspricht dem Namen im Datenblatt, Leerzeichen werden durch Unterstriche (_) ersetzt und ein _vect angehängt.

Der neue Code sieht dann so aus:

<c>
#include <avr/interrupt.h>
/* signal.h entfällt */

ISR(TIMER2_COMP_vect)
{
...
}
</c>

Bei Unklarheiten bezüglich der neuen Vektorlabels hilft (noch) ein Blick in die Headerdatei des entsprechenden Controllers. Für das vorherige Beispiel also der Blick in die Datei iom8.h für den ATmega8, dort findet man die veraltete Bezeichnung unterhalb der aktuellen.

<c>
...
/* $Id: iom8.h,v 1.13 2005/10/30 22:11:23 joerg_wunsch Exp $ */
/* avr/iom8.h - definitions for ATmega8 */

...

/* Timer/Counter2 Compare Match */
#define TIMER2_COMP_vect _VECTOR(3)
#define SIG_OUTPUT_COMPARE2 _VECTOR(3)
...
</c>

Für '''unterbrechbare''' Interruptroutinen, die mittels ''INTERRUPT'' deklariert sind, gibt es keinen direkten Ersatz in Form eines Makros. Solche Routinen sind laut Dokumentation der avr-libc in folgender Form zu deklarieren:

<c>
void XXX_vect(void) __attribute__((interrupt));
void XXX_vect(void) {
...
}
</c>

Beispiel:

<c>
/* ** alt ** */
#include <avr/io.h>
#include <avr/interrupt.h>

//...

INTERRUPT(SIG_OVERFLOW0)
{
...
}

/* ** neu: ** */
#include <avr/io.h>

//...

void TIMER0_OVF_vect(void) __attribute__((interrupt));
void TIMER0_OVF_vect(void)
{
...
}
</c>

Will oder kann man den Code nicht portieren, ist zur weiteren Verwendung von ''INTERRUPT'' die Header-Datei ''compat/deprecated.h'' einzubinden. Man sollte bei dieser Gelegenheit jedoch nochmals überprüfen, ob die Funktionalität von ''INTERRUPT'' tatsächlich gewollt ist. In vielen Fällen wurde ''INTERRUPT'' dort genutzt, wo eigentlich ''SIGNAL'' (nunmehr ''ISR'') hätte genutzt werden sollen.

=== Veraltete Funktionen zum Portzugriff ===

''inp'' und ''outp'' zum Einlesen bzw. Schreiben von Registern sind nicht mehr erforderlich, der Compiler unterstützt dies ohne diesen Umweg.

<c>
unsigned char i, j;

// alt:
i = inp(PINA);
j = 0xff;
outp(PORTB, j);

// neu (nicht mehr wirklich neu...):
i = PINA
j = 0xff;
PORTB = j;
</c>

Will oder kann man den Code nicht portieren, ist zur weiteren Verwendung von inp und outp die Header-Datei '''compat/deprecated.h''' einzubinden.

=== Veraltete Funktionen zum Zugriff auf Bits in Registern ===

''cbi'' und ''sbi'' zum Löschen und Setzen von Bits sind nicht mehr erforderlich, der Compiler unterstützt dies ohne diesen Umweg. Die Bezeichnung ist ohnehin irreführend da die Funktionen nur für Register mit Adressen im unteren Speicherbereich tatsächlich in die Assembleranweisungen cbi und sbi übersetzt werden.

<c>
// alt:
sbi(PORTB, PB2);
cbi(PORTC, PC1);

// neu (auch nicht mehr wirklich neu...):
PORTB |= (1<<PB2);
PORTC &= ~(1<<PC1);
</c>

Will oder kann man den Code nicht portieren, ist zur weiteren Verwendung von sbi und cbi die Header-Datei '''compat/deprecated.h''' einzubinden. Wer unbedingt will, kann sich natürlich eigene Makros mit aussagekräftigeren Namen definieren. Zum Beispiel:

<c>
#define SET_BIT(PORT, BITNUM) ((PORT) |= (1<<(BITNUM)))
#define CLEAR_BIT(PORT, BITNUM) ((PORT) &= ~(1<<(BITNUM)))
#define TOGGLE_BIT(PORT, BITNUM) ((PORT) ^= (1<<(BITNUM)))
</c>

=== Selbstdefinierte (nicht-standardisierte) ganzzahlige Datentypen ===

Bei den im Folgenden genannten Typdefinitionen ist zu beachten, dass die Bezeichnungen für "Worte" teilweise je nach Prozessorplattform unterschiedlich verwendet werden. Die angegebenen Definitionen beziehen sich auf die im Zusammenhang mit AVR/8-bit-Controllern üblichen "Bit-Breiten" (In Erläuterungen zum ARM7TDMI z. B. werden oft 32-bit Integer mit "Wort" ohne weitere Ergänzung bezeichnet). Es empfiehlt sich, bei der Überarbeitung von altem Code die im Abschnitt ''standardisierten ganzzahligen Datentypen'' beschriebenen Datentypen zu nutzen (stdint.h) und damit "Missverständnissen" vorzubeugen, die z. B. bei der Portierung von C-Code zwischen verschiedenen Plattformen auftreten können.

<c>
typedef unsigned char BYTE; // besser: uint8_t aus <stdint.h>
typedef unsigned short WORD; // besser: uint16_t aus <stdint.h>
typedef unsigned long DWORD; // besser: uint32_t aus <stdint.h>
typedef unsigned long long QWORD; // besser: uint64_t aus <stdint.h>
</c>

; BYTE : Der Datentyp BYTE definiert eine Variable mit 8 Bit Breite zur Darstellung von ganzen Zahlen im Bereich zwischen 0 ... 255.

; WORD : Der Datentyp WORD definiert eine Variable mit 16 Bit Breite zur Darstellung von ganzen Zahlen im Bereich zwischen 0 ... 65535.

; DWORD : Der Datentyp DWORD (gesprochen: Double-Word) definiert eine Variable mit 32 Bit Breite zur Darstellung von ganzen Zahlen im Bereich zwischen 0 ... 4294967295.

; QWORD : Der Datentyp QWORD (gesprochen: Quad-Word) definiert eine Variable mit 64 Bit Breite zur Darstellung von ganzen Zahlen im Bereich zwischen 0 ... 18446744073709551615.

== Zusätzliche Funktionen im Makefile ==

=== Bibliotheken (Libraries/.a-Dateien) hinzufügen ===

Um Funktionen aus Bibliotheken ("echte" Libraries, *.a-Dateien) zu nutzen, sind dem Linker die Namen der Bibliotheken als Parameter zu übergeben. Dazu ist die Option -l (kleines L) vorgesehen, an die der Name der Library angehängt wird.

Dabei ist zu beachten, dass der Name der Library und der Dateiname der Library nicht identisch sind. Der hinter -l angegebene Name entspricht dem Dateinamen der Library ohne die Zeichenfolge ''lib'' am Anfang des Dateinamens und ohne die Endung ''.a''. Sollen z. B. Funktionen aus einer Library mit dem Dateinamen ''libefsl.a'' eingebunden (gelinkt) werden, lautet der entsprechende Parameter -lefsl (vergl. auch -lm zum Anbinden von libm.a).

In Makefiles wird traditonell eine make-Variable LDLIBS genutzt, in die "l-Parameter" abgelegt werden. Die WinAVR-makefile-Vorlage enthält diese Variable zwar nicht, dies stellt jedoch keine Einschränkung dar, da alle in der make-Variable LDFLAGS abgelegten Parameter an den Linker weitergereicht werden.

Beispiele:

<div class="code"><pre>
# Einbinden von Funktionen aus einer Library efsl (Dateiname libefsl.a)
LDFLAGS += -lefsl
# Einbinden von Funktionen aus einer Library xyz (Dateiname libxyz.a)
LDFLAGS += -lxyz
</pre></div>

Liegen die Library-Dateien nicht im Standard Library-Suchpfad, sind die Pfade mittels Parameter ''-L'' ebenfalls anzugeben. (Der vordefinierte Suchpfad kann mittels ''avr-gcc --print-search-dirs'' angezeigt werden.)

Als Beispiel ein Projekt ("superapp2"), in dem der Quellcode von zwei Libraries (efsl und xyz) und der Quellcode der eigentlichen Anwendung in verschiedenen Verzeichnissen mit der folgenden "Baumstruktur" abgelegt sind:

<div class="code"><pre>
superapp2
|
+----- efslsource (darin libefsl.a)
|
+----- xyzsource (darin libxyz.a)
|
+----- firmware (darin Anwendungs-Quellcode und Makefile)
</pre></div>

Daraus folgt, dass im Makefile die Verzeichnis efslsource und xyzsource in den Library-Suchpfad aufzunehmen sind:

<div class="code"><pre>
LDFLAGS += -L../efslsource/ -L../xyzsource/
</pre></div>

=== Fuse-Bits ===

Zur Berechnung der Fuse-Bits bietet sich neben dem Studium des Datenblattes auch der [http://palmavr.sourceforge.net/cgi-bin/fc.cgi AVR Fuse Calculator] an. Gewarnt werden muss vor der Benutzung von PonyProg, weil dort durch die negierte Darstellung gern Fehler gemacht werden.

Soll die Programmierung von Fuse- und Lockbits automatisiert werden, kann man dies ebenfalls durch Einträge im Makefile vornehmen, die beim Aufruf von "make program" an die genutzte Programmiersoftware übergeben werden. In der makefile-Vorlage von WinAVR (und mfile) gibt es dafuer jedoch keine "Ausfüllhilfe" (Stand 9/2006). Die folgenden Ausführungen gelten für die Programmiersoftware [[AVRDUDE]] (Standard in der WinAVR-Vorlage), können jedoch sinngemäß auf andere Programmiersoftware übertragen werden, die die Angabe der Fuse- und Lockbits-Einstellungen per Kommandozeilenparameter unterstützt (z. B. stk500.exe). Im einfachsten Fall ergänzt man im Makefile einige Variablen, deren Werte natürlich vom verwendeten Controller und den gewünschten Einstellungen abhängen (vgl. Datenblatt Fuse-/Lockbits):

<c>
#---------------- Programming Options (avrdude) ----------------

#...
#Beispiel! f. ATmega16 - nicht einfach uebernehmen! Zahlenwerte anhand
#--------- des Datenblatts nachvollziehen und gegebenenfalls aendern.
#
AVRDUDE_WRITE_LFUSE = -U lfuse:w:0xff:m
AVRDUDE_WRITE_HFUSE = -U hfuse:w:0xd8:m
AVRDUDE_WRITE_LOCK = -U lock:w:0x2f:m
#...
</c>

Damit diese Variablen auch genutzt werden, ist der Aufruf von avrdude im Makefile entsprechend zu ergänzen:

<c>
# Program the device.
program: $(TARGET).hex $(TARGET).eep
# ohne Fuse-/Lock-Einstellungen (nach WinAVR Vorlage Stand 4/2006)
# $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) \
# $(AVRDUDE_WRITE_EEPROM)
# mit Fuse-/Lock-Einstellungen
$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_LFUSE) \
$(AVRDUDE_WRITE_HFUSE) $(AVRDUDE_WRITE_FLASH) \
$(AVRDUDE_WRITE_EEPROM) $(AVRDUDE_WRITE_LOCK)
</c>

Eine weitere Möglichkeit besteht darin, die Fuse- und Lockbit-Einstellungen vom Preprozessor/Compiler generieren zu lassen. Die Fuse-Bits werden dann bei Verwendung von AVRDUDE in eigene Hex-Files geschrieben. Hierzu kann man z. B. folgendes Konstrukt verwenden:

In eine der C-Sourcen wird eine Variable je Fuse-Byte vom Typ ''unsigned char'' deklariert und in eine extra Section gepackt. Dies kann entweder in einem vorhandenen File passieren oder in ein neues (z. B. fuses.c) geschrieben werden. Das File muss im Makefile aber auf jeden Fall mit kompiliert und gelinkt werden.

<c>
// tiny 2313 fuses low byte
#define CKDIV8 7
#define CKOUT 6
#define SUT1 5
#define SUT0 4
#define CKSEL3 3
#define CKSEL2 2
#define CKSEL1 1
#define CKSEL0 0

// tiny2313 fuses high byte
#define DWEN 7
#define EESAVE 6
#define SPIEN 5
#define WDTON 4
#define BODLEVEL2 3
#define BODLEVEL1 2
#define BODLEVEL0 1
#define RSTDISBL 0

// tiny2313 fuses extended byte
#define SELFPRGEN 0

#define LFUSE __attribute__ ((section ("lfuses")))
#define HFUSE __attribute__ ((section ("hfuses")))
#define EFUSE __attribute__ ((section ("efuses")))

// select ext crystal 3-8Mhz
unsigned char lfuse LFUSE =
( (1<<CKDIV8) | (1<<CKOUT) | (1<<CKSEL3) | (1<<CKSEL2) |
(0<<CKSEL1) | (1<<CKSEL0) | (0<<SUT1) | (1<<SUT0) );
unsigned char hfuse HFUSE =
( (1<<DWEN) | (1<<EESAVE) | (0<<SPIEN) | (1<<WDTON) |
(1<<BODLEVEL2) | (1<<BODLEVEL1) | (0<<BODLEVEL0) | (1<<RSTDISBL) );
unsigned char efuse EFUSE =
((0<<SELFPRGEN));
</c>

'''ACHTUNG: Die Bitpositionen wurden nicht vollständig getestet!'''

Eine "1" bedeutet hier, dass das Fuse-Bit ''nicht'' programmiert wird - die Funktion also i.A. nicht aktiviert ist. Eine "0" hingegen aktiviert die meisten Funktionen. Dies ist wie im Datenblatt (1 = unprogrammed, 0 = programmed).

Das Makefile muss nun noch um folgende Targets erweitert werden (mit Tabulator einrücken - nicht mit Leerzeichen):

<div class="code"><pre>
lfuses: build
-$(OBJCOPY) -j lfuses --change-section-address lfuses=0 \
-O ihex $(TARGET).elf $(TARGET)-lfuse.hex
@if [ -f $(TARGET)-lfuse.hex ]; then \
$(AVRDUDE) $(AVRDUDE_FLAGS) -U lfuse:w:$(TARGET)-lfuse.hex; \
fi;

hfuses: build
-$(OBJCOPY) -j hfuses --change-section-address hfuses=0 \
-O ihex $(TARGET).elf $(TARGET)-hfuse.hex
@if [ -f $(TARGET)-hfuse.hex ]; then \
$(AVRDUDE) $(AVRDUDE_FLAGS) -U hfuse:w:$(TARGET)-hfuse.hex; \
fi;

efuses: build
-$(OBJCOPY) -j efuses --change-section-address efuses=0 \
-O ihex $(TARGET).elf $(TARGET)-efuse.hex
@if [ -f $(TARGET)-efuse.hex ]; then \
$(AVRDUDE) $(AVRDUDE_FLAGS) -U efuse:w:$(TARGET)-efuse.hex;
fi;
</pre></div>

Das Target "clean" muss noch um die Zeilen
<div class="code"><pre>
$(REMOVE) $(TARGET)-lfuse.hex
$(REMOVE) $(TARGET)-hfuse.hex
$(REMOVE) $(TARGET)-efuse.hex
</pre></div>
erweitert werden, wenn auch die Fuse-Dateien gelöscht werden sollen.

Um nun die Fusebits des angeschlossenen Controllers zu programmieren muss lediglichein "make lfuses", "make hfuses" oder "make efuses" gestartet werden.
Bei den Fuse-Bits ist besondere Vorsicht geboten, da diese das Programmieren des Controllers unmöglich machen können. Also erst programmieren, wenn man einen HV-Programmierer hat oder ein paar Reserve-AVRs zur Hand ;-)

Um weiterhin den "normalen" Flash beschreiben zu können, ist es wichtig, für das Target "*.hex" im Makefile nicht nur "-R .eeprom" als Parameter zu übergeben sondern zusätzlich noch "-R lfuses -R efuses -R hfuses". Sonst bekommt AVRDUDE Probleme diese Sections in den Flash (wo sie ja nicht hingehören) zu schreiben.

Siehe auch: [[AVR_Fuses#Vergleich_der_Fuses_bei_verschiedenen_Programmen|Vergleich der Fuses bei verschiedenen Programmen]]

== Externe Referenzspannung des internen Analog-Digital-Wandlers ==

Die minimale (externe) Referenzspannung des ADC darf nicht beliebig niedrig sein, vgl. dazu das (aktuellste) Datenblatt des verwendeten Controllers. z. B. beim ATMEGA8 darf sie laut Datenblatt (S.245, Tabelle 103, Zeile "VREF") 2,0V nicht unterschreiten. HINWEIS: diese Information findet sich erst in der letzten Revision (Rev. 2486O-10/04) des Datenblatts.

Meiner  eigenen Erfahrung nach kann man aber (auf eigene Gefahr und natürlich nicht für Seriengeräte) durchaus noch ein klein wenig weiter heruntergehen, bei dem von mir unter die Lupe genommenen ATMEGA8L (also die Low-Voltage-Variante) funktioniert der ADC bei 5V Betriebsspannung mit bis zu VREF=1,15V hinunter korrekt, ab 1,1V und darunter digitalisiert er jedoch nur noch Blödsinn). Ich würde sicherheitshalber nicht unter 1,5V gehen und bei niedrigeren Betriebsspannungen mag sich die Untergrenze für VREF am Pin AREF ggf. nach oben'''(!)''' verschieben.

In der letzten Revision des Datenblatts ist außerdem korrigiert, dass ADC4 und ADC5 sehr wohl 10 Bit Genauigkeit bieten (und nicht bloß 8 Bit, wie in älteren Revisionen irrtümlich angegeben.)

= Watchdog =
Siehe auch http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_Watchdog

= TODO =
* Aktualisierung Register- und Bitbeschreibungen an aktuelle AVR
* stdio.h, malloc()
* "naked"-Funktionen
* Bootloader (bez. auf boot.h)
* Übersicht zu den C bzw. GCC-predefined Makros (__DATE__, __TIME__,...)

= Softwareentwicklung =

"Wild drauflos" zu programmieren kann nach einiger Zeit frustrieren, da mehr Zeit erforderlich wird, das Programm neuen Anforderungen anzupassen.
Wer erst etwas Zeit darauf verwendet, ein offenes Konzept (erweiterbare Programmstruktur, Algorithmen) zu entwickeln (ggf. in Ruhe mit Papier und Bleistift), wird später schneller ans Ziel gelangen.

http://de.wikipedia.org/wiki/Softwareentwicklung

= Programmierstil =

Damit ein größeres Programm (nach längerer Zeit) überschaubar bleibt, sollte man sich bei der Gliederung, Namensgebung, Formatierung und Kommentierung an bewährten, begründeten Konzepten orientieren.
* http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=48535&postdays=0&postorder=asc Modularizing C Code: Managing large projects

* http://www.mikrocontroller.net/articles/Include-Files_(C)

* http://www.mikrocontroller.net/topic/130218

* http://www.elektroniknet.de/home/embeddedsystems/fachwissen/uebersicht/software/entwicklungssoftware/der-programmierstandard-misra/

* http://www.mikrocontroller.net/topic/132304

* http://de.wikipedia.org/wiki/Programmierstil

[[Kategorie:avr-gcc Tutorial| ]]
[[Kategorie:AVR]]

Lokale Elektroniklieferanten

2010-07-19T12:46:51Z

Hugstuart: /* Herne */

=Einleitung=
Da nicht jeder beim Fehlen einzelner Bauteile eine Online-Bestellung aufgeben möchte und der eine oder andere regionale Anbieter nicht so gut zu finden ist, soll hier eine Liste entstehen, die hilft Anbieter zu finden.

__TOC__

Falls die Darstellungsart nicht gefällt oder Rubriken fehlen, so bitte nicht hier ändern, sondern das Template anpassen: [[Vorlage:ElektronikLieferant]] 
So soll das Template ausgefüllt werden:
{{ElektronikLieferant
|Firmenname=hier Firmenname eintragen
|Straße=Straßenname, z. B. Musterstraße 123
|PLZ=PLZ, z. B. 12345
|Ort=Ort, z. B. München
|Telefon=Telnr., z. B. 012345/12341234
|Fax=Faxnr., z. B. 012345/12345234
|Öffnungszeiten=Öffnungszeiten eintragen Neue Zeile mit "br" abgetrennt
|Weblink=http://www.mikrocontroller.net Link ohne umschliessende eckige Klammern
|Email=Emailadresse, z. B. xxx@yyy.de
|Bemerkung=ggf. Bemerkung, ansonsten Rubrik/Feld/Variable leer lassen
}}

=Deutschland=
==Baden-Württemberg==
===Aalen===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Wilhelm-Zapf-Str. 9
|PLZ=73430
|Ort=Aalen
|Telefon=07361/610820
|Fax=07361/610821
|Öffnungszeiten=Mo.-Fr. 9.00 - 13.00 Uhr, 14.00 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com
|Email=info@muekra.de
|Bemerkung=Keine SMD-Teile
}}
===Esslingen===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Bahnhofstr. 23
|PLZ=73728
|Ort=Esslingen
|Telefon=0711/355676
|Fax=0711/3108656
|Öffnungszeiten=Mo.-Fr. 9.00 - 13.00 Uhr, 14.30 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com/FilES.php
|Email=info@muekra.de
|Bemerkung=Keine Mikrocontroller, keine SMD-Teile (ausser einige wenige Transistoren)
}}
===Freiburg===
{{ElektronikLieferant
|Firmenname=Omega electronic GmbH
|Straße=Eschholzstr. 58-60
|PLZ=79115
|Ort=Freiburg
|Telefon=0761/76776-0
|Fax=0761/76776-55
|Öffnungszeiten=Mo.-Sa.: 10:00 - 19:30
|Weblink=http://www.omega-electronic.de
|Email=info@omega-electronic.de
|Bemerkung=
}}
===Karlsbad===
{{ElektronikLieferant
|Firmenname=IT-WNS, Ute Heldt
|Straße=Schulstr. 13
|PLZ=76307
|Ort=Karlsbad - Mutschelbach
|Telefon=07202/936083
|Fax=07202/936085
|Öffnungszeiten=Nach Vereinbahrung (Email-Kontakt)
|Weblink=http://www.it-wns.de
|Email=info@it-wns.de
|Bemerkung=Bestellungen im Onlineshop können wahlweise auch direkt abgeholt werden
}}

===Karlsruhe===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Fritz-Erler-Straße 24
|PLZ=76133
|Ort=Karlsruhe
|Telefon=0721/374270
|Fax=0721/9379171
|Öffnungszeiten=Mo.-Fr. 9.00 - 13.00 Uhr, 14.30 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://www.muekra.com/Filiale_Karlsruhe
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Mc TEC Elektronik Vertriebs GmbH
|Straße=Kaiserstrasse 160
|PLZ=76133
|Ort=Karlsruhe
|Telefon=0721/24456
|Fax=0721/20061
|Öffnungszeiten=Mo.-Fr. 10.00 - 19.00 Uhr Sa. 10.00 - 15.00 Uhr
|Weblink=http://www.mctec.de/
|Email=
|Bemerkung=Vorübergehend geschlossen, Website down???
}}

===Offenburg===
{{ElektronikLieferant
|Firmenname=Günther Wultschner (Elektronikladen)
|Straße=Luisenstraße 16
|PLZ=77654
|Ort=Offenburg
|Telefon=0781 43270‎
|Fax=
|Öffnungszeiten=Mo.-Fr. 9.00 - 19:00 Uhr Sa. 9.00 - 16.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

===Reutlingen===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Federnseestr. 4
|PLZ=72764
|Ort=Reutlingen
|Telefon=07121/370748
|Fax=07121/370741
|Öffnungszeiten=Mo.-Fr. 9.30 - 13.00 Uhr, 14.00 - 18.00 Uhr Sa. 9.30 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com
|Email=info@muekra.de
|Bemerkung=Keine SMD-Teile
}}

===Ulm===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Neutorstr. 20
|PLZ=89073
|Ort=Ulm
|Telefon=0731/64494
|Fax=0731/6028676
|Öffnungszeiten=Mo.-Fr. 9.00 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com/FilUlm.php
|Email=
|Bemerkung=Keine SMD-Teile
}}

===Villingen-Schwenningen===
{{ElektronikLieferant
|Firmenname=Buchmann Elektronik
|Straße=Wasenstrasse 51
|PLZ=78054
|Ort=Villingen-Schwenningen
|Telefon=07720/1308
|Fax=07720/1360
|Öffnungszeiten=Mo-Fr., ausser Mittwoch; Zeiten leider unbekannt
|Weblink=keine Webseite
|Email=buchmann-elektronik@t-online.de
|Bemerkung=keine SMD.
}}

{{ElektronikLieferant
|Firmenname=SchiBe Elektronik
|Straße=Mühlenstr. 9
|PLZ=78050
|Ort=Villingen-Schwenningen
|Telefon=07721/8879880
|Fax=07721/88798820
|Öffnungszeiten=Mo-Fr.; Zeiten leider unbekannt
|Weblink=http://www.schibe.de
|Email=info@SchiBe.de
|Bemerkung=Bestellt auf Anfrage ohne Versandkosten bei Conrad mit Selbstabholung dort.
}}

==Bayern==
===Aschaffenburg===
{{ElektronikLieferant
|Firmenname=VS Elektronik OHG
|Straße= Magnolienweg 3
|PLZ= 63739
|Ort=Aschaffenburg
|Telefon=06021-30460
|Fax=06021-304626
|Öffnungszeiten= Montag - Freitag: 09:00 - 18:00 Uhr Samstag: 09:00 - 13:00 Uhr
|Weblink=http://www.vs-electronic.de
|Email=info@vs-electronic.de
|Bemerkung= führt Vellemann Bausätze, PCs, Telekommunikation und Bauteile
}}

===Erlangen===
{{ElektronikLieferant
|Firmenname=Radio-Fernseh-Elektronik
|Straße=Beethovenstraße 2
|PLZ=91052
|Ort=Erlangen‎
|Telefon=09131 25288‎
|Fax=
|Öffnungszeiten=
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Feller-electronic
|Straße=Marquardsenstraße 21
|PLZ=91054
|Ort=Erlangen‎
|Telefon=09131 27595
|Fax=
|Öffnungszeiten=Mo-Fr 9.00 - 13.00, 14.00-18.00 Uhr. Sa 9.00 - 14.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

===Fürth===
{{ElektronikLieferant
|Firmenname=B+D Electronic GmbH
|Straße=Königstr. 107 (gegenüber Citycenter und neben Feuerwehr)
|PLZ=90762
|Ort=Fürth
|Telefon=0911 - 77 30 40
|Fax=
|Öffnungszeiten=Mo - Fr: 10.00 - 12.30 & 14.00 - 18.00 Sa: 10.00 - 13.00
|Weblink=http://www.bdelectronic.de/
|Email=
|Bemerkung=
}}

=== Kaufbeuren ===
{{ElektronikLieferant
|Firmenname=Jantsch-Elektronik GmbH
|Straße=Porschestrasse 26
|PLZ=87600
|Ort=Kaufbeuren
|Telefon=0 83 41 / 95 33-0
|Fax=0 83 41 / 37 00
|Öffnungszeiten=Mo-Fr 9:00-12:30 / 13:30-18:00 
Sa 9:00-13:00 Uhr
|Weblink= http://www.j-e.de
|Email=info@j-e.de
|Bemerkung=führt auch gebrauchte Messgeräte
}}

===Leiblfing (bei Straubing)===
{{ElektronikLieferant
|Firmenname=Hans Entner Funkelektronik
|Straße=Landshuter Straße 1
|PLZ=94339
|Ort=Leiblfing
|Telefon=(0 94 27) 90 20 86
|Fax=09427 - 902087
|Öffnungszeiten= leider nicht bekannt
|Weblink=
|Email=Entner-DF9RJ@t-online.de
|Bemerkung= Kleiner Laden und sehr netter Inhaber. Einige Geräte und Zubehör. Viele HF-Stecker (v.a. SMA, BNC, N und PL(UHF)) und Koax-Kabel. Bietet auch Reparaturen an.
}}

===München===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Tal 29
|PLZ=80331
|Ort=München
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Fr: 9:00 - 20:00 Sa: 9:00 - 20:00
|Weblink=http://www.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Hanauer Straße 91 (gegenüber OEZ)
|PLZ=80993
|Ort=München - Moosach
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Fr: 9:30 - 20:00 Sa: 9:00 - 20:00
|Weblink=http://www.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Bürklin
|Straße=Schillerstr. 41
|PLZ=80336
|Ort=München
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Do: 9:00 - 16:30 Fr: 9:00 - 13:00
|Weblink=http://buerklin.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Strixner & Holzinger
|Straße=Schillerstraße 25-29
|PLZ=80336
|Ort=München
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Fr: 9:30 - 18:00
|Weblink=http://sh-halbleiter.de/
|Email=
|Bemerkung=
}}

===Schweinfurt===
{{ElektronikLieferant
|Firmenname=Spath Elektronische Bauteile
|Straße=Cramerstr. 9
|PLZ=97421
|Ort=Schweinfurt
|Telefon=09721/25186
|Fax=09721/22999
|Öffnungszeiten=
|Weblink=
|Email=
|Bemerkung=
}}

===Straubing===
{{ElektronikLieferant
|Firmenname=Röhrner Electronic
|Straße=Innere Passauer Str. 12
|PLZ=94315
|Ort=Straubing
|Telefon=09421/12573
|Fax=09421/22207
|Öffnungszeiten=Mo - Do: 9:00 - 18:00 Sa: 10:00 - 13:00
|Weblink=http://www.roehrner-electronic.de/
|Email=
|Bemerkung=Netter Elektronikladen mit vielen Halbleitern neben dem üppigen Standardsortiment
}}

===Pförring===
{{ElektronikLieferant
|Firmenname=Pollin
|Straße=Max-Pollin-Straße 1
|PLZ=85104
|Ort=Pförring
|Telefon=
|Fax=
|Öffnungszeiten=Mo.-Fr. 9 - 19 Uhr Sa. 9 - 16 Uhr
|Weblink=http://www.pollin.de/shop/static/ecenter.htm
|Email=
|Bemerkung=nähe Ingolstadt
}}

==Berlin==
===Charlottenburg-Wilmersdorf===
{{ElektronikLieferant
|Firmenname=Segor-electronics
|Straße=Kaiserin-Augusta-Alle 94
|PLZ=10589
|Ort=Berlin
|Telefon=030 4399843
|Fax=030 4399855
|Öffnungszeiten=Mo.-Fr. 10.00-13.30 Uhr und 14:30-18:00 Uhr, Sa. 10.00-13.00 Uhr
|Weblink=http://www.segor.de
|Email=sales@segor.de
|Bemerkung=Sehr gut sortiertes und vielseitiges Sortiment, preiswert, hochwertig.
}}
===Berlin Schöneberg===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Kleiststraße 30-31
|PLZ=10787
|Ort=Berlin
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Atzert Radio
|Straße=Kleiststraße 32-33
|PLZ=10787
|Ort=Berlin
|Telefon=030/212984-0
|Fax=030/212984-11
|Öffnungszeiten=Montag-Samstag 10:00-19.00 Uhr
|Weblink=http://www.atzert-radio.de/
|Email=
|Bemerkung=
}}

===Berlin Kreuzberg===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Hasenheide 14-15
|PLZ=10967
|Ort=Berlin
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Fr. 10.00-20.00 Uhr, Sa. 10.00-18.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

===Berlin Steglitz===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Schloßstrasse 34-36
|PLZ=12163
|Ort=Berlin
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Do. 10.00-20.00 Uhr, Fr.-Sa. 10.00-22.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Brandenburg==
===Frankfurt (Oder)===

{{ElektronikLieferant
|Firmenname=Elektronik Service Landrock
|Straße=Karl-Ritter-Platz 8-9
|PLZ=15230
|Ort=Frankfurt (Oder)
|Telefon=0335 / 6802029
|Fax=0335 / 684171
|Öffnungszeiten=Mo-Fr. 10-18 Uhr
|Weblink=http://www.landrock-elektronik.de/
|Email=
|Bemerkung=Jürgen (Chef) ist superfreundlich, habe jahrelang dort eingekauft.
}}

==Bremen==
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Borgwardstr. 2
|PLZ=28279
|Ort=Bremen
|Telefon=01 80 / 55 64 44 5
|Fax=
|Öffnungszeiten=
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Schuricht Distrelec GmbH
|Straße=Rehland 8
|PLZ=28832
|Ort=Achim
|Telefon= 04 20 2 / 97 47-97
|Fax=
|Öffnungszeiten=
|Weblink=https://www.distrelec.de
|Email=
|Bemerkung= Nur telefonische Bestellung. Wenn man bei der Bestellung explizit sagt dass man die Sachen in Achim abholen möchte, dann klappt dies auch... meistens...
}}

==Hamburg==
===Harburg===
{{ElektronikLieferant
|Firmenname=Electronic 70
|Straße=Küchgarten 21
|PLZ=21073
|Ort=Hamburg
|Telefon=040 / 77 81 08
|Fax=
|Öffnungszeiten=Mo. - Fr. 9.30 - 13.00 Uhr 14.00 - 18.00 Uhr 
Samstag 10.00 - 14.00 Uhr
|Weblink=http://electronic70.de
|Email=
|Bemerkung= Nett und kompetent.
}}

===Sankt Pauli (Schanzenviertel)===
{{ElektronikLieferant
|Firmenname=Radio Kölsch
|Straße=Schanzenstr. 1
|PLZ=20357
|Ort=Hamburg
|Telefon=040 / 43 46 56
|Fax=040 / 439 09 25
|Öffnungszeiten=
|Weblink=http://www.koelsch24.com
|Email=
|Bemerkung=
}}

===Hoheluft Ost===
{{ElektronikLieferant
|Firmenname=Statronic
|Straße=Eppendorfer Weg 244
|PLZ=20251
|Ort=Hamburg
|Telefon=040 / 422 33 22
|Fax=040 / 422 33 25
|Öffnungszeiten=
|Weblink=http://www.statronic.de
|Email=
|Bemerkung=
}}

===Wandsbek===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Wandsbeker Zollstr. 67-69
|PLZ=22041
|Ort=Hamburg
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Fr. 09.30-20.00 Uhr, Sa. 09.00-18.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

===Altona===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Hahnenkamp 1
|PLZ=22765
|Ort=Hamburg
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Hessen==
===Darmstadt===
{{ElektronikLieferant
|Firmenname=Zimmermann Electronic GmbH
|Straße=Kasinostr. 2
|PLZ=64293
|Ort=Darmstadt
|Telefon=06151 - 66 69 - 240
|Fax=06151 - 66 69 - 290
|Öffnungszeiten=Mo.- Fr. 9:00 - 19:00 Uhr Sa. 9:00 - 14:00 Uhr
|Weblink=http://www.zeg-shop.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=EBG Electronic Business GmbH
|Straße=Bismarckstr. 61
|PLZ=64293
|Ort=Darmstadt
|Telefon=06151 / 82 91 - 0
|Fax=06151 / 82 91 - 20
|Öffnungszeiten=Montag-Freitag: 9:00 bis 19:00 Uhr Samstag: 9:00 bis 14:00 Uhr
|Weblink=http://www.ebg-darmstadt.de
|Email=info@ebg-darmstadt.de
|Bemerkung=
}}

===Offenbach===
{{ElektronikLieferant
|Firmenname=Rail Electronic
|Straße=Großer Biergrund 4
|PLZ=63065
|Ort=Offenbach
|Telefon=069 / 88 20 72
|Fax=069 / 88 31 14
|Öffnungszeiten=Mo.- Fr. 09.30 bis 12.30 sowie 13.30 bis 18.30 Uhr Sa. 9.30 bis 13.30 Uhr
|Weblink=http://www.rail-electronic.de
|Email=
|Bemerkung=
}}

===Wöllstadt===
{{ElektronikLieferant
|Firmenname=ELW Elektronik Handels GMBH
|Straße=Am Kalkofen 10
|PLZ=61206
|Ort=Wöllstadt
|Telefon=06034-4411
|Fax=06034-5739
|Öffnungszeiten=Mo-Fr 08.30 - 18.00 Uhr Sa 08.30 - 13.00 Uhr
|Weblink=http://www.elw-elektronik.com/
|Email=elw-gmbh@t-online.de
|Bemerkung=
}}

===Frankfurt/Main===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Zeil 58 + 64 (Konstabler Wache)
|PLZ=60313
|Ort=Frankfurt
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Mi. 10.00-20.00 Uhr Do.-Sa. 10.00-21.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Mecklenburg-Vorpommern==
===Rostock===
{{ElektronikLieferant
|Firmenname=A-Z City-Stores
|Straße=Doberaner-Hof
|PLZ=
|Ort=Rostock
|Telefon=0381-4031171
|Fax=
|Öffnungszeiten=Mo. – Fr. 9.30 – 19.30 Uhr Sa. 9.30 – 16.00 Uhr
|Weblink=
|Email=
|Bemerkung=geringes Angebot recht teuer
}}

==Niedersachsen==
===Braunschweig===
{{ElektronikLieferant
|Firmenname=Conrad Electronic GmbH
|Straße=Sudetenstr. 4
|PLZ=38114
|Ort=Braunschweig
|Telefon= 0531 501514
|Fax=
|Öffnungszeiten=Mo.-Fr. 09.30-19.00 Uhr, Sa. 09.00-18.00 Uhr
|Weblink=http://www.filialen.conrad.de/
|Email=
|Bemerkung= Hinter dem Conrad-Gebäude gibt es noch eine "Resterampe" mit Garantiefällen, unvollständigen Bausätzen etc. (andere Öffnungszeiten!)
}}

{{ElektronikLieferant
|Firmenname=EFB - Electronic Fundgrube Braunschweig
|Straße=Kreuzstrasse 65
|PLZ=38118
|Ort=Braunschweig
|Telefon=0531-58 11 058
|Fax=0531-58 11 059
|Öffnungszeiten=
|Weblink=http://www.efb-online.de/
|Bemerkung= Online-Katalog unter http://www.megakick-stores.de/.
}}

{{ElektronikLieferant
|Firmenname=Elektronik Bauteile Vertrieb - Dipl.-Ing. Jörg Bassenberg
|Straße=Nußbergstraße 9
|PLZ=38102
|Ort=Braunschweig
|Telefon=0531-79 17 07
|Fax=0531-7 60 22
|Öffnungszeiten=
|Weblink=http://www.bassenberg.de/
|Email=info@bassenberg.de
|Bemerkung= Kleines Ladengeschäft, hauptsächlich ältere Bauteile vorrätig.
}}

===Hannover===
{{ElektronikLieferant
|Firmenname=Conrad Electronic GmbH
|Straße=Goseriede 3
|PLZ=30159
|Ort=Hannover
|Telefon= 0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 09.00-20.00 Uhr
|Weblink=http://www.filialen.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Radio Menzel-Electronic
|Straße=Limmerstraße 3-5
|PLZ=30451
|Ort=Hannover
|Telefon= 0511 442607
|Fax=
|Öffnungszeiten=Mo-Fr: 10:00-13:30, 14:30-18:00 Sa: 10:00-13:30
|Weblink=www.menzel-electronic.de
|Email=
|Bemerkung=
}}

===Lüneburg===
{{ElektronikLieferant
|Firmenname=Beusch Elektronik
|Straße=Reichenbachstr. 8
|PLZ=21335
|Ort=Lüneburg
|Telefon=04131 33311
|Fax=?
|Öffnungszeiten=Mo und Sa geschlossen, Di - Fr 10:00-13:00, 14:00-18:00
|Bemerkung=
}}

===Oldenburg===
{{ElektronikLieferant
|Firmenname=ebc Utz Kohl GmbH
|Straße=Alexanderstraße 31
|Telefon=0441 82114
|Fax=0441 85801
|Weblink=www.e-b-c-elektronik.de
|Email=kontakt@e-b-c-elektronik.de
|PLZ=26121
|Ort=Oldenburg
|Öffnungszeiten=Mo. - Fr. 9:00 - 12:30 und 13:30 - 18:00 Uhr, Sa. 9:00 - 13:00 Uhr
|Bemerkung=
}}

===Osnabrück===
{{ElektronikLieferant
|Firmenname=Heinicke-electronic
|Straße=Meller Str. 43
|PLZ=49084
|Ort=Osnabrück
|Telefon=0541 587666
|Fax=0541 586614
|Öffnungszeiten=Mo-Fr. 9:30-13:00Uhr und 14:30-18:00Uhr Sa. 9:30-13:00Uhr
|Weblink=http://www.heinicke-electronic.de/
|Email=sales@heinicke-electronic.de
|Bemerkung=Haben auch einen PC Shop nebenan.
}}

===Wilhelmshaven===
{{ElektronikLieferant
|Firmenname=Reichelt Elektronik
|Straße=Elektronikring 1
|PLZ=26452
|Ort=Sande
|Telefon=04422-955 333
|Fax=04422-955 111
|Öffnungszeiten=Montag - Donnerstag: 9:00 - 17:00 Uhr; Freitag: 9:00 - 15:30 Uhr
|Weblink=http://www.reichelt.de
|Email=
|Bemerkung=
}}

==Nordrhein-Westfalen==
===Aachen===
Siehe http://aachen.wikia.com/wiki/Elektronik-Teile

===Bielefeld===
{{ElektronikLieferant
|Firmenname=alpha electronic Ing. A. Berger GmbH
|Straße=Oldentruper Str. 104
|PLZ=33604
|Ort=Bielefeld
|Telefon=0521-324333
|Fax=0521-320435
|Öffnungszeiten=Mo. – Sa. 9.00 – 13.00 Uhr Mo. – Fr. 14.00 – 18.00 Uhr
|Weblink=http://www.alphaelectronic-bielefeld.de/
|Email=info@alphaelectronic.de
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Fuchs und Lützow Elekronik - Handelsges. mbH
|Straße=Heeper Str. 184
|PLZ=33607
|Ort=Bielefeld
|Telefon=0521-5576555
|Fax=0521-5576557
|Öffnungszeiten=Mo. – Sa. 9.00 – 13.00 Uhr Mo. – Fr. 14.00 – 18.00 Uhr
|Weblink=http://www.electronicfuchs.com/
|Email=info@electronicfuchs.com
|Bemerkung=
}}

===Bonn===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Karlstraße 3
|PLZ=53115
|Ort=Bonn
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.filialen.conrad.de/rubriken/filialen.php?filiale=28
|Email=filiale.bonn@conrad.de
|Bemerkung=
}}
{{ElektronikLieferant
|Firmenname=P & M Elektronik Bonn GmbH
|Straße=Budapester Strasse 6
|PLZ=53111
|Ort=Bonn
|Telefon=0228-656005
|Fax=0228-656336
|Öffnungszeiten=Mo-Fr 09:00 – 19:00 Uhr Sa 10:00 – 16:00 Uhr
|Weblink=http://www.pm-elektronik-bonn.de/
|Email=pm-elektronikbonn@web.de
|Bemerkung=
}}

===Dortmund===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Westenhellweg 95-101
|PLZ=44137
|Ort=Dortmund
|Telefon=01805-564445
|Fax=
|Öffnungszeiten=Mo. – Fr. 10.00 – 20.00 Uhr Sa. 9.30 – 20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=direkt in der Innenstadt
}}

{{ElektronikLieferant
|Firmenname=SR-Tronic
|Straße=Beratgerstr. 28
|PLZ=44149
|Ort=Dortmund
|Telefon=0231-33671-0
|Fax=0231-33671-25
|Öffnungszeiten=Mo. – Fr. 10.00 – 18.00 Uhr
|Weblink=http://www.sr-tronic.de
|Email=info@sr-tronic.de
|Bemerkung=Ist zwar ein Versandhandel, Abholung ist aber möglich, extrem kleines Elektroniksortiment (Atmel, Eproms), ist eigentlich ein Satshop.
}}

{{ElektronikLieferant
|Firmenname=Electronic am Wall
|Straße=Hoher Wall 22
|PLZ=44137
|Ort=Dortmund
|Telefon=0231-16863
|Fax= 0231-160632 begin_of_the_skype_highlighting 0231-160632 end_of_the_skype_highlighting begin_of_the_skype_highlighting 0231-160632 end_of_the_skype_highlighting
|Öffnungszeiten=Mo. – Fr. 9.00 – 18.00 Uhr (?)
|Weblink=http://electronic-am-wall.de
|Email=electronic-am-wall@t-online.de
|Bemerkung=Alteingesessener Laden mit mittlerem Elektronik und Bauteilesortiment (Leider nicht mehr so viel wie früher).
}}

===Essen===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Altendorfer Str. 11
|PLZ=45127
|Ort=Essen
|Telefon=01805-564445
|Fax=
|Öffnungszeiten=Mo. – Fr. 10.00 – 19.30 Uhr Sa. 10.00 – 13.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=schräg gegenüber von IKEA, Tiefgarage im UG für Kunden kostenlos, Karte an der Kasse lochen lassen
}}

===Herne===
{{ElektronikLieferant
|Firmenname=Electronic Hanke
|Straße=Wilhelmstr. 38
|PLZ=44649
|Ort=Herne
|Telefon=02325-52728
|Fax=
|Öffnungszeiten=Mo. – Fr. 10.00 – 18.00 Uhr, außer Dienstags ab 15.00Uhr Mittagspause von 13.00 Uhr - 15.00 Uhr Sa. 9.30 – 13.00 Uhr
|Weblink=http://www.electronic-hanke.de/
|Email=electronic_hanke@t-online.de
|Bemerkung=
}}

===Köln===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Horbellerstr. 2-4
|PLZ=50858
|Ort=Köln
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 9.30-20.00 Uhr
|Weblink=http://filialen.conrad.de/rubriken/filialen.php?filiale=13
|Email=filiale.koeln@conrad.de
|Bemerkung= Hat ab dem 3.07. geschlossen!!!!
}}

{{ElektronikLieferant
|Firmenname=M. + M. van der Meyden GmbH
|Straße=Breite Straße 101
|PLZ=50667
|Ort=Köln
|Telefon=0221/2576369
|Fax=0221/2576369
|Öffnungszeiten=Mo.–Fr. von 9:30 – 19:00 Uhr Sa. von 10:00 – 16:30 Uhr
|Weblink=http://vandermeyden.de
|Email=http://vandermeyden.de/?page_id=13
|Bemerkung=
}}
 

===Bergisch Gladbach===
{{ElektronikLieferant
|Firmenname=MS-Elektronik
|Straße=Laurentiusstrasse 20
|PLZ=51465
|Ort=Bergisch Gladbach
|Telefon=02202 - 93 22 17
|Fax=02202 - 93 22 18
|Öffnungszeiten=Mo.-Fr.: 09:00-12:30 & 14:30 - 18:30 Uhr Sa: 09:00 - 14:00 Uhr
|Weblink=http://www.ms-elektronik.info/
|Email=info@ms-elektronik.info
|Bemerkung= Auch Versand
}}

===Langenfeld===
{{ElektronikLieferant
|Firmenname=rs elektronik - Reinhard Sinzel
|Straße=Solinger Strasse 152
|PLZ=40764
|Ort=Langenfeld
|Telefon=02173/22766
|Fax=02173/25958
|Öffnungszeiten=Mo-Fr 10:00-13:00 + 15:00-18:00, Sa 10:00-13:00
|Weblink=
|Email=
|Bemerkung=zwischen Polizeiwache und Bahnunterführung auf der linken Seite. Nur Ladenverkauf!
}}

===Mönchengladbach===
{{ElektronikLieferant
|Firmenname=Brunenberg Elektronik
|Straße=Lürriper Strasse 170
|PLZ=41065
|Ort=Mönchengladbach
|Telefon=02161-44421
|Fax=02161-42552
|Öffnungszeiten=Mo.- Fr. 9:00 - 13:00 und 14:00 - 18:00 Samstag 9:00 - 13:00 Donnerstag Nachmittag geschlossen!
|Weblink=http://www.bruntronic.de
|Email=info@bruntronic.de
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Zilles Elektronik GmbH
|Straße=Staufenstraße 8-10
|PLZ=41061
|Ort=Mönchengladbach
|Telefon=02161/176005
|Fax=02161/176007
|Öffnungszeiten=Montag - Freitag 8:30 - 13:00 & 14:00 - 18:00 Samstag 9:00 - 12:00
|Weblink=http://www.zilles-elektronik.de/
|Email=info@zilles-elektronik.de
|Bemerkung=
}}

===Paderborn===
{{ElektronikLieferant
|Firmenname=Jansen-Elektronik GmbH & Co. KG
|Straße=Heiersstrasse 24
|PLZ=33098
|Ort=Paderborn
|Telefon=05251-282848
|Fax=05251-282851
|Öffnungszeiten=Mo. – Sa. 9.30 – 13.00 Uhr Mo. – Fr. 14.30 – 18.00 Uhr
|Weblink=http://www.jansen-elektronik.de/
|Email=info@jansen-elektronik.de
|Bemerkung=
}}

===Recklinghausen===
{{ElektronikLieferant
|Firmenname=Elektronik-Center Wenzlik, Inh. H.- J. Juhnke
|Straße=Halterner Straße 24
|PLZ=45657
|Ort=Recklinghausen
|Telefon=02361-14103
|Fax=02361-182489
|Öffnungszeiten=Mo.-Fr.: 9.00h-18.30h, Sa.: 9.30h - 14.00h durchgehend geöffnet!
|Weblink=http://www.Wenzlik-RE.de
|Email=ecw-recklinghausen@t-online.de
|Bemerkung= Elektronik Einzelhandel 47.000 verschiedene Artikel vorrätig.
}}

==Rheinland-Pfalz==
===Andernach===
{{ElektronikLieferant
|Firmenname=EDV + Elektronic Systeme
|Straße=Füllscheuer 30
|PLZ=56626
|Ort=Andernach
|Telefon=02632/9293-0
|Fax=02632/9293-33
|Öffnungszeiten=Montag-Freitag 8:00 Uhr - 18:00 Uhr/Samstag geschlossen
|Weblink=http://www.eleksys.de/
|Email=info@eleksys.de
|Bemerkung=
}}

===Koblenz===
{{ElektronikLieferant
|Firmenname=Radio Erbar
|Straße=Bahnhofstr. 40
|PLZ=56068
|Ort=Koblenz
|Telefon=0261/34782
|Fax=0261/14570
|Öffnungszeiten=Montag-Freitag 9:00 Uhr - 18:00 Uhr/Samstag 9:00 Uhr - 12:00 Uhr
|Weblink=http://www.radio-erbar.de/
|Email=webmaster@radio-erbar.de
|Bemerkung=
}}
===Mainz===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Binger Str. 14-16 (nähe Hauptbahnhof)
|PLZ=55122
|Ort=Mainz
|Telefon=0180 5312111
|Fax=
|Öffnungszeiten=
|Weblink=http://www.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Elektronik Schmidt
|Straße=Boppstrasse 62 - 64
|PLZ=55118
|Ort=Mainz
|Telefon=0180 5312111
|Fax=
|Öffnungszeiten=Montag - Freitag 09.00 Uhr - 13.00 Uhr und 14.00 Uhr - 18.00 Uhr 
Samstag 09.00 Uhr - 13.00 Uhr
|Weblink=http://www.schmidt-electronic.de
|Email=
|Bemerkung=
}}

==Saarland==
=== Saarbrücken ===
{{ElektronikLieferant
|Firmenname=ESS Elektronik Service Skowronek
|Straße=Peter-Zimmer-Str. 13
|PLZ=66123
|Ort=Saarbrücken
|Telefon=+49 (681) 816414
|Fax= +49 (681) 816992
|Öffnungszeiten= Mo-Fr 8:00-12:00 Uhr / 14:00-18:00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Trierer Straße 16-20
|PLZ=66111
|Ort=Saarbrücken
|Telefon=0180 5 564445 (derzeit 14 Cent/Min. aus dem Festnetz der Dt. Telekom. Evtl. abweichende Preise für Anrufe aus den Mobilfunknetzen.)
|Fax=
|Öffnungszeiten= Mo.-Fr. 09.00-19.00 Uhr / Sa. 09.00-19.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

==Sachsen==
===Chemnitz===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Hartmannstr.45
|PLZ=09113
|Ort=Chemnitz
|Telefon=0371/365736
|Fax=0371/365736
|Öffnungszeiten=Mo.-Fr. 10.00 Uhr - 18.00 Uhr Sa. 10.00 Uhr - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com
|Email=
|Bemerkung=gut sortiert aber keine SMD BE
}}

{{ElektronikLieferant
|Firmenname=köhler-elektronik Firma Michael Köhler
|Straße=Erfenschlager Strasse 31
|PLZ=09125
|Ort=Chemnitz
|Telefon=(03 71) 51 91 03
|Fax=(03 71) 51 91 04
|Öffnungszeiten=Mo.-Fr. von 9 - 18 Uhr Sa. von 9 - 12 Uhr
|Weblink=http://www.koehler-elektronik.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=NEUMERKEL
|Straße=Straße der Nationen 26
|PLZ=09111
|Ort=Chemnitz
|Telefon=(03 71) 6 66 29 27
|Fax=(03 71) 6 66 29 51
|Öffnungszeiten=Mo.-Fr. von 9 - 13 und 14 - 18 Uhr
|Weblink=http://www.neumerkel.de
|Email=neumerkel.chemnitz@neumerkel.de
|Bemerkung=zwischen B. Uhse und ehemals McDonald’s :)
}}

===Dresden===
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Friedrich-List-Platz 2 gegenüber Hauptbahnhof
|PLZ=01069
|Ort=Dresden
|Telefon=
|Fax=
|Öffnungszeiten=Mo.-Fr. 09.30-20.00 Uhr, Sa. 09.00-20.00 Uhr
|Weblink=
|Email=
|Bemerkung= verhältnismäßig teuer
}}

{{ElektronikLieferant
|Firmenname=Sullus
|Straße=Tharandter Str. 67
|PLZ=01187
|Ort=Dresden
|Telefon=0351 4112100
|Fax=0351 4112146
|Öffnungszeiten=Mo.-Fr. 10.00-18.30 Uhr, Sa. 09.00-12.00 Uhr
|Weblink=http://www.sullus.de/
|Email=
|Bemerkung=
}}

===Leipzig===
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Neumarkt 20
|PLZ=04109
|Ort=Leipzig
|Telefon=
|Fax=
|Öffnungszeiten=Mo.-Sa.: 09.30-20.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=ELMICRO Computer GmbH & Co. KG
|Straße=Hohe Str. 9-13
|PLZ=04107
|Ort=Leipzig
|Telefon=+49-(0)341-9104810
|Fax=+49-(0)341-9104818
|Öffnungszeiten=Mo.-Sa.: 09.00-17.00 Uhr
|Weblink=http://elmicro.com/de/ela-leipzig.html
|Email=leipzig|at|elmicro.com
|Bemerkung=Besucher werden gebeten, sich kurzfristig telefonisch anzumelden.
}}

===Zwickau===
{{ElektronikLieferant
|Firmenname=Elektronik Neumerkel GmbH
|Straße=Kolpingstraße 20
|PLZ=08058
|Ort=Zwickau
|Telefon=+ 49 (0)375-589920
|Fax=+ 49 (0)375-5899222
|Öffnungszeiten=Mo. - Fr. 9:00 - 18:00 Uhr, Sa. 9:00 - 12:30 Uhr
|Weblink=http://www.neumerkel.de
|Email=info@neumerkel.de
|Bemerkung=Auch als Teuermerkel bekannt :)
}}

==Sachsen-Anhalt==
===Magdeburg===
{{ElektronikLieferant
|Firmenname=mittrenga electronic
|Straße=Maxim-Gorki-Str. 34
|PLZ=39108
|Ort=Magdeburg
|Telefon=0391/7333500
|Fax=0391/7346538
|Öffnungszeiten= 15.00- 18.00
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Nova Electronic
|Straße=Leipziger Str. 31
|PLZ=39112
|Ort=Magdeburg
|Telefon=0391/6272537
|Fax=?
|Öffnungszeiten=15.00- 1800
|Weblink=
|Email=
|Bemerkung=
}}

==Schleswig Holstein==
===Kiel===
{{ElektronikLieferant
|Firmenname=Elektronik Schmidt Inh. Karl Heinz Parting
|Straße=Adelheidstr. 28
|PLZ=24103
|Ort=Kiel
|Telefon=0431 94682
|Fax=0431 92574
|Öffnungszeiten=
|Weblink=
|Email=
|Bemerkung= viele historische Bauteile verfügbar, Röhren
}}

{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Mergenthalerstr. 22
|PLZ=24223
|Ort=Raisdorf
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Thüringen==
===Erfurt===
{{ElektronikLieferant
|Firmenname=Hübner-Elektronik e.K.
|Straße=Juri-Gagarin-Ring 27
|PLZ=99084
|Ort=Erfurt
|Telefon= +49 (0361) 6 42 34 56
|Fax= +49 (0361) 6 42 34 55
|Öffnungszeiten=Montag-Freitag - 9.30 bis 18.30 Uhr, Samstag - 10.00 bis 13.00 Uhr
|Weblink=http://www.huebner-elektronik.de/
|Email= info@huebner-elektronik.de
|Bemerkung=
}}

===Eisenach===
{{ElektronikLieferant
|Firmenname=Elektronik-Stübchen
|Straße=Katharinenstraße 117
|PLZ=99817
|Ort=Eisenach
|Telefon= (03691)77324
|Fax=
|Öffnungszeiten=Montag-Freitag - 9.00 bis 13.00 Uhr, 14.30 bis 18 Uhr
Sonnabend 9.00 bis 12.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

===Jena===
{{ElektronikLieferant
|Firmenname=Stefan Schmutzer VAT Elektronik
|Straße=Bachstraße 10
|PLZ=07743
|Ort=Jena
|Telefon= (03641)447184
|Fax=
|Öffnungszeiten= Mo-Fr. bis 18:00Uhr. Sa zu
|Weblink=
|Email=
|Bemerkung=
}}

=Österreich=
==Linz==
{{ElektronikLieferant
|Firmenname=Aigner Elektronik
|Straße=Dinghoferstr. 63
|PLZ=A-4020
|Ort=Linz
|Telefon=+43 732 669691-0
|Fax=+43 732 669691-15
|Öffnungszeiten=Mo. bis Fr. 8:30 bis 17:00 (keine Mittagssperre), Samstag 8:30 bis 12:00
|Weblink=http://www.aigner.co.at/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Kornstraße 4
|PLZ=A-4060
|Ort=Leonding
|Telefon=+43 732 683040-0
|Fax=+43 732 683040-13
|Öffnungszeiten=Mo. bis Fr. 9:00 bis 19:00 , Samstag 9:00 bis 17:00
|Weblink=http://www.conrad.at/
|Email=mailto://filiale.linz@conrad.at
|Bemerkung=
}}

==Graz==
{{ElektronikLieferant
|Firmenname=Neuhold Elektronik
|Straße=Griesplatz 1
|PLZ=A-8020
|Ort=Graz
|Telefon=+43 (0) 316 711245
|Fax=+43 (0) 316 717419
|Öffnungszeiten=Montag bis Freitag von 9.00 - 18.00 Uhr Samstag 9.00-12.30 Uhr
|Weblink=http://www.neuhold-elektronik.at/
|Email=
|Bemerkung=Großes Sortiment mit auch sehr ausgefallenen Artikeln. Führt eine breite Produktpalette. Durchweg sehr günstige Preise, jedoch manchmal bei Standardbauteilen (Mikrocontrollern z.B. AVRs) teurer als die Konkurrenz. Vergleichbar mit Pollin.
}}
 
 
{{ElektronikLieferant
|Firmenname=Riedl Electronic
|Straße=Brückenkopfgasse 2
|PLZ=A-8020
|Ort=Graz
|Telefon=Tel: +43 (0) 316 718031-0 od. +43 (0) 664 2104608
|Fax=+43 (0)316 718031-6
|Öffnungszeiten=Montag bis Freitag von 9.00 - 12.30 Uhr - Mittagspause und dann von 14.00 - 18.00 Uhr Samstag 9.00-12.00 Uhr
|Weblink=http://www.riedl-electronic.at/
|Email=office@riedl-electronic.at
|Bemerkung=Elektronikkomponenten müssen vorher über den Onlineshop bestellt werden. Diese werden dann von einem externen Lager geholt und können auf Wunsch in der Filiale in Graz abgeholt werden. Natürlich kann man sie auch direkt an die Haustür liefern lassen.
}}
 
 
{{ElektronikLieferant
|Firmenname=L-Tronik Austria
|Straße=Karlauerstrasse 5
|PLZ=A-8020
|Ort=Graz
|Telefon=Tel: +43 (0) 316 904 672
|Fax=
|Öffnungszeiten=Montag bis Freitag von 9.00 - 17.00 Uhr Samstag 9.00-12.00 Uhr
|Weblink=http://www.l-tronik.com/index.php
|Email=info@lta.at
|Bemerkung=Riesiges Sortiment an Halbleitern (Auch SMD). Solartechnik, Sicherheitstechnik, Haustechnik u.s.w..
}}
 
 
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Weblinger Gürtel 25
|PLZ=A-8054
|Ort=Graz
|Telefon=Tel: +43 (0) 50 - 20 40 73 00
|Fax=
|Öffnungszeiten=Montag bis Freitag von 9.00 - 19.30 Uhr Samstag 9.00 - 18.00 Uhr
|Weblink=http://www.conrad.at
|Email=filiale.graz@conrad.at
|Bemerkung=
}}

==Salzburg==
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Alpenstraße 95 - 97
|PLZ=5020
|Ort=Salzburg
|Telefon=050 - 20 40 81 00
|Fax=
|Öffnungszeiten=Mo.-Fr. 9.00-19.00 Uhr Sa. 9.00-18.00 Uhr
|Weblink=http://www.conrad.at/megastores
|Email=
|Bemerkung=
}}

==Wels==
{{ElektronikLieferant
|Firmenname=Andi Leitner - AL Elektronik
|Straße=Linzer Straße 57
|PLZ=4600
|Ort=Wels
|Telefon=07242/53624
|Fax=07242/53624-3
|Öffnungszeiten=Montag bis Freitag von 0800 bis 1800
|Weblink=http://www.al-elektronik.at
|Email=office@al-elektronik.at
|Bemerkung=Modellbau- und Elektronik-Laden. Andi nimmt sich für jeden Kunden die nötige Zeit. Nicht lagernde Ware nach Bestellung abholbar. Umfangreiche, kompetente Beratung. Nur wenig SMD-Bauteile, generell keine MSP430, sonst umfangreiche Auswahl. Website sehr unvollständig - besonders im Elektronikbereich.

Anfahrt: Von der Innenstadt kommend: Auf der Stelzhamerstraße westwärts bis zur Ampel vor der Gebietskrankenkasse. An der Ampel rechts, nach ungefähr 100m an der nächsten Kreuzung Links. Nach rund 250m erreichen Sie das Geschäft auf der Linken Straßenseite.

Von Osten kommend: Auf der Wiener Bundesstraße Richtung Zentrum, immer gerade aus (Osttangente queren). Weiter gerade aus westwärts (auf der Hans-Sachs-Straße). Auch beim Kreisverkehr beim Pensionistenheim gerade drüber (sprich: 2. Ausfahrt des Kreisverkehrs). Weiter gerade in Richtung Innenstadt, bis sie zur Ampel bei der Gebietskrankenkasse kommen. Hier Links abbiegen. Nach ungefähr 100m an der nächsten Kreuzung Links. Nach rund 250m erreichen Sie das Geschäft auf der Linken Straßenseite.
}}

==Wien==
{{ElektronikLieferant
|Firmenname=GM Electronic GmbH
|Straße=Brünner Straße 19
|PLZ=1210
|Ort=Wien
|Telefon=01/27 11 256
|Fax=
|Öffnungszeiten=Mo.-Fr. 9.00-13.00 14.00-18.00 Uhr Sa. 10.00-13.00 14.00-16.00 Uhr
|Weblink=http://www.gm-e.eu/index.php
|Email=
|Bemerkung=
}}

----

=Schweiz=
----
==Aargau (AG)==
===Baden===
{{ElektronikLieferant
|Firmenname=<s>Gautschi Elektronik (ehemals AUTRIX Meier)</s> ***)
|Straße=Martinsbergstrasse 28
|PLZ=5400
|Ort=Baden
|Telefon=056 222 24 24
|Fax=056 210 06 12
|Öffnungszeiten=
Montag 13:30-18:00, Di-Fr 08:00-12:00 und 13:00-18:00, Sa 09:00-12:00
|Weblink=
|Email=
|Bemerkung=Orchesterelektronik, REVOX und Elektronik-Laden.
Ehemals AUTRIX Meier. Nach bald 30 Jahren hat Ernst Meier den Laden 2006 in neue
Hände gegeben. Hier spürt man noch den Charme der 70er Jahre des letzten Jahrhunderts: ca. 20m2 Ladenlokal, vollgestopft bis unter die Decke mit mit elektronischem Kleinkram!
Teile des Sortiments entstammen ebenfalls dieser Zeitepoche. Mikroprozessoren und SMD-Bauteile sucht man hier vergebens. Dafür lassen sich auch mal (heute seltene) TTL's finden!
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
 '''***)''' seit Frühjahr 2009 Liegenschaft abgebrochen. Nachfolgefirma unbekannt. 
Schweizermacher [[Spezial:Beiträge/83.78.147.198|83.78.147.198]] 07:13, 7. Jan. 2010 (UTC)
}}

===Zofingen===
{{ElektronikLieferant
|Firmenname=Surplus Party Zofingen Funkerverein Zofingerrunde HB9FX
|Straße=Strengelbacherstrasse 27 (Mehrzweckhalle)
|PLZ=4800
|Ort=Zofingen
|Telefon=
|Fax=
|Öffnungszeiten= 
'''1x jährlich am letzen Samstag im Oktober:''' 31. Oktober 2009 / 30. Oktober 2010 / 29. Oktober 2011 / 27. Oktober 2012
 08:30 bis 16:30 Uhr
|Weblink=http://www.surplusparty.ch/surplus.htm
|Email=event(at)surplusparty.ch
|Bemerkung='''Die Surplus Party, seit 1984 der grösste Flohmarkt der Schweiz von Amateufunkern für Amateurfunker! Der Eintritt ist gratis.'''
Neue und gebrauchte Bauteile aus Elektronik, Funk- und Computertechnik, Surplus-Messgeräte, Funkgeräte und alles wonach man nie gesucht hat!

'''Anreise mit dem Auto:''' 
Aus den Richtungen Basel, Bern und Zürich die Autobahn A1 in Oftringen (Ausfahrt Nr. 48) verlassen und in Richtung Zofingen fahren. Vor dem Stadteingang beginnt die Beschilderung zu den Parkplätzen (nach rechts abbiegen, am Bahnhof vorbei, nach dem Busterminal rechts abbiegen und die Bahnlinie überqueren).

Aus der Richtung Luzern die Autobahn A2 in Reiden (Ausfahrt Nr. 18) verlassen und in Richtung Zofingen fahren. Vor dem Stadteingang beginnt die Beschilderung zu den Parkplätzen (nach links abbiegen).
Es stehen ausreichend Parkplätze zur Verfügung!

Die Parkplätze direkt bei der Halle sind gebührenpflichtig (Samstag bis 12:00 Uhr). Die Parkkarten für reservierte Plätze berechtigen nur zur Einfahrt direkt vor die Halle, aber Ersetzen nicht das notwendige Parkticket!

Total stehen für die Surplus Party '''rund 1'000 Parkplätze''' (davon etwa 750 gratis) zur Verfügung. Bitte befolgen Sie die Anweisungen des Parkdienstes.

'''Anreise mit dem Zug:''' 
Zofingen befindet sich an der SBB Linie 501 Olten - Luzern und ist Haltestelle für die meisten Schnellzüge.
In Zofingen angekommen, verlassen Sie und der Bahnlinie entlang in südlicher Richtung. Gehen Sie an den Busterminals vorbei, überqueren Sie die Bahnlinie nach rechts und von da an gehen Sie alles geradeaus bis zur Mehrzweckhalle (problemlos in 10 Minuten Fussmarsch erreichbar).
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

== Basel-Stadt (BS) ==
=== 4002 Basel ===
{{ElektronikLieferant
|Firmenname=<s>Grieder Elektronik Bauteile AG</s>
|Straße=<s>Nauenstrasse 63</s>
|PLZ=<s>4002</s>
|Ort=<s>Basel</s>
|Telefon=n/a
|Fax=n/a
|Öffnungszeiten='''Ladenlokal in Basel per Ende 2008 geschlossen.'''
|Weblink=http://shop.griederbauteile.ch/
|Email=n/a
|Bemerkung=Umzug nach 4450 Sissach ==> [[Lokale_Elektroniklieferanten#4450_Sissach]]
Fortführung als Versandunternehmen. 
z.Zt. liegen keine Informationen über die Möglichkeit der Abholung von vorbestellter Ware vor Ort vor.

 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:37, 13. Okt. 2009 (UTC)
}}

== Basel-Landschaft (BL) ==
=== 4450 Sissach ===
{{ElektronikLieferant
|Firmenname=Grieder Elektronik Bauteile AG
|Straße=Reuslistrasse 62
|PLZ=4450
|Ort=Sissach
|Telefon=061 976 95 95
|Fax=061 976 95 90
|Öffnungszeiten=Mo-Do 800-1200, 1300-1600 und Fr 800-1200, 1300-1500.
|Weblink=http://shop.griederbauteile.ch/
|Email=info@griederbauteile.ch
|Bemerkung=Mindestbestellwert CHF 20. Vorbestellte Waren können abgeholt werden. Der "Laden" befindet sich 10 Minuten zu Fuss vom Bahnhof Sissach.

}}

== Luzern (LU) ==
=== Emmenbrücke ===
{{ElektronikLieferant
|Firmenname=Conrad Electronic Schweiz
|Straße=Seetalstrasse 11
|PLZ=6020
|Ort=Emmenbrücke
|Telefon=0848/80 12 83
|Fax=041/267 32 14
|Öffnungszeiten= 
Mo/Di/Do 09:00-18:30, Mi/Fr 09:00-21:00, Sa 08:00-16:00 Uhr

|Weblink=http://www1.ch2.conrad.com/infocenter/filialen.php
|Email=filiale.emmenbruecke@conrad.ch

|Bemerkung=5 Minuten vom Bahnhof Emmenbrücke GRATIS Parkhaus & Parkplätze
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

== Solothurn (SO) ==
===5014 Gretzenbach===
{{ElektronikLieferant
|Firmenname=EFG Electronic AG
|Straße=Köllikerstrasse 32
|PLZ=5014
|Ort=Gretzenbach
|Telefon= 062 849 23 61
|Fax= 062 849 23 70
|Öffnungszeiten=
Mo-Fr 08:30-11:30, 13:30-18:30, Mi geschlossen, Sa 09:00-16:00
|Weblink=http://www.maxland.ch/netmax/standseiten/efg/index.html
|Email=efgag@yetnet.ch
|Bemerkung=Kabel - Messgeräte - Lautsprecher - elektronische Bauteile
kein Versand, nur Ladengeschäft
 [[Spezial:Beiträge/62.203.205.15|62.203.205.15]] 11:35, 8. Feb. 2010 (UTC) -- Edit: Schweizermacher
}}

== Zürich (ZH) ==
===8004 Zürich===
{{ElektronikLieferant
|Firmenname=Pusterla Elektronik AG
|Straße=Hohlstrasse 52
|PLZ=8004
|Ort= Zürich
|Telefon=044 241 56 77
|Fax=044 242 01 04
|Öffnungszeiten=
Mo-Fr 09:00-18:30, Sa 09:00-16:00
|Weblink=http://www.pusterla.ch/
|Email=info@pusterla.ch
|Bemerkung=Absoluter "Kult-Laden" mit Tradition. Wer jemals in der Schweiz einen Lötkolben in der Hand hatte, der kennt "Pusti"

Das Sortiment ist zweigeteilt: 
'''hinter dem Tresen:''' 
gutes allgemeines Bauteilesortiment, spezielle Sachen werden bestellt.
 Man nimmt sich Zeit für Fachberatung - es wird auch schon mal ein Vergleichstyp aus der Liste gesucht und dem jungen "Case-Modder" wird mit Engelsgeduld erklärt wie man den Vorwiderstand für seine coole LED-Prozessorinnenbeleuchtung berechnet.

'''vor dem Tresen - Selbstbedienung:''' 
Am Eingang nimmt man sich eine Pappschale mit Bleistift und Notizblock.
Artikel, Menge und Preise schreibt man selbst auf!

Das Sortiment bietet einen Querschnitt durch die elektronische Bauteilefertigung der letzten 50 Jahre. Sehr gute Quelle für spannungsfeste Kondensatoren und hochohmige (Leistungs-)Widerstände sowie mechanischem "Klein-Grabbel-Kram." Gute Auswahl an Gehäusen, Transformatoren (z.T. recht schräge Typen) sowie Relais und Stecker/Buchsen die die Welt wohl niemals gebraucht hat. '''Vorsicht bei Elektrolytkondensatoren:''' "historische" Lagerware, besser man hat ein ESR-Meter dabei - sodenn man hat!
 Kabel jeglicher Art gibt es ab der Rolle zum Selberabschneiden - auch 10cm sind kein Problem - ausrechnen und aufschreiben machst Du ja selber.
 Präsentation der Ware im Selbsbedienungsteil:
 Bauteile offen oder ab Gurt in kleinen, liebevoll angeschriebenen Pappschachteln (noch von Vater Pusterla), grösseren Wühlschachteln, einer Wühlecke sowie hier und da einige Merkwürdigkeiten auf dem Fussboden.
Man stelle sich das Ladenlokal eines Joint-Ventures aus Oppermann, Pollin, dem ehem. Völkner sowie dem örtlichen Entsorgungshof vor - '''das''' ist "Pusti" und so war er schon immer! 

'''Fazit:''' absolut lohnenswert, auch wenn man vielleicht nicht immer das bekommt was man wollte, dafür findet man aber alles, wonach man nie gesucht hatte!
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
 [[Spezial:Beiträge/62.203.205.15|62.203.205.15]] 11:45, 8. Feb. 2010 (UTC) -- Edit: Tippfehler (Schweizermacher)
}}

===8025 Zürich===
{{ElektronikLieferant
|Firmenname=in Memoriam: (1967 - 1996)
''Alfred Mattern AG''
|Straße=''Seilergraben 53''
|PLZ=''8025''
|Ort= ''Zürich''
|Telefon= n/a
|Fax= n/a
|Öffnungszeiten=n/a
|Weblink=http://www.moneyhouse.ch/u/pub/alfred_mattern_ag_CH-020.3.916.364-3.htm
|Email=
|Bemerkung=Firmengründung 1967, Konkurs 1996

'''SHAB: 235 / 1996 vom 03.12.1996 (Seite 7457)''' 
27. November 1996 (25729) 
Alfred Mattern AG, in Z ü r i c h, Handel mit Antennen und Antennenzubehör sowie mit Geräten und Bauteilen der Elektro-, Elektronik-, Radio-und Fernsehindustrie, Aktiengesellschaft (SHAB Nr. 210 vom 30. 10. 1995, S. 5945).
Firma neu: Alfred Mattern AG in Liquidation. Mit Verfügung vom 02.10.1996 hat der Konkursrichter des Bezirksgerichts Zürich über die Gesellschaft den Konkurs eröffnet; demnach ist die Gesellschaft aufgelöst. Das Konkursverfahren ist mit Verfügung desselben Richters vom 13.11.1996 mangels Aktiven eingestellt worden.
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

===8092 Zürich===
{{ElektronikLieferant
|Firmenname="Bastli" Fachverein der Departemente Informationstechnologie und Elektrotechnik und Maschinenbau und Verfahrenstechnik an der ETH Zürich.
|Straße=Universitätsstrasse 19
|PLZ=8092
|Ort= Zürich
|Telefon= n/a
|Fax= n/a
|Öffnungszeiten=Die Öffnungszeiten gelten nur während des Semesters.
Mo 12:15 - 13:00 Uhr 
Do 12:15 - 13:00 Uhr 

|Weblink=http://www.bastli.ethz.ch/
|Email=bastli@amiv.ethz.ch
|Bemerkung=Studentischer "Bastel-Shop"
Während den Öffnungszeiten ist der Bastli-Shop im ersten Stock des UNG geöffnet.
Ihr könnt Bauteile, welche wir an Lager haben, kaufen und euch wird mit diversen elektronischen Problemen geholfen.

Organisierte Sammelbestellungen bei Fa. Reichelt / Deutschland

'''Standort:''' 

Bastli und Messplatz befinden sich in den Räumlichkeiten des AMIV im UNG Gebäude schräg gegenüber des CAB.
Es ist das gleiche Gebäude in dem auch der ehem. AMIV-Verlag respektive ehem. WBS respektive SPOD untergebracht ist.

Das Gebäude wirkt beim ersten Kontakt wohl für jeden neuen ein bisschen abschreckend. Aber keine Scheu, wenn man durch das etwas schlecht beleuchtete Treppenhaus in den ersten Stock gelangt, wendet man sich dort gleich nach rechts. Bastli und Messplatz haben die Zimmernummern C6 und C5.
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

=== 8305 Dietlikon ===
{{ElektronikLieferant
|Firmenname=Conrad Electronic Schweiz
|Straße=Alte Dübendorferstrasse 17
|PLZ=8305
|Ort=Dietlikon
|Telefon=0848/80 12 84
|Fax=044/805 35 14
|Öffnungszeiten= 
Mo-Do 10:00-20:00, Fr 10:00-21:00, Sa 09:00-20:00 Uhr

|Weblink=http://www1.ch2.conrad.com/infocenter/filialen.php
|Email=filiale.dietlikon@conrad.ch

|Bemerkung=5 Minuten vom Bahnhof Dietlikon Parkhaus & Parkplätze vorhanden
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

=== 8606 Nänikon ===
{{ElektronikLieferant
|Firmenname=Distrelec Schweiz
|Straße=Grabenstrasse 6
|PLZ=8606
|Ort=Nänikon
|Telefon=044 - 944 99 11
|Fax=044 - 944 99 88
|Öffnungszeiten= 
Mo-Fr 07:30-18:00 Uhr (nur Abholschalter)

|Weblink=https://www.distrelec.ch
|Email=info@distrelec.com
|Bemerkung='''Abholschalter:''' (Vorbestellung unbedingt erforderlich)
Telefonisch oder online bestellte Ware kann nach ca. 2 Stunden abgeholt werden.
 Es kann auch direkt vor Ort ab Katalog bestellt werden, allerdings dann Wartezeit von min. 2 Stunden
 Bezahlung: bar/EC- und Post-Card
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

= Siehe auch =
* [[Platinenhersteller]]
* [[Elektronikversender]]
* [[Eisenwarenversender]]

Lokale Elektroniklieferanten

2010-07-19T12:44:42Z

Hugstuart: /* Nordrhein-Westfalen */

=Einleitung=
Da nicht jeder beim Fehlen einzelner Bauteile eine Online-Bestellung aufgeben möchte und der eine oder andere regionale Anbieter nicht so gut zu finden ist, soll hier eine Liste entstehen, die hilft Anbieter zu finden.

__TOC__

Falls die Darstellungsart nicht gefällt oder Rubriken fehlen, so bitte nicht hier ändern, sondern das Template anpassen: [[Vorlage:ElektronikLieferant]] 
So soll das Template ausgefüllt werden:
{{ElektronikLieferant
|Firmenname=hier Firmenname eintragen
|Straße=Straßenname, z. B. Musterstraße 123
|PLZ=PLZ, z. B. 12345
|Ort=Ort, z. B. München
|Telefon=Telnr., z. B. 012345/12341234
|Fax=Faxnr., z. B. 012345/12345234
|Öffnungszeiten=Öffnungszeiten eintragen Neue Zeile mit "br" abgetrennt
|Weblink=http://www.mikrocontroller.net Link ohne umschliessende eckige Klammern
|Email=Emailadresse, z. B. xxx@yyy.de
|Bemerkung=ggf. Bemerkung, ansonsten Rubrik/Feld/Variable leer lassen
}}

=Deutschland=
==Baden-Württemberg==
===Aalen===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Wilhelm-Zapf-Str. 9
|PLZ=73430
|Ort=Aalen
|Telefon=07361/610820
|Fax=07361/610821
|Öffnungszeiten=Mo.-Fr. 9.00 - 13.00 Uhr, 14.00 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com
|Email=info@muekra.de
|Bemerkung=Keine SMD-Teile
}}
===Esslingen===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Bahnhofstr. 23
|PLZ=73728
|Ort=Esslingen
|Telefon=0711/355676
|Fax=0711/3108656
|Öffnungszeiten=Mo.-Fr. 9.00 - 13.00 Uhr, 14.30 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com/FilES.php
|Email=info@muekra.de
|Bemerkung=Keine Mikrocontroller, keine SMD-Teile (ausser einige wenige Transistoren)
}}
===Freiburg===
{{ElektronikLieferant
|Firmenname=Omega electronic GmbH
|Straße=Eschholzstr. 58-60
|PLZ=79115
|Ort=Freiburg
|Telefon=0761/76776-0
|Fax=0761/76776-55
|Öffnungszeiten=Mo.-Sa.: 10:00 - 19:30
|Weblink=http://www.omega-electronic.de
|Email=info@omega-electronic.de
|Bemerkung=
}}
===Karlsbad===
{{ElektronikLieferant
|Firmenname=IT-WNS, Ute Heldt
|Straße=Schulstr. 13
|PLZ=76307
|Ort=Karlsbad - Mutschelbach
|Telefon=07202/936083
|Fax=07202/936085
|Öffnungszeiten=Nach Vereinbahrung (Email-Kontakt)
|Weblink=http://www.it-wns.de
|Email=info@it-wns.de
|Bemerkung=Bestellungen im Onlineshop können wahlweise auch direkt abgeholt werden
}}

===Karlsruhe===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Fritz-Erler-Straße 24
|PLZ=76133
|Ort=Karlsruhe
|Telefon=0721/374270
|Fax=0721/9379171
|Öffnungszeiten=Mo.-Fr. 9.00 - 13.00 Uhr, 14.30 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://www.muekra.com/Filiale_Karlsruhe
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Mc TEC Elektronik Vertriebs GmbH
|Straße=Kaiserstrasse 160
|PLZ=76133
|Ort=Karlsruhe
|Telefon=0721/24456
|Fax=0721/20061
|Öffnungszeiten=Mo.-Fr. 10.00 - 19.00 Uhr Sa. 10.00 - 15.00 Uhr
|Weblink=http://www.mctec.de/
|Email=
|Bemerkung=Vorübergehend geschlossen, Website down???
}}

===Offenburg===
{{ElektronikLieferant
|Firmenname=Günther Wultschner (Elektronikladen)
|Straße=Luisenstraße 16
|PLZ=77654
|Ort=Offenburg
|Telefon=0781 43270‎
|Fax=
|Öffnungszeiten=Mo.-Fr. 9.00 - 19:00 Uhr Sa. 9.00 - 16.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

===Reutlingen===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Federnseestr. 4
|PLZ=72764
|Ort=Reutlingen
|Telefon=07121/370748
|Fax=07121/370741
|Öffnungszeiten=Mo.-Fr. 9.30 - 13.00 Uhr, 14.00 - 18.00 Uhr Sa. 9.30 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com
|Email=info@muekra.de
|Bemerkung=Keine SMD-Teile
}}

===Ulm===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Neutorstr. 20
|PLZ=89073
|Ort=Ulm
|Telefon=0731/64494
|Fax=0731/6028676
|Öffnungszeiten=Mo.-Fr. 9.00 - 18.00 Uhr Sa. 9.00 - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com/FilUlm.php
|Email=
|Bemerkung=Keine SMD-Teile
}}

===Villingen-Schwenningen===
{{ElektronikLieferant
|Firmenname=Buchmann Elektronik
|Straße=Wasenstrasse 51
|PLZ=78054
|Ort=Villingen-Schwenningen
|Telefon=07720/1308
|Fax=07720/1360
|Öffnungszeiten=Mo-Fr., ausser Mittwoch; Zeiten leider unbekannt
|Weblink=keine Webseite
|Email=buchmann-elektronik@t-online.de
|Bemerkung=keine SMD.
}}

{{ElektronikLieferant
|Firmenname=SchiBe Elektronik
|Straße=Mühlenstr. 9
|PLZ=78050
|Ort=Villingen-Schwenningen
|Telefon=07721/8879880
|Fax=07721/88798820
|Öffnungszeiten=Mo-Fr.; Zeiten leider unbekannt
|Weblink=http://www.schibe.de
|Email=info@SchiBe.de
|Bemerkung=Bestellt auf Anfrage ohne Versandkosten bei Conrad mit Selbstabholung dort.
}}

==Bayern==
===Aschaffenburg===
{{ElektronikLieferant
|Firmenname=VS Elektronik OHG
|Straße= Magnolienweg 3
|PLZ= 63739
|Ort=Aschaffenburg
|Telefon=06021-30460
|Fax=06021-304626
|Öffnungszeiten= Montag - Freitag: 09:00 - 18:00 Uhr Samstag: 09:00 - 13:00 Uhr
|Weblink=http://www.vs-electronic.de
|Email=info@vs-electronic.de
|Bemerkung= führt Vellemann Bausätze, PCs, Telekommunikation und Bauteile
}}

===Erlangen===
{{ElektronikLieferant
|Firmenname=Radio-Fernseh-Elektronik
|Straße=Beethovenstraße 2
|PLZ=91052
|Ort=Erlangen‎
|Telefon=09131 25288‎
|Fax=
|Öffnungszeiten=
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Feller-electronic
|Straße=Marquardsenstraße 21
|PLZ=91054
|Ort=Erlangen‎
|Telefon=09131 27595
|Fax=
|Öffnungszeiten=Mo-Fr 9.00 - 13.00, 14.00-18.00 Uhr. Sa 9.00 - 14.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

===Fürth===
{{ElektronikLieferant
|Firmenname=B+D Electronic GmbH
|Straße=Königstr. 107 (gegenüber Citycenter und neben Feuerwehr)
|PLZ=90762
|Ort=Fürth
|Telefon=0911 - 77 30 40
|Fax=
|Öffnungszeiten=Mo - Fr: 10.00 - 12.30 & 14.00 - 18.00 Sa: 10.00 - 13.00
|Weblink=http://www.bdelectronic.de/
|Email=
|Bemerkung=
}}

=== Kaufbeuren ===
{{ElektronikLieferant
|Firmenname=Jantsch-Elektronik GmbH
|Straße=Porschestrasse 26
|PLZ=87600
|Ort=Kaufbeuren
|Telefon=0 83 41 / 95 33-0
|Fax=0 83 41 / 37 00
|Öffnungszeiten=Mo-Fr 9:00-12:30 / 13:30-18:00 
Sa 9:00-13:00 Uhr
|Weblink= http://www.j-e.de
|Email=info@j-e.de
|Bemerkung=führt auch gebrauchte Messgeräte
}}

===Leiblfing (bei Straubing)===
{{ElektronikLieferant
|Firmenname=Hans Entner Funkelektronik
|Straße=Landshuter Straße 1
|PLZ=94339
|Ort=Leiblfing
|Telefon=(0 94 27) 90 20 86
|Fax=09427 - 902087
|Öffnungszeiten= leider nicht bekannt
|Weblink=
|Email=Entner-DF9RJ@t-online.de
|Bemerkung= Kleiner Laden und sehr netter Inhaber. Einige Geräte und Zubehör. Viele HF-Stecker (v.a. SMA, BNC, N und PL(UHF)) und Koax-Kabel. Bietet auch Reparaturen an.
}}

===München===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Tal 29
|PLZ=80331
|Ort=München
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Fr: 9:00 - 20:00 Sa: 9:00 - 20:00
|Weblink=http://www.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Hanauer Straße 91 (gegenüber OEZ)
|PLZ=80993
|Ort=München - Moosach
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Fr: 9:30 - 20:00 Sa: 9:00 - 20:00
|Weblink=http://www.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Bürklin
|Straße=Schillerstr. 41
|PLZ=80336
|Ort=München
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Do: 9:00 - 16:30 Fr: 9:00 - 13:00
|Weblink=http://buerklin.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Strixner & Holzinger
|Straße=Schillerstraße 25-29
|PLZ=80336
|Ort=München
|Telefon=
|Fax=
|Öffnungszeiten=Mo - Fr: 9:30 - 18:00
|Weblink=http://sh-halbleiter.de/
|Email=
|Bemerkung=
}}

===Schweinfurt===
{{ElektronikLieferant
|Firmenname=Spath Elektronische Bauteile
|Straße=Cramerstr. 9
|PLZ=97421
|Ort=Schweinfurt
|Telefon=09721/25186
|Fax=09721/22999
|Öffnungszeiten=
|Weblink=
|Email=
|Bemerkung=
}}

===Straubing===
{{ElektronikLieferant
|Firmenname=Röhrner Electronic
|Straße=Innere Passauer Str. 12
|PLZ=94315
|Ort=Straubing
|Telefon=09421/12573
|Fax=09421/22207
|Öffnungszeiten=Mo - Do: 9:00 - 18:00 Sa: 10:00 - 13:00
|Weblink=http://www.roehrner-electronic.de/
|Email=
|Bemerkung=Netter Elektronikladen mit vielen Halbleitern neben dem üppigen Standardsortiment
}}

===Pförring===
{{ElektronikLieferant
|Firmenname=Pollin
|Straße=Max-Pollin-Straße 1
|PLZ=85104
|Ort=Pförring
|Telefon=
|Fax=
|Öffnungszeiten=Mo.-Fr. 9 - 19 Uhr Sa. 9 - 16 Uhr
|Weblink=http://www.pollin.de/shop/static/ecenter.htm
|Email=
|Bemerkung=nähe Ingolstadt
}}

==Berlin==
===Charlottenburg-Wilmersdorf===
{{ElektronikLieferant
|Firmenname=Segor-electronics
|Straße=Kaiserin-Augusta-Alle 94
|PLZ=10589
|Ort=Berlin
|Telefon=030 4399843
|Fax=030 4399855
|Öffnungszeiten=Mo.-Fr. 10.00-13.30 Uhr und 14:30-18:00 Uhr, Sa. 10.00-13.00 Uhr
|Weblink=http://www.segor.de
|Email=sales@segor.de
|Bemerkung=Sehr gut sortiertes und vielseitiges Sortiment, preiswert, hochwertig.
}}
===Berlin Schöneberg===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Kleiststraße 30-31
|PLZ=10787
|Ort=Berlin
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Atzert Radio
|Straße=Kleiststraße 32-33
|PLZ=10787
|Ort=Berlin
|Telefon=030/212984-0
|Fax=030/212984-11
|Öffnungszeiten=Montag-Samstag 10:00-19.00 Uhr
|Weblink=http://www.atzert-radio.de/
|Email=
|Bemerkung=
}}

===Berlin Kreuzberg===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Hasenheide 14-15
|PLZ=10967
|Ort=Berlin
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Fr. 10.00-20.00 Uhr, Sa. 10.00-18.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

===Berlin Steglitz===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Schloßstrasse 34-36
|PLZ=12163
|Ort=Berlin
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Do. 10.00-20.00 Uhr, Fr.-Sa. 10.00-22.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Brandenburg==
===Frankfurt (Oder)===

{{ElektronikLieferant
|Firmenname=Elektronik Service Landrock
|Straße=Karl-Ritter-Platz 8-9
|PLZ=15230
|Ort=Frankfurt (Oder)
|Telefon=0335 / 6802029
|Fax=0335 / 684171
|Öffnungszeiten=Mo-Fr. 10-18 Uhr
|Weblink=http://www.landrock-elektronik.de/
|Email=
|Bemerkung=Jürgen (Chef) ist superfreundlich, habe jahrelang dort eingekauft.
}}

==Bremen==
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Borgwardstr. 2
|PLZ=28279
|Ort=Bremen
|Telefon=01 80 / 55 64 44 5
|Fax=
|Öffnungszeiten=
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Schuricht Distrelec GmbH
|Straße=Rehland 8
|PLZ=28832
|Ort=Achim
|Telefon= 04 20 2 / 97 47-97
|Fax=
|Öffnungszeiten=
|Weblink=https://www.distrelec.de
|Email=
|Bemerkung= Nur telefonische Bestellung. Wenn man bei der Bestellung explizit sagt dass man die Sachen in Achim abholen möchte, dann klappt dies auch... meistens...
}}

==Hamburg==
===Harburg===
{{ElektronikLieferant
|Firmenname=Electronic 70
|Straße=Küchgarten 21
|PLZ=21073
|Ort=Hamburg
|Telefon=040 / 77 81 08
|Fax=
|Öffnungszeiten=Mo. - Fr. 9.30 - 13.00 Uhr 14.00 - 18.00 Uhr 
Samstag 10.00 - 14.00 Uhr
|Weblink=http://electronic70.de
|Email=
|Bemerkung= Nett und kompetent.
}}

===Sankt Pauli (Schanzenviertel)===
{{ElektronikLieferant
|Firmenname=Radio Kölsch
|Straße=Schanzenstr. 1
|PLZ=20357
|Ort=Hamburg
|Telefon=040 / 43 46 56
|Fax=040 / 439 09 25
|Öffnungszeiten=
|Weblink=http://www.koelsch24.com
|Email=
|Bemerkung=
}}

===Hoheluft Ost===
{{ElektronikLieferant
|Firmenname=Statronic
|Straße=Eppendorfer Weg 244
|PLZ=20251
|Ort=Hamburg
|Telefon=040 / 422 33 22
|Fax=040 / 422 33 25
|Öffnungszeiten=
|Weblink=http://www.statronic.de
|Email=
|Bemerkung=
}}

===Wandsbek===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Wandsbeker Zollstr. 67-69
|PLZ=22041
|Ort=Hamburg
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Fr. 09.30-20.00 Uhr, Sa. 09.00-18.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

===Altona===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Hahnenkamp 1
|PLZ=22765
|Ort=Hamburg
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Hessen==
===Darmstadt===
{{ElektronikLieferant
|Firmenname=Zimmermann Electronic GmbH
|Straße=Kasinostr. 2
|PLZ=64293
|Ort=Darmstadt
|Telefon=06151 - 66 69 - 240
|Fax=06151 - 66 69 - 290
|Öffnungszeiten=Mo.- Fr. 9:00 - 19:00 Uhr Sa. 9:00 - 14:00 Uhr
|Weblink=http://www.zeg-shop.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=EBG Electronic Business GmbH
|Straße=Bismarckstr. 61
|PLZ=64293
|Ort=Darmstadt
|Telefon=06151 / 82 91 - 0
|Fax=06151 / 82 91 - 20
|Öffnungszeiten=Montag-Freitag: 9:00 bis 19:00 Uhr Samstag: 9:00 bis 14:00 Uhr
|Weblink=http://www.ebg-darmstadt.de
|Email=info@ebg-darmstadt.de
|Bemerkung=
}}

===Offenbach===
{{ElektronikLieferant
|Firmenname=Rail Electronic
|Straße=Großer Biergrund 4
|PLZ=63065
|Ort=Offenbach
|Telefon=069 / 88 20 72
|Fax=069 / 88 31 14
|Öffnungszeiten=Mo.- Fr. 09.30 bis 12.30 sowie 13.30 bis 18.30 Uhr Sa. 9.30 bis 13.30 Uhr
|Weblink=http://www.rail-electronic.de
|Email=
|Bemerkung=
}}

===Wöllstadt===
{{ElektronikLieferant
|Firmenname=ELW Elektronik Handels GMBH
|Straße=Am Kalkofen 10
|PLZ=61206
|Ort=Wöllstadt
|Telefon=06034-4411
|Fax=06034-5739
|Öffnungszeiten=Mo-Fr 08.30 - 18.00 Uhr Sa 08.30 - 13.00 Uhr
|Weblink=http://www.elw-elektronik.com/
|Email=elw-gmbh@t-online.de
|Bemerkung=
}}

===Frankfurt/Main===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Zeil 58 + 64 (Konstabler Wache)
|PLZ=60313
|Ort=Frankfurt
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Mi. 10.00-20.00 Uhr Do.-Sa. 10.00-21.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Mecklenburg-Vorpommern==
===Rostock===
{{ElektronikLieferant
|Firmenname=A-Z City-Stores
|Straße=Doberaner-Hof
|PLZ=
|Ort=Rostock
|Telefon=0381-4031171
|Fax=
|Öffnungszeiten=Mo. – Fr. 9.30 – 19.30 Uhr Sa. 9.30 – 16.00 Uhr
|Weblink=
|Email=
|Bemerkung=geringes Angebot recht teuer
}}

==Niedersachsen==
===Braunschweig===
{{ElektronikLieferant
|Firmenname=Conrad Electronic GmbH
|Straße=Sudetenstr. 4
|PLZ=38114
|Ort=Braunschweig
|Telefon= 0531 501514
|Fax=
|Öffnungszeiten=Mo.-Fr. 09.30-19.00 Uhr, Sa. 09.00-18.00 Uhr
|Weblink=http://www.filialen.conrad.de/
|Email=
|Bemerkung= Hinter dem Conrad-Gebäude gibt es noch eine "Resterampe" mit Garantiefällen, unvollständigen Bausätzen etc. (andere Öffnungszeiten!)
}}

{{ElektronikLieferant
|Firmenname=EFB - Electronic Fundgrube Braunschweig
|Straße=Kreuzstrasse 65
|PLZ=38118
|Ort=Braunschweig
|Telefon=0531-58 11 058
|Fax=0531-58 11 059
|Öffnungszeiten=
|Weblink=http://www.efb-online.de/
|Bemerkung= Online-Katalog unter http://www.megakick-stores.de/.
}}

{{ElektronikLieferant
|Firmenname=Elektronik Bauteile Vertrieb - Dipl.-Ing. Jörg Bassenberg
|Straße=Nußbergstraße 9
|PLZ=38102
|Ort=Braunschweig
|Telefon=0531-79 17 07
|Fax=0531-7 60 22
|Öffnungszeiten=
|Weblink=http://www.bassenberg.de/
|Email=info@bassenberg.de
|Bemerkung= Kleines Ladengeschäft, hauptsächlich ältere Bauteile vorrätig.
}}

===Hannover===
{{ElektronikLieferant
|Firmenname=Conrad Electronic GmbH
|Straße=Goseriede 3
|PLZ=30159
|Ort=Hannover
|Telefon= 0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 09.00-20.00 Uhr
|Weblink=http://www.filialen.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Radio Menzel-Electronic
|Straße=Limmerstraße 3-5
|PLZ=30451
|Ort=Hannover
|Telefon= 0511 442607
|Fax=
|Öffnungszeiten=Mo-Fr: 10:00-13:30, 14:30-18:00 Sa: 10:00-13:30
|Weblink=www.menzel-electronic.de
|Email=
|Bemerkung=
}}

===Lüneburg===
{{ElektronikLieferant
|Firmenname=Beusch Elektronik
|Straße=Reichenbachstr. 8
|PLZ=21335
|Ort=Lüneburg
|Telefon=04131 33311
|Fax=?
|Öffnungszeiten=Mo und Sa geschlossen, Di - Fr 10:00-13:00, 14:00-18:00
|Bemerkung=
}}

===Oldenburg===
{{ElektronikLieferant
|Firmenname=ebc Utz Kohl GmbH
|Straße=Alexanderstraße 31
|Telefon=0441 82114
|Fax=0441 85801
|Weblink=www.e-b-c-elektronik.de
|Email=kontakt@e-b-c-elektronik.de
|PLZ=26121
|Ort=Oldenburg
|Öffnungszeiten=Mo. - Fr. 9:00 - 12:30 und 13:30 - 18:00 Uhr, Sa. 9:00 - 13:00 Uhr
|Bemerkung=
}}

===Osnabrück===
{{ElektronikLieferant
|Firmenname=Heinicke-electronic
|Straße=Meller Str. 43
|PLZ=49084
|Ort=Osnabrück
|Telefon=0541 587666
|Fax=0541 586614
|Öffnungszeiten=Mo-Fr. 9:30-13:00Uhr und 14:30-18:00Uhr Sa. 9:30-13:00Uhr
|Weblink=http://www.heinicke-electronic.de/
|Email=sales@heinicke-electronic.de
|Bemerkung=Haben auch einen PC Shop nebenan.
}}

===Wilhelmshaven===
{{ElektronikLieferant
|Firmenname=Reichelt Elektronik
|Straße=Elektronikring 1
|PLZ=26452
|Ort=Sande
|Telefon=04422-955 333
|Fax=04422-955 111
|Öffnungszeiten=Montag - Donnerstag: 9:00 - 17:00 Uhr; Freitag: 9:00 - 15:30 Uhr
|Weblink=http://www.reichelt.de
|Email=
|Bemerkung=
}}

==Nordrhein-Westfalen==
===Aachen===
Siehe http://aachen.wikia.com/wiki/Elektronik-Teile

===Bielefeld===
{{ElektronikLieferant
|Firmenname=alpha electronic Ing. A. Berger GmbH
|Straße=Oldentruper Str. 104
|PLZ=33604
|Ort=Bielefeld
|Telefon=0521-324333
|Fax=0521-320435
|Öffnungszeiten=Mo. – Sa. 9.00 – 13.00 Uhr Mo. – Fr. 14.00 – 18.00 Uhr
|Weblink=http://www.alphaelectronic-bielefeld.de/
|Email=info@alphaelectronic.de
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Fuchs und Lützow Elekronik - Handelsges. mbH
|Straße=Heeper Str. 184
|PLZ=33607
|Ort=Bielefeld
|Telefon=0521-5576555
|Fax=0521-5576557
|Öffnungszeiten=Mo. – Sa. 9.00 – 13.00 Uhr Mo. – Fr. 14.00 – 18.00 Uhr
|Weblink=http://www.electronicfuchs.com/
|Email=info@electronicfuchs.com
|Bemerkung=
}}

===Bonn===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Karlstraße 3
|PLZ=53115
|Ort=Bonn
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.filialen.conrad.de/rubriken/filialen.php?filiale=28
|Email=filiale.bonn@conrad.de
|Bemerkung=
}}
{{ElektronikLieferant
|Firmenname=P & M Elektronik Bonn GmbH
|Straße=Budapester Strasse 6
|PLZ=53111
|Ort=Bonn
|Telefon=0228-656005
|Fax=0228-656336
|Öffnungszeiten=Mo-Fr 09:00 – 19:00 Uhr Sa 10:00 – 16:00 Uhr
|Weblink=http://www.pm-elektronik-bonn.de/
|Email=pm-elektronikbonn@web.de
|Bemerkung=
}}

===Dortmund===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Westenhellweg 95-101
|PLZ=44137
|Ort=Dortmund
|Telefon=01805-564445
|Fax=
|Öffnungszeiten=Mo. – Fr. 10.00 – 20.00 Uhr Sa. 9.30 – 20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=direkt in der Innenstadt
}}

{{ElektronikLieferant
|Firmenname=SR-Tronic
|Straße=Beratgerstr. 28
|PLZ=44149
|Ort=Dortmund
|Telefon=0231-33671-0
|Fax=0231-33671-25
|Öffnungszeiten=Mo. – Fr. 10.00 – 18.00 Uhr
|Weblink=http://www.sr-tronic.de
|Email=info@sr-tronic.de
|Bemerkung=Ist zwar ein Versandhandel, Abholung ist aber möglich, extrem kleines Elektroniksortiment (Atmel, Eproms), ist eigentlich ein Satshop.
}}

{{ElektronikLieferant
|Firmenname=Electronic am Wall
|Straße=Hoher Wall 22
|PLZ=44137
|Ort=Dortmund
|Telefon=0231-16863
|Fax= 0231-160632 begin_of_the_skype_highlighting 0231-160632 end_of_the_skype_highlighting begin_of_the_skype_highlighting 0231-160632 end_of_the_skype_highlighting
|Öffnungszeiten=Mo. – Fr. 9.00 – 18.00 Uhr (?)
|Weblink=http://electronic-am-wall.de
|Email=electronic-am-wall@t-online.de
|Bemerkung=Alteingesessener Laden mit mittlerem Elektronik und Bauteilesortiment (Leider nicht mehr so viel wie früher).
}}

===Essen===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Altendorfer Str. 11
|PLZ=45127
|Ort=Essen
|Telefon=01805-564445
|Fax=
|Öffnungszeiten=Mo. – Fr. 10.00 – 19.30 Uhr Sa. 10.00 – 13.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=schräg gegenüber von IKEA, Tiefgarage im UG für Kunden kostenlos, Karte an der Kasse lochen lassen
}}

===Herne===
{{ElektronikLieferant
|Firmenname=Electronic Hanke
|Straße=Wilhelmstr. 38
|PLZ=44649
|Ort=Herne
|Telefon=02325-52728
|Fax=
|Öffnungszeiten=Mo. – Fr. 10.00 – 18.00 Uhr Sa. 9.30 – 18.00 Uhr
|Weblink=http://www.electronic-hanke.de/
|Email=electronic_hanke@t-online.de
|Bemerkung=
}}

===Köln===
{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Horbellerstr. 2-4
|PLZ=50858
|Ort=Köln
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 9.30-20.00 Uhr
|Weblink=http://filialen.conrad.de/rubriken/filialen.php?filiale=13
|Email=filiale.koeln@conrad.de
|Bemerkung= Hat ab dem 3.07. geschlossen!!!!
}}

{{ElektronikLieferant
|Firmenname=M. + M. van der Meyden GmbH
|Straße=Breite Straße 101
|PLZ=50667
|Ort=Köln
|Telefon=0221/2576369
|Fax=0221/2576369
|Öffnungszeiten=Mo.–Fr. von 9:30 – 19:00 Uhr Sa. von 10:00 – 16:30 Uhr
|Weblink=http://vandermeyden.de
|Email=http://vandermeyden.de/?page_id=13
|Bemerkung=
}}
 

===Bergisch Gladbach===
{{ElektronikLieferant
|Firmenname=MS-Elektronik
|Straße=Laurentiusstrasse 20
|PLZ=51465
|Ort=Bergisch Gladbach
|Telefon=02202 - 93 22 17
|Fax=02202 - 93 22 18
|Öffnungszeiten=Mo.-Fr.: 09:00-12:30 & 14:30 - 18:30 Uhr Sa: 09:00 - 14:00 Uhr
|Weblink=http://www.ms-elektronik.info/
|Email=info@ms-elektronik.info
|Bemerkung= Auch Versand
}}

===Langenfeld===
{{ElektronikLieferant
|Firmenname=rs elektronik - Reinhard Sinzel
|Straße=Solinger Strasse 152
|PLZ=40764
|Ort=Langenfeld
|Telefon=02173/22766
|Fax=02173/25958
|Öffnungszeiten=Mo-Fr 10:00-13:00 + 15:00-18:00, Sa 10:00-13:00
|Weblink=
|Email=
|Bemerkung=zwischen Polizeiwache und Bahnunterführung auf der linken Seite. Nur Ladenverkauf!
}}

===Mönchengladbach===
{{ElektronikLieferant
|Firmenname=Brunenberg Elektronik
|Straße=Lürriper Strasse 170
|PLZ=41065
|Ort=Mönchengladbach
|Telefon=02161-44421
|Fax=02161-42552
|Öffnungszeiten=Mo.- Fr. 9:00 - 13:00 und 14:00 - 18:00 Samstag 9:00 - 13:00 Donnerstag Nachmittag geschlossen!
|Weblink=http://www.bruntronic.de
|Email=info@bruntronic.de
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Zilles Elektronik GmbH
|Straße=Staufenstraße 8-10
|PLZ=41061
|Ort=Mönchengladbach
|Telefon=02161/176005
|Fax=02161/176007
|Öffnungszeiten=Montag - Freitag 8:30 - 13:00 & 14:00 - 18:00 Samstag 9:00 - 12:00
|Weblink=http://www.zilles-elektronik.de/
|Email=info@zilles-elektronik.de
|Bemerkung=
}}

===Paderborn===
{{ElektronikLieferant
|Firmenname=Jansen-Elektronik GmbH & Co. KG
|Straße=Heiersstrasse 24
|PLZ=33098
|Ort=Paderborn
|Telefon=05251-282848
|Fax=05251-282851
|Öffnungszeiten=Mo. – Sa. 9.30 – 13.00 Uhr Mo. – Fr. 14.30 – 18.00 Uhr
|Weblink=http://www.jansen-elektronik.de/
|Email=info@jansen-elektronik.de
|Bemerkung=
}}

===Recklinghausen===
{{ElektronikLieferant
|Firmenname=Elektronik-Center Wenzlik, Inh. H.- J. Juhnke
|Straße=Halterner Straße 24
|PLZ=45657
|Ort=Recklinghausen
|Telefon=02361-14103
|Fax=02361-182489
|Öffnungszeiten=Mo.-Fr.: 9.00h-18.30h, Sa.: 9.30h - 14.00h durchgehend geöffnet!
|Weblink=http://www.Wenzlik-RE.de
|Email=ecw-recklinghausen@t-online.de
|Bemerkung= Elektronik Einzelhandel 47.000 verschiedene Artikel vorrätig.
}}

==Rheinland-Pfalz==
===Andernach===
{{ElektronikLieferant
|Firmenname=EDV + Elektronic Systeme
|Straße=Füllscheuer 30
|PLZ=56626
|Ort=Andernach
|Telefon=02632/9293-0
|Fax=02632/9293-33
|Öffnungszeiten=Montag-Freitag 8:00 Uhr - 18:00 Uhr/Samstag geschlossen
|Weblink=http://www.eleksys.de/
|Email=info@eleksys.de
|Bemerkung=
}}

===Koblenz===
{{ElektronikLieferant
|Firmenname=Radio Erbar
|Straße=Bahnhofstr. 40
|PLZ=56068
|Ort=Koblenz
|Telefon=0261/34782
|Fax=0261/14570
|Öffnungszeiten=Montag-Freitag 9:00 Uhr - 18:00 Uhr/Samstag 9:00 Uhr - 12:00 Uhr
|Weblink=http://www.radio-erbar.de/
|Email=webmaster@radio-erbar.de
|Bemerkung=
}}
===Mainz===
{{ElektronikLieferant
|Firmenname=Conrad Elektronik
|Straße=Binger Str. 14-16 (nähe Hauptbahnhof)
|PLZ=55122
|Ort=Mainz
|Telefon=0180 5312111
|Fax=
|Öffnungszeiten=
|Weblink=http://www.conrad.de/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Elektronik Schmidt
|Straße=Boppstrasse 62 - 64
|PLZ=55118
|Ort=Mainz
|Telefon=0180 5312111
|Fax=
|Öffnungszeiten=Montag - Freitag 09.00 Uhr - 13.00 Uhr und 14.00 Uhr - 18.00 Uhr 
Samstag 09.00 Uhr - 13.00 Uhr
|Weblink=http://www.schmidt-electronic.de
|Email=
|Bemerkung=
}}

==Saarland==
=== Saarbrücken ===
{{ElektronikLieferant
|Firmenname=ESS Elektronik Service Skowronek
|Straße=Peter-Zimmer-Str. 13
|PLZ=66123
|Ort=Saarbrücken
|Telefon=+49 (681) 816414
|Fax= +49 (681) 816992
|Öffnungszeiten= Mo-Fr 8:00-12:00 Uhr / 14:00-18:00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Trierer Straße 16-20
|PLZ=66111
|Ort=Saarbrücken
|Telefon=0180 5 564445 (derzeit 14 Cent/Min. aus dem Festnetz der Dt. Telekom. Evtl. abweichende Preise für Anrufe aus den Mobilfunknetzen.)
|Fax=
|Öffnungszeiten= Mo.-Fr. 09.00-19.00 Uhr / Sa. 09.00-19.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

==Sachsen==
===Chemnitz===
{{ElektronikLieferant
|Firmenname=mükra electronic shop GmbH
|Straße=Hartmannstr.45
|PLZ=09113
|Ort=Chemnitz
|Telefon=0371/365736
|Fax=0371/365736
|Öffnungszeiten=Mo.-Fr. 10.00 Uhr - 18.00 Uhr Sa. 10.00 Uhr - 13.00 Uhr
|Weblink=http://onlineshop.muekra-electronic.com
|Email=
|Bemerkung=gut sortiert aber keine SMD BE
}}

{{ElektronikLieferant
|Firmenname=köhler-elektronik Firma Michael Köhler
|Straße=Erfenschlager Strasse 31
|PLZ=09125
|Ort=Chemnitz
|Telefon=(03 71) 51 91 03
|Fax=(03 71) 51 91 04
|Öffnungszeiten=Mo.-Fr. von 9 - 18 Uhr Sa. von 9 - 12 Uhr
|Weblink=http://www.koehler-elektronik.de
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=NEUMERKEL
|Straße=Straße der Nationen 26
|PLZ=09111
|Ort=Chemnitz
|Telefon=(03 71) 6 66 29 27
|Fax=(03 71) 6 66 29 51
|Öffnungszeiten=Mo.-Fr. von 9 - 13 und 14 - 18 Uhr
|Weblink=http://www.neumerkel.de
|Email=neumerkel.chemnitz@neumerkel.de
|Bemerkung=zwischen B. Uhse und ehemals McDonald’s :)
}}

===Dresden===
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Friedrich-List-Platz 2 gegenüber Hauptbahnhof
|PLZ=01069
|Ort=Dresden
|Telefon=
|Fax=
|Öffnungszeiten=Mo.-Fr. 09.30-20.00 Uhr, Sa. 09.00-20.00 Uhr
|Weblink=
|Email=
|Bemerkung= verhältnismäßig teuer
}}

{{ElektronikLieferant
|Firmenname=Sullus
|Straße=Tharandter Str. 67
|PLZ=01187
|Ort=Dresden
|Telefon=0351 4112100
|Fax=0351 4112146
|Öffnungszeiten=Mo.-Fr. 10.00-18.30 Uhr, Sa. 09.00-12.00 Uhr
|Weblink=http://www.sullus.de/
|Email=
|Bemerkung=
}}

===Leipzig===
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Neumarkt 20
|PLZ=04109
|Ort=Leipzig
|Telefon=
|Fax=
|Öffnungszeiten=Mo.-Sa.: 09.30-20.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=ELMICRO Computer GmbH & Co. KG
|Straße=Hohe Str. 9-13
|PLZ=04107
|Ort=Leipzig
|Telefon=+49-(0)341-9104810
|Fax=+49-(0)341-9104818
|Öffnungszeiten=Mo.-Sa.: 09.00-17.00 Uhr
|Weblink=http://elmicro.com/de/ela-leipzig.html
|Email=leipzig|at|elmicro.com
|Bemerkung=Besucher werden gebeten, sich kurzfristig telefonisch anzumelden.
}}

===Zwickau===
{{ElektronikLieferant
|Firmenname=Elektronik Neumerkel GmbH
|Straße=Kolpingstraße 20
|PLZ=08058
|Ort=Zwickau
|Telefon=+ 49 (0)375-589920
|Fax=+ 49 (0)375-5899222
|Öffnungszeiten=Mo. - Fr. 9:00 - 18:00 Uhr, Sa. 9:00 - 12:30 Uhr
|Weblink=http://www.neumerkel.de
|Email=info@neumerkel.de
|Bemerkung=Auch als Teuermerkel bekannt :)
}}

==Sachsen-Anhalt==
===Magdeburg===
{{ElektronikLieferant
|Firmenname=mittrenga electronic
|Straße=Maxim-Gorki-Str. 34
|PLZ=39108
|Ort=Magdeburg
|Telefon=0391/7333500
|Fax=0391/7346538
|Öffnungszeiten= 15.00- 18.00
|Weblink=
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Nova Electronic
|Straße=Leipziger Str. 31
|PLZ=39112
|Ort=Magdeburg
|Telefon=0391/6272537
|Fax=?
|Öffnungszeiten=15.00- 1800
|Weblink=
|Email=
|Bemerkung=
}}

==Schleswig Holstein==
===Kiel===
{{ElektronikLieferant
|Firmenname=Elektronik Schmidt Inh. Karl Heinz Parting
|Straße=Adelheidstr. 28
|PLZ=24103
|Ort=Kiel
|Telefon=0431 94682
|Fax=0431 92574
|Öffnungszeiten=
|Weblink=
|Email=
|Bemerkung= viele historische Bauteile verfügbar, Röhren
}}

{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Mergenthalerstr. 22
|PLZ=24223
|Ort=Raisdorf
|Telefon=0180 5 564445
|Fax=
|Öffnungszeiten=Mo.-Sa. 10.00-20.00 Uhr
|Weblink=http://www.conrad.de
|Email=
|Bemerkung=
}}

==Thüringen==
===Erfurt===
{{ElektronikLieferant
|Firmenname=Hübner-Elektronik e.K.
|Straße=Juri-Gagarin-Ring 27
|PLZ=99084
|Ort=Erfurt
|Telefon= +49 (0361) 6 42 34 56
|Fax= +49 (0361) 6 42 34 55
|Öffnungszeiten=Montag-Freitag - 9.30 bis 18.30 Uhr, Samstag - 10.00 bis 13.00 Uhr
|Weblink=http://www.huebner-elektronik.de/
|Email= info@huebner-elektronik.de
|Bemerkung=
}}

===Eisenach===
{{ElektronikLieferant
|Firmenname=Elektronik-Stübchen
|Straße=Katharinenstraße 117
|PLZ=99817
|Ort=Eisenach
|Telefon= (03691)77324
|Fax=
|Öffnungszeiten=Montag-Freitag - 9.00 bis 13.00 Uhr, 14.30 bis 18 Uhr
Sonnabend 9.00 bis 12.00 Uhr
|Weblink=
|Email=
|Bemerkung=
}}

===Jena===
{{ElektronikLieferant
|Firmenname=Stefan Schmutzer VAT Elektronik
|Straße=Bachstraße 10
|PLZ=07743
|Ort=Jena
|Telefon= (03641)447184
|Fax=
|Öffnungszeiten= Mo-Fr. bis 18:00Uhr. Sa zu
|Weblink=
|Email=
|Bemerkung=
}}

=Österreich=
==Linz==
{{ElektronikLieferant
|Firmenname=Aigner Elektronik
|Straße=Dinghoferstr. 63
|PLZ=A-4020
|Ort=Linz
|Telefon=+43 732 669691-0
|Fax=+43 732 669691-15
|Öffnungszeiten=Mo. bis Fr. 8:30 bis 17:00 (keine Mittagssperre), Samstag 8:30 bis 12:00
|Weblink=http://www.aigner.co.at/
|Email=
|Bemerkung=
}}

{{ElektronikLieferant
|Firmenname=Conrad Electronic
|Straße=Kornstraße 4
|PLZ=A-4060
|Ort=Leonding
|Telefon=+43 732 683040-0
|Fax=+43 732 683040-13
|Öffnungszeiten=Mo. bis Fr. 9:00 bis 19:00 , Samstag 9:00 bis 17:00
|Weblink=http://www.conrad.at/
|Email=mailto://filiale.linz@conrad.at
|Bemerkung=
}}

==Graz==
{{ElektronikLieferant
|Firmenname=Neuhold Elektronik
|Straße=Griesplatz 1
|PLZ=A-8020
|Ort=Graz
|Telefon=+43 (0) 316 711245
|Fax=+43 (0) 316 717419
|Öffnungszeiten=Montag bis Freitag von 9.00 - 18.00 Uhr Samstag 9.00-12.30 Uhr
|Weblink=http://www.neuhold-elektronik.at/
|Email=
|Bemerkung=Großes Sortiment mit auch sehr ausgefallenen Artikeln. Führt eine breite Produktpalette. Durchweg sehr günstige Preise, jedoch manchmal bei Standardbauteilen (Mikrocontrollern z.B. AVRs) teurer als die Konkurrenz. Vergleichbar mit Pollin.
}}
 
 
{{ElektronikLieferant
|Firmenname=Riedl Electronic
|Straße=Brückenkopfgasse 2
|PLZ=A-8020
|Ort=Graz
|Telefon=Tel: +43 (0) 316 718031-0 od. +43 (0) 664 2104608
|Fax=+43 (0)316 718031-6
|Öffnungszeiten=Montag bis Freitag von 9.00 - 12.30 Uhr - Mittagspause und dann von 14.00 - 18.00 Uhr Samstag 9.00-12.00 Uhr
|Weblink=http://www.riedl-electronic.at/
|Email=office@riedl-electronic.at
|Bemerkung=Elektronikkomponenten müssen vorher über den Onlineshop bestellt werden. Diese werden dann von einem externen Lager geholt und können auf Wunsch in der Filiale in Graz abgeholt werden. Natürlich kann man sie auch direkt an die Haustür liefern lassen.
}}
 
 
{{ElektronikLieferant
|Firmenname=L-Tronik Austria
|Straße=Karlauerstrasse 5
|PLZ=A-8020
|Ort=Graz
|Telefon=Tel: +43 (0) 316 904 672
|Fax=
|Öffnungszeiten=Montag bis Freitag von 9.00 - 17.00 Uhr Samstag 9.00-12.00 Uhr
|Weblink=http://www.l-tronik.com/index.php
|Email=info@lta.at
|Bemerkung=Riesiges Sortiment an Halbleitern (Auch SMD). Solartechnik, Sicherheitstechnik, Haustechnik u.s.w..
}}
 
 
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Weblinger Gürtel 25
|PLZ=A-8054
|Ort=Graz
|Telefon=Tel: +43 (0) 50 - 20 40 73 00
|Fax=
|Öffnungszeiten=Montag bis Freitag von 9.00 - 19.30 Uhr Samstag 9.00 - 18.00 Uhr
|Weblink=http://www.conrad.at
|Email=filiale.graz@conrad.at
|Bemerkung=
}}

==Salzburg==
{{ElektronikLieferant
|Firmenname=Conrad
|Straße=Alpenstraße 95 - 97
|PLZ=5020
|Ort=Salzburg
|Telefon=050 - 20 40 81 00
|Fax=
|Öffnungszeiten=Mo.-Fr. 9.00-19.00 Uhr Sa. 9.00-18.00 Uhr
|Weblink=http://www.conrad.at/megastores
|Email=
|Bemerkung=
}}

==Wels==
{{ElektronikLieferant
|Firmenname=Andi Leitner - AL Elektronik
|Straße=Linzer Straße 57
|PLZ=4600
|Ort=Wels
|Telefon=07242/53624
|Fax=07242/53624-3
|Öffnungszeiten=Montag bis Freitag von 0800 bis 1800
|Weblink=http://www.al-elektronik.at
|Email=office@al-elektronik.at
|Bemerkung=Modellbau- und Elektronik-Laden. Andi nimmt sich für jeden Kunden die nötige Zeit. Nicht lagernde Ware nach Bestellung abholbar. Umfangreiche, kompetente Beratung. Nur wenig SMD-Bauteile, generell keine MSP430, sonst umfangreiche Auswahl. Website sehr unvollständig - besonders im Elektronikbereich.

Anfahrt: Von der Innenstadt kommend: Auf der Stelzhamerstraße westwärts bis zur Ampel vor der Gebietskrankenkasse. An der Ampel rechts, nach ungefähr 100m an der nächsten Kreuzung Links. Nach rund 250m erreichen Sie das Geschäft auf der Linken Straßenseite.

Von Osten kommend: Auf der Wiener Bundesstraße Richtung Zentrum, immer gerade aus (Osttangente queren). Weiter gerade aus westwärts (auf der Hans-Sachs-Straße). Auch beim Kreisverkehr beim Pensionistenheim gerade drüber (sprich: 2. Ausfahrt des Kreisverkehrs). Weiter gerade in Richtung Innenstadt, bis sie zur Ampel bei der Gebietskrankenkasse kommen. Hier Links abbiegen. Nach ungefähr 100m an der nächsten Kreuzung Links. Nach rund 250m erreichen Sie das Geschäft auf der Linken Straßenseite.
}}

==Wien==
{{ElektronikLieferant
|Firmenname=GM Electronic GmbH
|Straße=Brünner Straße 19
|PLZ=1210
|Ort=Wien
|Telefon=01/27 11 256
|Fax=
|Öffnungszeiten=Mo.-Fr. 9.00-13.00 14.00-18.00 Uhr Sa. 10.00-13.00 14.00-16.00 Uhr
|Weblink=http://www.gm-e.eu/index.php
|Email=
|Bemerkung=
}}

----

=Schweiz=
----
==Aargau (AG)==
===Baden===
{{ElektronikLieferant
|Firmenname=<s>Gautschi Elektronik (ehemals AUTRIX Meier)</s> ***)
|Straße=Martinsbergstrasse 28
|PLZ=5400
|Ort=Baden
|Telefon=056 222 24 24
|Fax=056 210 06 12
|Öffnungszeiten=
Montag 13:30-18:00, Di-Fr 08:00-12:00 und 13:00-18:00, Sa 09:00-12:00
|Weblink=
|Email=
|Bemerkung=Orchesterelektronik, REVOX und Elektronik-Laden.
Ehemals AUTRIX Meier. Nach bald 30 Jahren hat Ernst Meier den Laden 2006 in neue
Hände gegeben. Hier spürt man noch den Charme der 70er Jahre des letzten Jahrhunderts: ca. 20m2 Ladenlokal, vollgestopft bis unter die Decke mit mit elektronischem Kleinkram!
Teile des Sortiments entstammen ebenfalls dieser Zeitepoche. Mikroprozessoren und SMD-Bauteile sucht man hier vergebens. Dafür lassen sich auch mal (heute seltene) TTL's finden!
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
 '''***)''' seit Frühjahr 2009 Liegenschaft abgebrochen. Nachfolgefirma unbekannt. 
Schweizermacher [[Spezial:Beiträge/83.78.147.198|83.78.147.198]] 07:13, 7. Jan. 2010 (UTC)
}}

===Zofingen===
{{ElektronikLieferant
|Firmenname=Surplus Party Zofingen Funkerverein Zofingerrunde HB9FX
|Straße=Strengelbacherstrasse 27 (Mehrzweckhalle)
|PLZ=4800
|Ort=Zofingen
|Telefon=
|Fax=
|Öffnungszeiten= 
'''1x jährlich am letzen Samstag im Oktober:''' 31. Oktober 2009 / 30. Oktober 2010 / 29. Oktober 2011 / 27. Oktober 2012
 08:30 bis 16:30 Uhr
|Weblink=http://www.surplusparty.ch/surplus.htm
|Email=event(at)surplusparty.ch
|Bemerkung='''Die Surplus Party, seit 1984 der grösste Flohmarkt der Schweiz von Amateufunkern für Amateurfunker! Der Eintritt ist gratis.'''
Neue und gebrauchte Bauteile aus Elektronik, Funk- und Computertechnik, Surplus-Messgeräte, Funkgeräte und alles wonach man nie gesucht hat!

'''Anreise mit dem Auto:''' 
Aus den Richtungen Basel, Bern und Zürich die Autobahn A1 in Oftringen (Ausfahrt Nr. 48) verlassen und in Richtung Zofingen fahren. Vor dem Stadteingang beginnt die Beschilderung zu den Parkplätzen (nach rechts abbiegen, am Bahnhof vorbei, nach dem Busterminal rechts abbiegen und die Bahnlinie überqueren).

Aus der Richtung Luzern die Autobahn A2 in Reiden (Ausfahrt Nr. 18) verlassen und in Richtung Zofingen fahren. Vor dem Stadteingang beginnt die Beschilderung zu den Parkplätzen (nach links abbiegen).
Es stehen ausreichend Parkplätze zur Verfügung!

Die Parkplätze direkt bei der Halle sind gebührenpflichtig (Samstag bis 12:00 Uhr). Die Parkkarten für reservierte Plätze berechtigen nur zur Einfahrt direkt vor die Halle, aber Ersetzen nicht das notwendige Parkticket!

Total stehen für die Surplus Party '''rund 1'000 Parkplätze''' (davon etwa 750 gratis) zur Verfügung. Bitte befolgen Sie die Anweisungen des Parkdienstes.

'''Anreise mit dem Zug:''' 
Zofingen befindet sich an der SBB Linie 501 Olten - Luzern und ist Haltestelle für die meisten Schnellzüge.
In Zofingen angekommen, verlassen Sie und der Bahnlinie entlang in südlicher Richtung. Gehen Sie an den Busterminals vorbei, überqueren Sie die Bahnlinie nach rechts und von da an gehen Sie alles geradeaus bis zur Mehrzweckhalle (problemlos in 10 Minuten Fussmarsch erreichbar).
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

== Basel-Stadt (BS) ==
=== 4002 Basel ===
{{ElektronikLieferant
|Firmenname=<s>Grieder Elektronik Bauteile AG</s>
|Straße=<s>Nauenstrasse 63</s>
|PLZ=<s>4002</s>
|Ort=<s>Basel</s>
|Telefon=n/a
|Fax=n/a
|Öffnungszeiten='''Ladenlokal in Basel per Ende 2008 geschlossen.'''
|Weblink=http://shop.griederbauteile.ch/
|Email=n/a
|Bemerkung=Umzug nach 4450 Sissach ==> [[Lokale_Elektroniklieferanten#4450_Sissach]]
Fortführung als Versandunternehmen. 
z.Zt. liegen keine Informationen über die Möglichkeit der Abholung von vorbestellter Ware vor Ort vor.

 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:37, 13. Okt. 2009 (UTC)
}}

== Basel-Landschaft (BL) ==
=== 4450 Sissach ===
{{ElektronikLieferant
|Firmenname=Grieder Elektronik Bauteile AG
|Straße=Reuslistrasse 62
|PLZ=4450
|Ort=Sissach
|Telefon=061 976 95 95
|Fax=061 976 95 90
|Öffnungszeiten=Mo-Do 800-1200, 1300-1600 und Fr 800-1200, 1300-1500.
|Weblink=http://shop.griederbauteile.ch/
|Email=info@griederbauteile.ch
|Bemerkung=Mindestbestellwert CHF 20. Vorbestellte Waren können abgeholt werden. Der "Laden" befindet sich 10 Minuten zu Fuss vom Bahnhof Sissach.

}}

== Luzern (LU) ==
=== Emmenbrücke ===
{{ElektronikLieferant
|Firmenname=Conrad Electronic Schweiz
|Straße=Seetalstrasse 11
|PLZ=6020
|Ort=Emmenbrücke
|Telefon=0848/80 12 83
|Fax=041/267 32 14
|Öffnungszeiten= 
Mo/Di/Do 09:00-18:30, Mi/Fr 09:00-21:00, Sa 08:00-16:00 Uhr

|Weblink=http://www1.ch2.conrad.com/infocenter/filialen.php
|Email=filiale.emmenbruecke@conrad.ch

|Bemerkung=5 Minuten vom Bahnhof Emmenbrücke GRATIS Parkhaus & Parkplätze
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

== Solothurn (SO) ==
===5014 Gretzenbach===
{{ElektronikLieferant
|Firmenname=EFG Electronic AG
|Straße=Köllikerstrasse 32
|PLZ=5014
|Ort=Gretzenbach
|Telefon= 062 849 23 61
|Fax= 062 849 23 70
|Öffnungszeiten=
Mo-Fr 08:30-11:30, 13:30-18:30, Mi geschlossen, Sa 09:00-16:00
|Weblink=http://www.maxland.ch/netmax/standseiten/efg/index.html
|Email=efgag@yetnet.ch
|Bemerkung=Kabel - Messgeräte - Lautsprecher - elektronische Bauteile
kein Versand, nur Ladengeschäft
 [[Spezial:Beiträge/62.203.205.15|62.203.205.15]] 11:35, 8. Feb. 2010 (UTC) -- Edit: Schweizermacher
}}

== Zürich (ZH) ==
===8004 Zürich===
{{ElektronikLieferant
|Firmenname=Pusterla Elektronik AG
|Straße=Hohlstrasse 52
|PLZ=8004
|Ort= Zürich
|Telefon=044 241 56 77
|Fax=044 242 01 04
|Öffnungszeiten=
Mo-Fr 09:00-18:30, Sa 09:00-16:00
|Weblink=http://www.pusterla.ch/
|Email=info@pusterla.ch
|Bemerkung=Absoluter "Kult-Laden" mit Tradition. Wer jemals in der Schweiz einen Lötkolben in der Hand hatte, der kennt "Pusti"

Das Sortiment ist zweigeteilt: 
'''hinter dem Tresen:''' 
gutes allgemeines Bauteilesortiment, spezielle Sachen werden bestellt.
 Man nimmt sich Zeit für Fachberatung - es wird auch schon mal ein Vergleichstyp aus der Liste gesucht und dem jungen "Case-Modder" wird mit Engelsgeduld erklärt wie man den Vorwiderstand für seine coole LED-Prozessorinnenbeleuchtung berechnet.

'''vor dem Tresen - Selbstbedienung:''' 
Am Eingang nimmt man sich eine Pappschale mit Bleistift und Notizblock.
Artikel, Menge und Preise schreibt man selbst auf!

Das Sortiment bietet einen Querschnitt durch die elektronische Bauteilefertigung der letzten 50 Jahre. Sehr gute Quelle für spannungsfeste Kondensatoren und hochohmige (Leistungs-)Widerstände sowie mechanischem "Klein-Grabbel-Kram." Gute Auswahl an Gehäusen, Transformatoren (z.T. recht schräge Typen) sowie Relais und Stecker/Buchsen die die Welt wohl niemals gebraucht hat. '''Vorsicht bei Elektrolytkondensatoren:''' "historische" Lagerware, besser man hat ein ESR-Meter dabei - sodenn man hat!
 Kabel jeglicher Art gibt es ab der Rolle zum Selberabschneiden - auch 10cm sind kein Problem - ausrechnen und aufschreiben machst Du ja selber.
 Präsentation der Ware im Selbsbedienungsteil:
 Bauteile offen oder ab Gurt in kleinen, liebevoll angeschriebenen Pappschachteln (noch von Vater Pusterla), grösseren Wühlschachteln, einer Wühlecke sowie hier und da einige Merkwürdigkeiten auf dem Fussboden.
Man stelle sich das Ladenlokal eines Joint-Ventures aus Oppermann, Pollin, dem ehem. Völkner sowie dem örtlichen Entsorgungshof vor - '''das''' ist "Pusti" und so war er schon immer! 

'''Fazit:''' absolut lohnenswert, auch wenn man vielleicht nicht immer das bekommt was man wollte, dafür findet man aber alles, wonach man nie gesucht hatte!
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
 [[Spezial:Beiträge/62.203.205.15|62.203.205.15]] 11:45, 8. Feb. 2010 (UTC) -- Edit: Tippfehler (Schweizermacher)
}}

===8025 Zürich===
{{ElektronikLieferant
|Firmenname=in Memoriam: (1967 - 1996)
''Alfred Mattern AG''
|Straße=''Seilergraben 53''
|PLZ=''8025''
|Ort= ''Zürich''
|Telefon= n/a
|Fax= n/a
|Öffnungszeiten=n/a
|Weblink=http://www.moneyhouse.ch/u/pub/alfred_mattern_ag_CH-020.3.916.364-3.htm
|Email=
|Bemerkung=Firmengründung 1967, Konkurs 1996

'''SHAB: 235 / 1996 vom 03.12.1996 (Seite 7457)''' 
27. November 1996 (25729) 
Alfred Mattern AG, in Z ü r i c h, Handel mit Antennen und Antennenzubehör sowie mit Geräten und Bauteilen der Elektro-, Elektronik-, Radio-und Fernsehindustrie, Aktiengesellschaft (SHAB Nr. 210 vom 30. 10. 1995, S. 5945).
Firma neu: Alfred Mattern AG in Liquidation. Mit Verfügung vom 02.10.1996 hat der Konkursrichter des Bezirksgerichts Zürich über die Gesellschaft den Konkurs eröffnet; demnach ist die Gesellschaft aufgelöst. Das Konkursverfahren ist mit Verfügung desselben Richters vom 13.11.1996 mangels Aktiven eingestellt worden.
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

===8092 Zürich===
{{ElektronikLieferant
|Firmenname="Bastli" Fachverein der Departemente Informationstechnologie und Elektrotechnik und Maschinenbau und Verfahrenstechnik an der ETH Zürich.
|Straße=Universitätsstrasse 19
|PLZ=8092
|Ort= Zürich
|Telefon= n/a
|Fax= n/a
|Öffnungszeiten=Die Öffnungszeiten gelten nur während des Semesters.
Mo 12:15 - 13:00 Uhr 
Do 12:15 - 13:00 Uhr 

|Weblink=http://www.bastli.ethz.ch/
|Email=bastli@amiv.ethz.ch
|Bemerkung=Studentischer "Bastel-Shop"
Während den Öffnungszeiten ist der Bastli-Shop im ersten Stock des UNG geöffnet.
Ihr könnt Bauteile, welche wir an Lager haben, kaufen und euch wird mit diversen elektronischen Problemen geholfen.

Organisierte Sammelbestellungen bei Fa. Reichelt / Deutschland

'''Standort:''' 

Bastli und Messplatz befinden sich in den Räumlichkeiten des AMIV im UNG Gebäude schräg gegenüber des CAB.
Es ist das gleiche Gebäude in dem auch der ehem. AMIV-Verlag respektive ehem. WBS respektive SPOD untergebracht ist.

Das Gebäude wirkt beim ersten Kontakt wohl für jeden neuen ein bisschen abschreckend. Aber keine Scheu, wenn man durch das etwas schlecht beleuchtete Treppenhaus in den ersten Stock gelangt, wendet man sich dort gleich nach rechts. Bastli und Messplatz haben die Zimmernummern C6 und C5.
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

=== 8305 Dietlikon ===
{{ElektronikLieferant
|Firmenname=Conrad Electronic Schweiz
|Straße=Alte Dübendorferstrasse 17
|PLZ=8305
|Ort=Dietlikon
|Telefon=0848/80 12 84
|Fax=044/805 35 14
|Öffnungszeiten= 
Mo-Do 10:00-20:00, Fr 10:00-21:00, Sa 09:00-20:00 Uhr

|Weblink=http://www1.ch2.conrad.com/infocenter/filialen.php
|Email=filiale.dietlikon@conrad.ch

|Bemerkung=5 Minuten vom Bahnhof Dietlikon Parkhaus & Parkplätze vorhanden
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

=== 8606 Nänikon ===
{{ElektronikLieferant
|Firmenname=Distrelec Schweiz
|Straße=Grabenstrasse 6
|PLZ=8606
|Ort=Nänikon
|Telefon=044 - 944 99 11
|Fax=044 - 944 99 88
|Öffnungszeiten= 
Mo-Fr 07:30-18:00 Uhr (nur Abholschalter)

|Weblink=https://www.distrelec.ch
|Email=info@distrelec.com
|Bemerkung='''Abholschalter:''' (Vorbestellung unbedingt erforderlich)
Telefonisch oder online bestellte Ware kann nach ca. 2 Stunden abgeholt werden.
 Es kann auch direkt vor Ort ab Katalog bestellt werden, allerdings dann Wartezeit von min. 2 Stunden
 Bezahlung: bar/EC- und Post-Card
 [[Spezial:Beiträge/85.3.130.90|85.3.130.90]] 13:12, 13. Okt. 2009 (UTC)
}}

= Siehe auch =
* [[Platinenhersteller]]
* [[Elektronikversender]]
* [[Eisenwarenversender]]