Mikrocontroller.net - Benutzerbeiträge [de]

Bierdeckel-Programmer

2014-10-16T14:39:36Z

M-w: Werbelink entfernt. Leider gar kein Bezug zu Mikrocontrollern.

[[Bild:bierdeckel_programmer.jpg|right|thumb|306px|Bierdeckel-Programmer]]

Nein, es werden hier keine Bierdeckel programmiert, sondern gezeigt, dass AVR-Programmer für die USB-Schnittstelle so einfach sind, dass man sie mit Hilfe weniger Teile auch auf einem Bierdeckel aufbauen kann.

Ursprünglich war der Schaltplan auf einem Bierdeckel nur als Werbegag gedacht, aber es lässt sich tatsächlich auf diese Art ein Programmer bauen: Die aufgedruckten kleinen Kreise werden jeweils mit einer Pinnwand-Nadel durchstochen. Auf die so entstandene "Platine" setzt man die Bauteile des Programmers. Verlötet werden sie auf der Unterseite. Dabei stehen die durchgezogenen Linien für Anschlussdrähte, die auf der Oberseite sichtbar sind, und die gestrichelten Linien für Drähte, die auf der Unterseite verlaufen.

; Stückliste
* 1 Mikrocontroller ATtiny85, evtl. mit Fassung
* 1 USB-Anschlussleitung oder eine USB-B-Buchse
* 2 Zener-Dioden (3,6 V)
* 6 Widerstände (2 x 100, 3 x 470, 1 x 2200 Ohm)
* 1 Kondensator (100 nF)

; Verdrahtungsplan
[[Bild:bierdeckel_verdrahtung.png|Verdrahtungsplan des Bierdeckel-Programmers]]

Die 470-Ohm-Widerstände werden für die Funktion des Programmers nicht benötigt. Es ist jedoch empfehlenswert, nicht darauf zu verzichten, sie schützen den Programmer bei falscher Verdrahtung.

== Software ==

Da es sich beim Bierdeckel-Programmer um eine Weiterentwicklung des Standard-USBasp von Thomas Fischl handelt, kann man als Software [[avrdude]] verwenden. Damit lässt sich der Programmer auch unter AVR Studio einbinden.

== Firmware ==

Für den Aufbau wird ein Mikrocontroller des Typs ATtiny85 im DIP-Gehäuse benötigt. Diesen kann man selbst mit der Firmware versehen, sie ist quelloffen und zum Beispiel [http://guloshop.de/f/sources/ ''hier''] downloadbar. Oder man besorgt sich den Mikrocontroller in der bereits programmierten Variante.

[[Kategorie:AVR-Programmer und -Bootloader]]

Datei:Bierdeckel verdrahtung.png

2014-10-16T14:32:12Z

M-w: M-w lud eine neue Version von „Datei:Bierdeckel verdrahtung.png“ hoch

Verdrahtungsplan für den Bierdeckel-Programmer

AVR Typen

2014-07-19T11:55:32Z

M-w: ATtiny861A ergänzt, Preisangaben aktualisiert

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 bzw. ATmega8A statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man eine andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny4313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt es von [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz] oder in dem [http://www.jtronics.de/avr-projekte/xmega-tutorial.html jtronics Xmega Tutorial] .

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny (=winzig) und die Mega (=riesig). Die ATTiny haben kleinere Gehäuse als die ATMega, mit weniger Pins. Dies führt bei ähnlicher Funktionalität wie die Megas zu extremen Mehrfachbelegungen der Pins und auch eher zu Überschneidungen der Pinfunktionalität. Die Tiny sind daher eher für sehr hohe Stückzahlen geeignet, wo die Einsparung über die Stückzahl kommt. Anfänger und Bastler sind mit den ATMega besser bedient, da es weniger Limitierungen gibt.

Tinys haben keinen Hardware-Multiplizierer.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in [https://de.wikipedia.org/wiki/Kibibyte Kibibyte] an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis
|-
|[http://www.atmel.com/Images/doc8127.pdf ATtiny10]
|1
| --
|32
|4
|12
|1.8-5.5
|4 8-bit
|Ja
|1
| --
|Nein
|Ja
|2
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|SOT23
| 0.50-0.99
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.60-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/Images/Atmel-2586-AVR-8-bit-Microcontroller-ATtiny25-ATtiny45-ATtiny85_Datasheet.pdf ATtiny45]
|4
|256
|256
|6
|20
|2.7-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|2
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.80-2.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|2
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.90-2.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.00-2.00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|2.7-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|0.85
|-
|[http://www.atmel.com/Images/doc8183.pdf ATtiny84A]
|8
|512
|512
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1,00-4,00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8197.pdf ATtiny861A]
|8
|512
|512
|16
|20
|1,8-5,5
|11
|Ja
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF32 TSSOP20
|1,50
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8] [http://www.atmel.com/Images/Atmel-8159-8-bit-AVR-microcontroller-ATmega8A_datasheet.pdf ATmega8A]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.50-4.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega48A]
|4
|256
|512
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega88A]
|8
|512
|1K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8011.pdf ATmega164]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|PDIP40 TQFP44 QFN/MLF44
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8271.pdf ATmega168A]
|16
|512
|1K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8271.pdf ATmega328]
|32
|1K
|2K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.80-4.50
|-
|[http://www.atmel.com/Images/doc8272.pdf ATmega324A]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2
|Ja
|PDIP40 TQFP44 VQFN44 QFN/MLF44 DRQFN44 VFBGA49
| 3.50-4.50
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|5.00-7.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8.00-15.00
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

Hinweis: Die angegebenen Preise sind Richtwerte. Es empfiehlt sich die Verwendung einer Preissuchmaschine, z.B. [http://www.google.de/shopping google.de/shopping].

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==
Vergleichstabellen zum Downloaden gibt es unter Anderem
* [http://www.mikrocontroller.net/topic/242328 von Andreas], Stand 19.12.2011; vollständig,
* [http://www.mikrocontroller.net/topic/232939 von Sven], Stand 22.09.2011; weiter eingedampft.

=== ATtiny ===

{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|+ Device-specific Features  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| ATtiny28L || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || ATtiny28L
|-
| ATtiny26 || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || ATtiny26
|-
| ATtiny13 || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || ATtiny13
|-
| ATtiny2313 || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny2313
|-
| ATtiny25 || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || ATtiny25
|-
| ATtiny85 || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || ATtiny85
|-
| ATtiny45 || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || ATtiny45
|-
| ATtiny24 || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny24
|-
| ATtiny44 || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny44
|-
| ATtiny84 || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny84
|-
| ATtiny261 || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || ATtiny261
|-
| ATtiny461 || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || ATtiny461
|-
| ATtiny861 || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || ATtiny861
|-
| ATtiny13A || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || ATtiny13A
|-
| ATtiny48 || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || ATtiny48
|-
| ATtiny88 || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || ATtiny88
|-
| ATtiny24A || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny24A
|-
| ATtiny44A || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny44A
|-
| ATtiny43U || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || ATtiny43U
|-
| ATtiny10 || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || ATtiny10
|-
| ATtiny4 || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || ATtiny4
|-
| ATtiny5 || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || ATtiny5
|-
| ATtiny9 || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || ATtiny9
|-
| ATtiny261A || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || ATtiny261A
|-
| ATtiny461A || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || ATtiny461A
|-
| ATtiny861A || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || ATtiny861A
|-
| ATtiny2313A || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny2313A
|-
| ATtiny4313 || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny4313
|-
| ATtiny167 || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || ATtiny167
|-
| ATtiny87 || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || ATtiny87
|-
| ATtiny20 || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || ATtiny20
|-
| ATtiny40 || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || ATtiny40
|-
| ATtiny84A || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || ATtiny84A
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATmega"
|+ Device-specific Features  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| ATmega8 || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || ATmega8
|-
| ATmega8515 || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || ATmega8515
|-
| ATmega8535 || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega8535
|-
| ATmega16 || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega16
|-
| ATmega32 || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega32
|-
| ATmega64 || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || ATmega64
|-
| ATmega128 || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || ATmega128
|-
| ATmega162 || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || ATmega162
|-
| ATmega48 || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega48
|-
| ATmega88 || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega88
|-
| ATmega168 || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega168
|-
| AT90CAN128 || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || AT90CAN128
|-
| ATmega325 || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega325
|-
| ATmega3250 || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega3250
|-
| ATmega6450 || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega6450
|-
| ATmega645 || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega645
|-
| ATmega329 || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega329
|-
| ATmega3290 || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega3290
|-
| ATmega649 || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega649
|-
| ATmega6490 || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega6490
|-
| ATmega640 || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || ATmega640
|-
| ATmega1281 || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || ATmega1281
|-
| ATmega2561 || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || ATmega2561
|-
| ATmega2560 || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || ATmega2560
|-
| ATmega1280 || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || ATmega1280
|-
| ATmega644 || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega644
|-
| AT90CAN32 || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || AT90CAN32
|-
| AT90CAN64 || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || AT90CAN64
|-
| AT90USB1286 || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || AT90USB1286
|-
| AT90USB1287 || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || AT90USB1287
|-
| AT90USB647 || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || AT90USB647
|-
| AT90USB646 || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || AT90USB646
|-
| ATmega164P || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega164P
|-
| ATmega324P || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega324P
|-
| ATmega165P || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega165P
|-
| ATmega169P || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega169P
|-
| ATmega644P || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega644P
|-
| AT90PWM1 || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || AT90PWM1
|-
| ATmega329P || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega329P
|-
| ATmega3290P || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega3290P
|-
| ATmega325P || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega325P
|-
| ATmega3250P || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega3250P
|-
| AT90USB82 || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || AT90USB82
|-
| AT90USB162 || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || AT90USB162
|-
| AT90PWM216 || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || AT90PWM216
|-
| AT90PWM316 || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || AT90PWM316
|-
| ATmega48P || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega48P
|-
| ATmega88P || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega88P
|-
| ATmega168P || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega168P
|-
| ATmega328P || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega328P
|-
| AT90PWM3B || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || AT90PWM3B
|-
| AT90PWM2B || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || AT90PWM2B
|-
| ATmega32U4 || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || ATmega32U4
|-
| ATmega1284P || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega1284P
|-
| ATmega16U4 || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || ATmega16U4
|-
| ATmega16A || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega16A
|-
| ATmega32A || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega32A
|-
| ATmega88PA || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega88PA
|-
| ATmega324PA || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega324PA
|-
| ATmega48PA || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega48PA
|-
| ATmega164PA || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega164PA
|-
| ATmega64A || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || ATmega64A
|-
| ATmega128A || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || ATmega128A
|-
| ATmega8A || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || ATmega8A
|-
| ATmega168PA || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega168PA
|-
| ATmega8U2 || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || ATmega8U2
|-
| ATmega16U2 || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || ATmega16U2
|-
| ATmega32U2 || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || ATmega32U2
|-
| ATmega644PA || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega644PA
|-
| ATmega16M1 || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || ATmega16M1
|-
| ATmega32M1 || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || ATmega32M1
|-
| ATmega64M1 || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || ATmega64M1
|-
| ATmega169PA || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega169PA
|-
| ATmega48A || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega48A
|-
| ATmega88A || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega88A
|-
| ATmega168A || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega168A
|-
| ATmega328 || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega328
|-
| ATmega164A || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega164A
|-
| ATmega324A || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega324A
|-
| ATmega644A || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega644A
|-
| ATmega1284 || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || ATmega1284
|-
| AT90PWM81 || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || AT90PWM81
|-
| ATmega165PA || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega165PA
|-
| ATmega325A || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega325A
|-
| ATmega3250A || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega3250A
|-
| ATmega645A || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega645A
|-
| ATmega645P || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega645P
|-
| ATmega6450P || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega6450P
|-
| ATmega6450A || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega6450A
|-
| ATmega169A || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega169A
|-
| ATmega329A || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega329A
|-
| ATmega649A || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega649A
|-
| ATmega3290A || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega3290A
|-
| ATmega649P || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega649P
|-
| ATmega6490A || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega6490A
|-
| ATmega6490P || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega6490P
|-
| ATmega329PA || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || ATmega329PA
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATxmega"
|+ Device-specific Features  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Anzahl Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| ATxmega64A1 || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || ATxmega64A1
|-
| ATxmega128A1 || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || ATxmega128A1
|-
| ATxmega64A3 || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega64A3
|-
| ATxmega128A3 || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega128A3
|-
| ATxmega192A3 || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega192A3
|-
| ATxmega256A3 || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega256A3
|-
| ATxmega16A4 || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || ATxmega16A4
|-
| ATxmega32A4 || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || ATxmega32A4
|-
| ATxmega64A4 || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || ATxmega64A4
|-
| ATxmega128A4 || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || ATxmega128A4
|-
| ATxmega256A3B || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega256A3B
|-
| ATxmega256D3 || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || ATxmega256D3
|-
| ATxmega192D3 || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || ATxmega192D3
|-
| ATxmega128D3 || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || ATxmega128D3
|-
| ATxmega64D3 || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || ATxmega64D3
|-
| ATxmega128D4 || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || ATxmega128D4
|-
| ATxmega64D4 || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || ATxmega64D4
|-
| ATxmega32D4 || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || ATxmega32D4
|-
| ATxmega16D4 || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || ATxmega16D4
|-
| ATxmega16A4U || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || ATxmega16A4U
|-
| ATxmega32A4U || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || ATxmega32A4U
|-
| ATxmega64A3U || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega64A3U
|-
| ATxmega128A3U || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega128A3U
|-
| ATxmega192A3U || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega192A3U
|-
| ATxmega256A3U || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega256A3U
|-
| ATxmega256A3BU || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || ATxmega256A3BU
|-
| ATxmega64B3 || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || ATxmega64B3
|-
| ATxmega128B3 || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || ATxmega128B3
|-
| ATxmega128B1 || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || ATxmega128B1
|-
| ATxmega64B1 || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || ATxmega64B1
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/products/selector_overview.aspx Parametrische Suche bei Atmel]

[[Kategorie:AVR]]
[[Kategorie:Liste mit Bauteilen]]

AVR Typen

2014-04-10T16:32:12Z

M-w: Änderung 81370 von 87.157.79.148 (Diskussion) rückgängig gemacht.

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 bzw. ATmega8A statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man eine andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny4313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt es von [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz] oder in dem [http://www.jtronics.de/avr-projekte/xmega-tutorial.html jtronics Xmega Tutorial] .

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny (=winzig) und die Mega (=riesig). Die ATTiny haben kleinere Gehäuse als die ATMega, mit weniger Pins. Dies führt bei ähnlicher Funktionalität wie die Megas zu extremen Mehrfachbelegungen der Pins und auch eher zu Überschneidungen der Pinfunktionalität. Die Tiny sind daher eher für sehr hohe Stückzahlen geeignet, wo die Einsparung über die Stückzahl kommt. Anfänger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

Tinys haben keinen Hardware-Multiplizierer.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in [https://de.wikipedia.org/wiki/Kibibyte Kibibyte] an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis
|-
|[http://www.atmel.com/Images/doc8127.pdf ATtiny10]
|1
| --
|32
|4
|12
|1.8-5.5
|4 8-bit
|Ja
|1
| --
|Nein
|Ja
|2
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|SOT23
| 0.83-0.99
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.60-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/Images/Atmel-2586-AVR-8-bit-Microcontroller-ATtiny25-ATtiny45-ATtiny85_Datasheet.pdf ATtiny45]
|4
|256
|256
|6
|20
|2.7-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|2
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.90-2.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.90-2.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.00-2.00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|2.7-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|0.85
|-
|[http://www.atmel.com/Images/doc8183.pdf ATtiny84A]
|8
|512
|512
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1,00-4,00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8] [http://www.atmel.com/Images/Atmel-8159-8-bit-AVR-microcontroller-ATmega8A_datasheet.pdf ATmega8A]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.50-4.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega48A]
|4
|256
|512
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega88A]
|8
|512
|1K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8011.pdf ATmega164]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|PDIP40 TQFP44 QFN/MLF44
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8271.pdf ATmega168A]
|16
|512
|1K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8271.pdf ATmega328]
|32
|1K
|2K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/Images/doc8272.pdf ATmega324A]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2
|Ja
|PDIP40 TQFP44 VQFN44 QFN/MLF44 DRQFN44 VFBGA49
| 3.50-4.50
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|5.00-7.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8.00-15.00
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

Hinweis: Die angegebenen Preise sind Richtwerte. Es empfiehlt sich die Verwendung einer Preissuchmaschine, z.B. [http://www.google.de/shopping google.de/shopping].

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==
Vergleichstabellen zum Downloaden gibt es unter Anderem
* [http://www.mikrocontroller.net/topic/242328 von Andreas], Stand 19.12.2011; vollständig,
* [http://www.mikrocontroller.net/topic/232939 von Sven], Stand 22.09.2011; weiter eingedampft.

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Anzahl Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Kategorie:AVR]]
[[Kategorie:Liste mit Bauteilen]]

C ohne Makefile

2014-01-30T21:09:19Z

M-w:

Während es unbedingt zu empfehlen ist, zum Übersetzen von mittelgroßen und großen Projekten Makefiles zu verwenden, kann es bei sehr kleinen Programmen oder für kurze Tests einfacher sein, das Übersetzen und Übertragen direkt per Kommandozeilenbefehl zu erledigen. Hier wird eine Methode vorgestellt, die es erlaubt, mit einer einzigen Datei auszukommen, die gleichzeitig als Batch-Datei fürs Übersetzen und Übertragen sowie als Quellcode-Datei verwendet wird.

Dieser Trick gelingt sehr gut unter Linux (hier: Ubuntu). Wahrscheinlich ist es ohne größere Probleme möglich, eine Windows-Variante zu erstellen (bitte im Artikel ergänzen).

Am besten kann die Funktionsweise an einer Beispiel-Quellcodedatei gezeigt werden (hier für AVR-Mikrocontroller):

<div class="code"><pre>
# /*
M=atmega328p; F=${0:0:-2}; rm -f "$F".hex; avr-gcc -mmcu=$M -Os \
-funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums \
-Wall -Wstrict-prototypes -std=gnu99 -g "$F".c -o "$F".elf && \
avr-objcopy -O ihex -R .eeprom "$F".elf "$F".hex && \
avrdude -c usbasp -p $M -B 12 -U flash:w:"$F".hex:i; exit; */

#include <avr/io.h>

int main(void) {
DDRB= 0xFF;
while(1) {
PORTB= 0x03;
// ...
}
return 0;
}

</pre></div>

== Voraussetzungen ==

Neben avr-gcc wird im Beispiel das weit verbreitete Programm [[avrdude]] verwendet. Natürlich kann auch jedes andere Programm zur Übertragung der am Ende erzeugten .hex-Datei verwendet werden. Die Kommandozeilen sind dann entsprechend anzupassen.

== Vorbereitung ==

Die oben im Beispiel gezeigten Kopfzeilen (alles oberhalb von "#include") müssen in die eigene Quellcodedatei kopiert werden. Dort müssen sie ebenfalls ganz am Anfang stehen.

In der zweiten Zeile der Quellcodedatei muss der Name des verwendeten Mikrocontrollers auf den tatsächlich verwendeten Typ geändert werden. Der Compiler akzeptiert den Namen nur in Kleinbuchstaben, also zum Beispiel: <tt>attiny13a</tt>

Damit die Quelldatei als Programm startbar ist, muss einmalig das Ausführungsflag gesetzt werden. Unter Ubuntu kann das am einfachsten so erledigt werden: Rechtsklick auf das Symbol der Quelldatei, Menüpunkt "Eigenschaften", Reiter "Zugriffsrechte", Häkchen bei "Datei als Programm ausführen" setzen.

== Arbeitsweise ==

Die Quelldatei mit den oben gezeigten speziellen Kopfzeilen kann ganz wie gewohnt editiert werden. Zum Übersetzen des Programms bewegt man sich per Kommandozeilenbefehl <tt>cd</tt> in dessen Verzeichnis und ruft es auf, als wäre es ein ganz normales Batch-Kommando. Unter Linux so:

<tt>./meinprogramm.c</tt>

Das Programm wird nun übersetzt, in eine .hex-Datei konvertiert und auf den Mikrocontroller übertragen. 

Geht bei der Übersetzung etwas schief, weil das Programm nicht fehlerfrei übersetzt werden konnte, unterbleibt das Übertragen auf den Mikrocontroller, und die Terminal-Ausgabe zeigt die betreffenden Fehlermeldungen.

== Disassemblieren ==

Mit diesem Befehlszeilenkommando kann man sich anzeigen lassen, welche Assembler-Befehle der C-Compiler erzeugt hat:

<tt>avr-objdump -D -m avr -S -j .text -j .data hier_der_quelldateiname.elf</tt>

C-Programmierer mit guten Assemblerkenntnissen werden hier so manche Überraschung finden. Teilweise lernt man neue Kniffe, die man danach selbst in der Assemblerprogrammierung einsetzen kann. In vielen Fällen wird man sich aber auch wundern, wie umständlich manche Programmabschnitte vom Compiler umgesetzt werden. Man kann sich selbst ein Bild davon machen, in welchen Fällen die Programmiersprache C Vorteile hat und in welchen Fällen man mit Assembler eher zum Ziel kommt.

== Warum funktioniert es, Kommandozeilenbefehle ''und'' Quellcode in derselben Datei zu verwenden? ==

Für das Programmieren von Mikrocontrollern ist die Antwort darauf nicht wichtig, man kann auch einfach hinnehmen, dass es so ist. Für jeden, der sich intensiver mit den Hintergründen beschäftigen will, hier ein paar Sätze zur Erklärung.

Für die Parser von Compiler und Shell ist der jeweils andere Code "unsichtbar":
* Der C-Compiler interpretiert alles, was zwischen /* und */ steht, als Kommentar und ignoriert den betreffenden Abschnitt. Das #-Zeichen zu Beginn der Datei wird in C als Einleitung für eine Präprozessor-Direktive verstanden. Da dem #-Zeichen aber in der gleichen Zeile keine solche Direktive folgt, wird es vom Compiler als "leere Direktive" angesehen und deshalb ignoriert.
* Der Kommandozeileninterpreter betrachtet das #-Zeichen als Einleitung eines Kommentars und ignoriert daher den Rest der ersten Zeile; er macht gleich mit der zweiten Zeile weiter und arbeitet sich bis zum Kommando "exit" durch. Dort beendet er seine Arbeit und ignoriert deshalb den danach folgenden C-Quellcode.

[[Kategorie:avr-gcc Tutorial]]

AVR-GCC-Tutorial

2014-01-26T21:47:36Z

M-w: + Makefile-Alternative

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] (GCC) erleichtern.

Vorausgesetzt werden Grundkenntnisse der Programmiersprache 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.

= Vorwort =

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. Beim Paket [[WinAVR]] gehört die avr-libc Dokumentation zum Lieferumfang und wird mitinstalliert.

Der Compiler und die Standardbibliothek avr-libc werden ständig weiterentwickelt. Einige Unterschiede, die sich im Verlauf der Entwicklung ergeben haben, werden hier und im Artikel [[AVR-GCC-Tutorial/Alte Quellen|Alte Quellen]] zwar angesprochen, Anfängern und Umsteigern sei jedoch empfohlen, eine aktuelle Versionen zu nutzen.

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

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

== Weiterführende Kapitel ==

Um dieses riesige Tutorial 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]].

;UART: → Hauptartikel: ''[[AVR-GCC-Tutorial/Der UART|Der UART]]''

;ADC: → Hauptartikel: ''[[AVR-GCC-Tutorial/Analoge Ein- und Ausgabe|Analoge Ein- und Ausgabe (ADC)]]''

;Timer: → Hauptartikel: ''[[AVR-GCC-Tutorial/Die Timer und Zähler des AVR|Die Timer und Zähler des AVR]]''

;LCD: → Hauptartikel: ''[[AVR-GCC-Tutorial/LCD-Ansteuerung|LCD-Ansteuerung]]''

;Watchdog: → Hauptartikel: ''[[AVR-GCC-Tutorial/Der Watchdog|Der Watchdog]]''

;Assembler: → Hauptartikel: ''[[AVR-GCC-Tutorial/Assembler und Inline-Assembler|Assembler und Inline-Assembler]]''

;alte Quellen anpassen: → Hauptartikel: ''[[AVR-GCC-Tutorial/Alte Quellen|Alte Quellen anpassen]]''

;Makefiles: → Hauptartikel: ''[[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]]'' sowie als Alternative für sehr kleine Projekte → Hauptartikel: ''[[C ohne Makefile]]''

= Benötigte Werkzeuge =

Um eigene Programme für AVRs mittels einer AVR-Toolchain zu erstellen wird folgende Hard- und Software benötigt:

* Eine AVR-Toolchain bestehend aus avr-gcc, den avr-Binutils (Assembler, Linker, etc) und einer Standard-C Bibliothek. Üblich ist die AVR-LibC, die auch quasi in allen avr-gcc Distributionen enthalten ist.

Hardware wird keine benötigt – bis auf einen PC natürlich, auf dem der Compiler ablaufen kann. Selbst ohne AVR-Hardware kann man also bereits C-Programme für AVRs schreiben, compiliern und sich das Look-an-Feel von avr-gcc sowie von IDEs wie [[Atmel Studio]], Eclipse oder leichtgewichtigeren Entwicklungsumbgebungen anschauen. Selbst das Debuggen und Simulieren ist mithilfe entsprechender Tools wie Debugge und Simulator in gewissen Grenzen möglich.

Um Programme für AVRs mittels einer AVR-Toolchain 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.<ref>Für eine Liste der unterstützten COntroller siehe die Dokumentation des Compilers oder [http://www.nongnu.org/avr-libc/user-manual/index.html#supported_devices AVR-Libc: Supported Devices].</ref> 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]].

* 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]].

* 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, siehe auch [[AVR Eclipse]]. Ebenfalls unter Linux und Windows verfügbar ist die Entwicklungsumgebung [http://www.codeblocks.org/ Code::Blocks]<ref>Aktuelle, stabile Versionen sind als Nightly Builds regelmäßig im [http://forums.codeblocks.org/ Forum] verfügbar.</ref>. 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 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 Beispielprogramme 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 drei 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).

* Das Generieren des Programms ohne IDE und ohne Makefile. In diesem Fall muss die Quellcodedatei durch eine vorgefertigte Kommandofolge an den Compiler übergeben werden. Der Artikel [[C ohne Makefile]] zeigt, wie das funktioniert. Diese Vorgehensweise empfiehlt sich jedoch nur für kleine Programme, die nicht auf verschiedene Quellcodedateien verteilt sind.

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.

Ein kurzes Wort zur Hardware: Bei diesem Programm werden alle Pins von PORTB auf Ausgang gesetzt, und einige davon werden auf HIGH andere auf LOW gesetzt. Das kann je nach angeschlossener Hardware an diesen Pins kritisch sein. Am ungefährlichsten ist es, wenn nichts an den Pins angeschlossen ist und man die Funktion des Programmes durch eine Spannungsmessung mit einem Multimeter kontrolliert. Die Spannung wird dabei zwischen GND-Pin und den einzelnen Pins von PORTB gemessen.

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

<syntaxhighlight lang="c">
/* Alle Zeichen zwischen Schrägstrich-Stern
und Stern-Schrägstrich sind 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) { // (5)
/* "leere" Schleife*/ // (6)
} // (7)

/* wird nie erreicht */
return 0; // (8)
}
</syntaxhighlight>

# In dieser Zeile wird eine sogenannte Header-Datei eingebunden. In <code>avr/io.h</code> sind die Registernamen definiert, die im späteren Verlauf genutzt werden. Auch unter Windows wird ein <code>/</code> zur Kennzeichnung von Unterverzeichnissen in Include-Dateinamen verwendet und kein <code>\</code>.
# Hier beginnt das eigentliche Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion <code>main</code>.
# Die Anschlüsse eines AVR (Pins) 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.
# 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, Näheres dazu im Artikel [[Bitmanipulation]]:<syntaxhighlight lang="c">PORTB = (1<<PB1) | (1<<PB0);</syntaxhighlight>
# ist der Beginn der sogenannte ''Hauptschleife'' (main-loop). Dies ist eine Endlosschleife, welche kontinuierlich wiederkehrende Befehle enthält.
# In diesem Beispiel ist die Hauptschleife leer. Der Controller durchläuft die Schleife immer wieder, ohne dass etwas passiert. 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 kehrt das Programm aus <code>main</code> zurück, alle Interrupts werden deaktiviert und eine Endlosschleife betreten.
# Ende der Hauptschleife und Sprung zur passenden, öffnenden Klammer, also zu 5.
# ist das Programmende. Die Zeile ist nur aus Gründen der C-Kompatibilität enthalten: <syntaxhighlight lang="c">int main(void)</syntaxhighlight> besagt, dass die Funktion einen int-Wert zurückgibt. Die Anweisung wird aber nicht erreicht, da das Programm die Hauptschleife nie verlässt.

Um diesen Quellcode in ein 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 <code>Makefile</code> (ohne Endung) im selben Verzeichnis, in dem auch die Datei <code>main.c</code> 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:\beispiel>dir

Verzeichnis von D:\beispiel

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 <code>main.hex</code>, in welcher der Code für den AVR enthalten ist.
<pre>
D:\beispiel>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<ref>z. B. [[Pony-Prog_Tutorial|Ponyprog]], yapp, AVRStudio</ref>, 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 Datentypen (Integer) =

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 <code>stdint.h</code> definiert, die folgendermaßen eingebunden werden kann:
<syntaxhighlight lang="c">#include <stdint.h></syntaxhighlight>

{| {{Tabelle}}
|+ '''int-Typen aus <code>stdint.h</code> (C99)'''  
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenbehaftete int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>int8_t</code> ||align="right"| 8 || −128 ⋯ 127 || −27 ⋯ 27−1 || <code>signed char</code>
|-
|<code>int16_t</code> ||align="right"| 16 || −32768 ⋯ 32767 || −215 ⋯ 215−1 || <code>signed short</code>, <code>signed int</code>
|-
|<code>int32_t</code> ||align="right"| 32 || −2147483648 ⋯ 2147483647 || −231 ⋯ 231−1 || <code>signed long</code>
|-
|<code>int64_t</code> ||align="right"| 64 || −9223372036854775808 ⋯ 9223372036854775807 || −263 ⋯ 263−1 || <code>signed long long</code>
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenlose int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>uint8_t</code> ||align="right"| 8 || 0 ⋯ 255 || 0 ⋯ 28−1 || <code>unsigned char</code>
|-
|<code>uint16_t</code> ||align="right"| 16 || 0 ⋯ 65535 || 0 ⋯ 216−1 || <code>unsigned short</code>, <code>unsigned int</code>
|-
|<code>uint32_t</code> ||align="right"| 32 || 0 ⋯ 4294967295 || 0 ⋯ 232−1 || <code>unsigned long</code>
|-
|<code>uint64_t</code> ||align="right"| 64 || 0 ⋯ 18446744073709551615 || 0 ⋯ 264−1 || <code>unsigned long long</code>
|}

Neben den Typen gibt es auch Makros für die Bereichsgrenzen wie <code>INT8_MIN</code> oder <code>UINT16_MAX</code>. Siehe dazu auch: [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdint.html Dokumentation der avr-libc: Standard Integer Types].

= 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 ==

[[Image:Sequentielle Programme.gif|left]]
Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat. Es wird hier nach dem sogenannten EVA-Prinzip gehandelt. EVA steht für "Eingabe, Verarbeitung, Ausgabe".
{{Absatz}}

== Interruptgesteuerter Programmablauf ==

[[Image:Interrupt Programme.gif|left]]
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.
{{Absatz}}

= 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:

<syntaxhighlight lang="c">
#include <avr/io.h>
</syntaxhighlight>

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:

<syntaxhighlight lang="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
</syntaxhighlight>

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.<ref>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.</ref>

Beispiel:

<syntaxhighlight lang="c">
#include <avr/io.h>

int main()
{
/* 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);

while (1);
}
</syntaxhighlight>

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 unter [[Bitmanipulation]].

Der gcc C-Compiler unterstützt ab Version 4.3.0 Konstanten im Binärformat, z. B. DDRB = 0b00011111. Diese Schreibweise ist jedoch nur in GNU-C verfügbar und nicht in ISO-C definiert. Man sollte sie daher 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.

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

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

Beispiel:
<syntaxhighlight lang="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 */
</syntaxhighlight>

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

Beispiel:
<syntaxhighlight lang="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 */
</syntaxhighlight>

Bei bestimmten AVR Registern mit Bits, die durch Beschreiben mit einer logischen 1 gelöscht werden, muss eine absolute Zuweisung benutzt werden. Ein ODER löscht in diesen Registern ALLE gesetzten Bits!

Beispiel:
<syntaxhighlight lang="c">
#include <avr/io.h>
...
TIFR2 = (1<<OCF2A); // Nur Bit OCF2A löschen
</syntaxhighlight>

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:

<syntaxhighlight lang="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;
//...
}
</syntaxhighlight>

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:

<syntaxhighlight lang="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 (bitweise 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 und/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 mindestens eines der Bits gesetzt
}
// 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 not-Operator
if ( !i ) {
test2();
}
// nochmals verkürzt:
if ( !( PINA & 0x01 ) ) {
test2();
}
</syntaxhighlight>

== 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.

<syntaxhighlight lang="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)) ) {}
...
</syntaxhighlight>

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.

<syntaxhighlight lang="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) ) {}
...
</syntaxhighlight>

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" (Low-Byte) und "H" (High-Byte) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese Register kann dann direkt zugegriffen werden. Dies ist zum Beispiel der Fall für Register wie ADC oder TCNT1.
<syntaxhighlight lang="c">
#include <avr/io.h>
...
uint16_t foo;

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

Bei anderen Registern, wie zum Beispiel Baudraten-Register, liegen High- und Low-Teil nicht direkt nebeneinander im SFR-Bereich, so dass ein 16-Bit Zugriff nicht möglich ist und der Zugriff zusammengebastelt werden muss:

<syntaxhighlight lang="c">
#include <avr/io.h>

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

...
uint16_t baud = F_CPU / (UART_BAUD_RATE * 16L) -1;

UBRRH = (uint8_t) (baud >> 8);
UBRRL = (uint8_t) baud;
...
</syntaxhighlight>

Bei einigen AVR-Typen wie ATmega8 oder ATmega16 teilen sich UBRRH und UCSRC die gleiche Speicher-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:
* Lesezugriff: Erst Low-Byte, dann High-Byte
* 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:

<syntaxhighlight lang="c">
#include <avr/io.h>
#include <util/delay.h>

uint8_t key_pressed (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: */

void foo (void)
{
uint8_t i = key_pressed (&PINB, PB1);
}
</syntaxhighlight>

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.

Siehe auch: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass avr-libc FAQ: "How do I pass an IO port as a parameter to a function?"]

= 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.

Die physischen Ein- und Ausgänge werden bei AVR-Controllern zu logischen Ports gruppiert.

Alle Ports 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:

<syntaxhighlight lang="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
// direkte Zuweisung - standardkonform */
DDRB = 0x1F; /*

// übersichtliche Alternative - Binärschreibweise, aber kein ISO-C
DDRB = 0b00011111;

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

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

<syntaxhighlight lang="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;
</syntaxhighlight>

== 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):

<syntaxhighlight lang="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
</syntaxhighlight>

== 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
<syntaxhighlight lang="c">
#include <avr/io.h>
...
PORTB = 0x04; /* besser PORTB=(1<<PB2) */

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

</syntaxhighlight>
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:

<syntaxhighlight lang="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" */
</syntaxhighlight>

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

<syntaxhighlight lang="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" */
</syntaxhighlight>
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 war:
* 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:

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

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

<syntaxhighlight lang="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 */
}
...
</syntaxhighlight>
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.

<syntaxhighlight lang="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<<PC7); /* Pin PC7 als Eingang */
PORTC |= (1<<PC7); /* internen Pull-Up an PC7 aktivieren */
</syntaxhighlight>

=== Taster und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller, ist zwischen zwei unterschiedliche Methoden zu unterscheiden: ''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.
</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 ü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. Interne Pull-Down-Widerstand sind nicht verfügbar und müssen daher in Form zusätzlicher Bauteile in die Schaltung eingefügt werden.

==== Taster entprellen ====

Siehe: ''[[Entprellung#Warteschleifen-Verfahren|Entprellung: Warteschleifen-Verfahren]]

= 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. Außerdem sind die Funktionen der Bibliothek wirklich getestet.

Einfach!? Schon, aber während gewartet wird, macht der µC nichts anderes mehr (abgesehen von möglicherweise auftretenden Interrupts, falls welche aktiviert sind). 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.

Eine weitere Einschränkung liegt darin, daß sie möglicherweise länger warten, als erwartet, nämlich in dem Fall, daß Interrupts auftreten und die _delay...()-Funktion unterbrechen. Genau genommen warten diese nämlich nicht eine bestimmte Zeit, sondern verbrauchen eine bestimmte Anzahl von Prozessortakten. Die wiederum ist so bemessen, daß ohne Unterbrechung durch Interrupts die gewünschte Wartezeit erreicht wird.
Wird das Warten aber durch eine oder mehrere ISR unterbrochen, die zusammen 1% Prozessorzeit verbrauchen, dann dauert das Warten etwa 1% länger. Bei 50% Last durch die ISR dauert das Warten doppelt solange wie gewünscht, bei 90% zehnmal solange...

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

== avr-libc Versionen bis 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,4µs 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
<syntaxhighlight lang="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;
}
</syntaxhighlight>

== avr-libc Versionen ab 1.7 ==

_delay_ms() kann mit einem Argument bis 6553,5 ms (= 6,5535 Sekunden) benutzt werden. Es ist nicht möglich, eine Variable als Argument zu übergeben. 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
<syntaxhighlight lang="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;
}
</syntaxhighlight>

Trick zur Übergabe einer Variablen an _delay_ms():
<syntaxhighlight lang="c">
#include <avr/io.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>

void sleep ( uint8_t ms )
{
for(; ms > 0; ms--) _delay_ms(1);
}

int main( void )
{
int x = 0; // Variable als Wartezeit erstellen
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z.B. angeschlossene LED
sleep(x);
x++;
}
return 0;
}
</syntaxhighlight>

Die _delay_ms() und die _delay_us aus '''avr-libc 1.7.0''' sind fehlerhaft. _delay_ms () läuft 4x schneller als erwartet. Abhilfe ist eine korrigierte Includedatei: [http://www.mikrocontroller.net/topic/196738#1943039]

= 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.

Tritt ein Interrupt auf, unterbricht (engl. interrupts) der Controller die Verarbeitung des Hauptprogramms und verzweigt zu einer Interruptroutine. Das Hauptprogramm wird also beim Eintreffen eines Interrupts unterbrochen, die Interruptroutine ausgeführt und danach erst wieder das Hauptprogramm an der Unterbrechungsstelle fortgesetzt (vgl. die Abbildung).

Um Interrupts verarbeiten zu können, ist folgendes zu beachten:

* Für jede aktivierte Interruptquelle ist eine Funktion zu programmieren, in der die beim Auftreten des jeweiligen Interrupts erforderlichen Verarbeitungsschritte enthalten sind. Für diese Funktion existieren verschiedene Bezeichnungen. Üblich sind die englischen Begriffe Interrupt-Handler oder Interrupt-Service-Routinen (ISR), man findet aber auch die Bezeichnungen Interruptverarbeitungs- oder -behandlungsroutine oder auch kurz Interruptroutine. Zum Beispiel wird üblicherweise in der ISR zur Verarbeitung des Empfangsinterrupts eines UARTs (UART-RX Interrupt) das empfangene Zeichen in einen Zwischenspeicher (FIFO-Buffer) kopiert, dessen Inhalt später von anderen Programmteilen geleert wird. Sofern der Zwischenspeicher ausreichend groß ist, geht also kein Zeichen verloren, auch wenn im Hauptprogramm zeitintensive Operationen durchgeführt werden.
* Die benötigten Interrupts sind in den jeweiligen Funktionsbausteinen einzuschalten. Dies erfolgt über das jeweilige Aktivierungsbit (Interrupt Enable) in einem der Hardwareregister (z.B. RX(Complete)Interrupt Enable eines UARTs)
* Sämtliche Interrupts werden über einen weiteren globalen Schalter aktiviert und deaktiviert. Zur Verarbeitung der Interrupts ist dieser Schalter zu aktivieren (sei(), siehe unten).

Alle Punkte sind zu beachten. Fehlt z.B. die globale Aktivierung, werden Interruptroutinen auch dann nicht aufgerufen, wenn sie im Funktionsbaustein eingeschaltet sind und eine Behandlungsroutine verhanden ist.

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 Microcontroller-Typen. Im Zweifel hilft ein Blick ins Datenblatt ("Interrupt Vectors").

== Register ==

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

{| class="wikitable"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''a'''sk''' Register. 

{| 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-Bedingung, entsprechend der Konfiguration, als eingetreten 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-Bedingung, entsprechend der Konfiguration, als eingetreten 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 über den 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 avr-gcc ==



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

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

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

<syntaxhighlight lang="c">
sei();
</syntaxhighlight>

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

<syntaxhighlight lang="c">
cli();
</syntaxhighlight>

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:

<syntaxhighlight lang="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!
//...

}
</syntaxhighlight>


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]].)

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

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.

<syntaxhighlight lang="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)

//...
</syntaxhighlight>


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

<syntaxhighlight lang="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...
</syntaxhighlight>

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.

<syntaxhighlight lang="c">
#include <avr/interrupt.h>

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

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 durch Rekursion 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:

<syntaxhighlight lang="c">
#include <avr/interrupt.h>

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

<<Deaktiviere 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>>
}
</syntaxhighlight>
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.

<syntaxhighlight lang="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" */
}
}
//...
}
</syntaxhighlight>

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:

<syntaxhighlight lang="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
}
//...
</syntaxhighlight>

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.

<syntaxhighlight lang="c">
volatile uint8_t *a; // das Ziel von a ist volatile

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

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 (außerhalb 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:

<syntaxhighlight lang="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;
//...
}
</syntaxhighlight>

Die avr-libc bietet ab Version 1.6.0(?) einige Hilfsfunktionen/Makros, mit der im Beispiel oben gezeigten Funktionalität, die zusätzlich auch sogenannte [http://en.wikipedia.org/wiki/Memory_barrier memory barriers] beinhalten. Diese stehen nach #include <util/atomic.h> zur Verfügung.
<syntaxhighlight lang="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;
}

//...
</syntaxhighlight>

* 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:

<syntaxhighlight lang="c">
#include <avr/io.h>

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

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

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 Unterbrechungen 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 Unterbrechungen. 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 auf '''1''', PORTA ist danach 0b0000000'''1'''. 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

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sogenannten [[Sleep Mode |''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).

<syntaxhighlight lang="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
...
}
}
</syntaxhighlight>

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():

<syntaxhighlight lang="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
...
</syntaxhighlight>

== 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 (SLEEP_MODE_IDLE): Die CPU kann durch SPI, USART, Analog Comperator, ADC, TWI, Timer, Watchdog und irgendeinen anderen Interrupt wieder aufgeweckt werden.

;ADC Noise Reduction Mode (SLEEP_MODE_ADC): 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 (SLEEP_MODE_PWR_DOWN): 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 (SLEEP_MODE_PWR_SAVE): 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 (SLEEP_MODE_STANDBY, SLEEP_MODE_EXT_STANDBY): 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'') sind Variablen, die die Adresse von Daten oder Funktionen enthalten und belegen 16 Bits. Die Größe hängt mit dem adressierbaren Speicherbereich zusammen und der 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.

Siehe auch:
* [[Binäre Daten zum Programm hinzufügen]]
== 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():
<syntaxhighlight lang="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);
}
</syntaxhighlight>

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 erst ab Version 4.7 "transparent" möglich. Um Daten aus dem Flash zu lesen, muss die AVR-Instruktion LPM (''load from program memory'') erzeugt erzeugt werden, bei Controllern mit mehr als 64kiB Flash auch ELMP. Zum Erzeugen dieser Instruktionen gibt es die im folgenden dargestellten zwei Wege.

=== progmem und pgm_read_xxx ===

→ [http://nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html avr-libc: Doku zu avr/pgmspace.h]

<tt>progmem</tt> ist ein AVR-spezifisches GCC-Attribut, mit dem eine Variablendeklaration im ''static storage''<ref>Variablen der Speicherklasse ''static storage'' haben eine unbegrenzte Lebensdauer. Beispiel für solche Variablen sind globale Variablen, aber auch static-Variablen innerhalb einer Funktion gehören dazu. Beispiele für Variablen, die nicht ''static storage'' sind: auto-Variablen ("normale" lokale Variablen), register-Variablen, durch malloc geschaffene Objekte, etc.</ref> markiert werden kann:
<syntaxhighlight lang="c">
const int value __attribute__((progmem)) = 1;
</syntaxhighlight>

Effekt ist, dass die so markierte Variable nicht im RAM sondern im Flash angelegt wird. Wird durch "normalen" C-Code auf solch eine Variable zugegriffen, wird jedoch aus dem RAM gelesen und nicht aus dem Flash!

Zum Lesen aus dem Flash stellt die avr-libc daher zahlreiche Makros zur Verfügung. Zudem wird das Makro <tt>PROGMEM</tt> definiert, das etwas Tipparbeit spart:

<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

const int value PROGMEM = 1;
</syntaxhighlight>

<tt>progmem</tt> funktioniert im Wesentlichen wie ein Section-Attribut, das die Daten in der Section <tt>.progmem.data</tt> ablegt. Im Gegensatz zum Section-Attribut werden jedoch noch weitere Prüfungen unternommen, ab avr-gcc 4.6 etwa muss die entsprechende Variable <tt>const</tt> sein.

==== Integer und float ====

Zum Lesen von Skalaren stellt die avr-libc folgende Makros zu Verfügung, die jeweils ein Argument erhalten: Die 16-Bit Adresse des zu lesenden Wertes<ref>Damit ist der mögliche Speicherbereich für Flash-Konstanten auf 64kiB begrenzt. Einige pgmspace-Funktionen ermöglichen den Lesezugriff auf den gesamten Flash-Speicher, intern via Assembler-Anweisung ELPM. Die Initialisierungswerte des Speicherinhalts jenseits der 64kiB-Marke müssen dann jedoch auf anderem Weg angelegt werden, d.h. nicht per PROGMEM. Evtl. eigene Section und Linker-Optionen. Alt und nicht ganz korrekt: Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kiB Flash bei Controllern mit mehr als 64kiB.</ref>

:{| {{Tabelle}}
|+ Übersicht der <tt>pgm_read</tt> Funktionen aus dem Header <tt>avr/pgmspace.h</tt> der avr-libc
|-
! Gelesener Wert || <tt>pgm_read_xxx</tt> || Anzahl Bytes
|-
| <tt>uint8_t</tt> || <tt>pgm_read_byte</tt> || 1
|-
| <tt>uint16_t</tt> || <tt>pgm_read_word</tt> || 2
|-
| <tt>uint32_t</tt> || <tt>pgm_read_dword</tt> || 4
|-
| <tt>float</tt> || <tt>pgm_read_float</tt><ref>ab avr-libc 1.7.0</ref> || 4
|}

Soll ein Zeiger gelesen werden, so verwendet man <tt>pgm_read_word</tt> und castet das Ergebnis zum gewünschten Zeiger-Typ.

;Beispiele:

<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

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

/* int-Array */
const int anArray[] PROGMEM = { 18, 3 ,70 };

void foo (void)
{
/* Zeiger */
static const uint8_t* const aPointer PROGMEM = &aByte;

uint8_t a = pgm_read_byte (&aByte);
int a2 = (int) pgm_read_word (&anArray[2]);
const uint8_t* p = (const uint8_t*) pgm_read_word (&aPointer);
}
</syntaxhighlight>

==== Blöcke ====

In den Flash-Funktionen der avr-libc sind keine der pgm_read_xxxx Nomenklatur folgenden Funktionen, die Speicherblöcke auslesen oder vergleichen. Die enstprechende Funktionen sind Varianten von <tt>memcpy</tt>, <tt>memcmp</tt> und heißt <tt>memcpy_P</tt>, <tt>memcmp_P</tt>, usw. Für weitere Funktionen und deren Prototypen siehe die Dokumentation der avr-libc.

==== Strings ====

Strings sind in C nichts anderes als eine Abfolge von Zeichen und einem <tt>'\0'</tt> als Stringende. Der prinzipielle Weg ist daher identisch zum Lesen von Bytes, wobei auf die [[FAQ#Wie funktioniert String-Verarbeitung in C?|Besonderheiten von Strings]] wie 0-Terminierung geachtet werden muss.

<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

size_t my_string_length (const char* addr)
{
size_t length = 0;

while (pgm_read_byte (addr++))
{
len++;
}
return length;
}
</syntaxhighlight>

Zur Unterstützung des Programmierers steht das Repertoire der str-Funktionen auch in jeweils eine Variante zur Verfügung, die mit dem Flash-Speicher arbeiten kann. Die Funktionsnamen tragen den Suffix <tt>_P</tt>. Darüber hinaus gibt es das Makro <tt>PSTR</tt>, das ein String-Literal im Flash-Speicher ablegt und die Adresse des Strings liefert:

<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

/* Liefert true zurück, wenn string_im_ram gleich "Hallo Welt" ist. */
int foo (const char* string_im_ram)
{
return strcmp_P (string_im_ram, PSTR ("Hallo Welt"));
}
</syntaxhighlight>

Zu beachten ist, dass <tt>PSTR</tt> nur innerhalb von Funktionen verwendet werden kann.

; Array aus Strings:

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 gewünschten Elements aus dem Array im Flash-Speicher gelesen, die im Anschluss dazu genutzt wird, um auf das Element (den String) selbst zuzugreifen.

<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

static const char str1[] PROGMEM = "Hund";
static const char str2[] PROGMEM = "Katze";
static const char str3[] PROGMEM = "Maus";

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

// Liest den i-ten String von array[] und kopiert ihn ins RAM nach buf[]
void read_string (char* buf, size_t i)
{
// Lese die Adresse des i-ten Strings aus array[]
const char *parray = (const char*) pgm_read_word (&array[i]);

// Kopiere den Inhalt der Zeichenkette vom Flash ins RAM
strcpy_P (buf, parray);
}
</syntaxhighlight>

Eine weitere Möglichkeit ist, die Strings in einem 2-dimensionalen char-Array abzulegen anstatt deren Adresse in einem 1-dimensionalen Adress-Array zu speichern.

Vorteil ist, dass der Code einfacher wird. Nachteil ist, dass bei unterschiedlich langen Strings Speicherplatz verschwendet wird, weil sich die Array-Dimension and der Länge des längsten Strings orientieret. Bei in etwa gleich langen Strings kann es aber sogar Speicherplatz sparen, denn es die Adressen der einzelnen Strings müssen nicht abgespeichert werden.<ref>In unserem Hund-Katze-Maus Beispiel belegt die erste Variante 22 Bytes Daten und 18 Bytes Code, die zweite Variante mit 2-dimensionalem Array belegt 18 Bytes Daten und 20 Bytes Code. Gemessen wurde mit avr-gcc 4.8 -Os für ATmega8.</ref>

<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

// Die "6" ist 1 plus die Länge des längsten Strings ("Katze")
const char array[][6] PROGMEM =
{
"Hund", "Katze", "Maus"
};

// Liest den i-ten String von array[] und kopiert ihn ins RAM nach buf[]
void read_string (char* buf, size_t i)
{
// Kopiere den Inhalt der i-ten Zeichenkette vom Flash ins RAM
strcpy_P (buf, array[i]);
}
</syntaxhighlight>

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

==== 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 sieht 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, dann weiß die Funktion nicht, ob die Adresse in den Flash-Speicher oder das RAM zeigt. Weder aus dem Pointer-Wert, also dem Zahlenwert, noch aus dem "const" kann auf den Ort der Ablage geschlossen werden.

Einige AVR-Compiler bilden die Harvard-Architektur ab, indem sie in einen Pointer nicht nur die Adresse speichern, sondern auch den Ablageort wie ''Flash'' oder ''RAM''. In einem Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben.

Dies hat jedoch auch Nachteile, denn bei jedem Zugriff über einen Zeiger muss zur ''Laufzeit'' entschieden werden, wie der Zugriff auszuführen ist und entsprechend länglicher und langsamer wird der erzeugte Code.

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

==== Variablenzugriff >64kB ====

Die Zeiger beim avr-gcc sind nur 16 Bit breit, können somit also nur 64kiB Datenspeicher adressieren. Als Funktionspointer können sie beim AVR bis zu 128 kiB Programmspeicher adressieren, weil FUnktionsadressen immer gerade sind. Für den Datenzugriff jenseits von 64kiB stellt die AVR-Libc die Funktionen <tt>pgm_read_xxx_far</tt> zur Verfügung. Diese Funktionen erwarten einen 32-Bit Pointer auf die Daten. Unverständlicherweise gibt es aber in der AVR-Libc keine Funktion, um diesen 32-Bit Pointer zu erhalten. Hier schafft ein eigenes Makro Abhilfe:

<syntaxhighlight lang="c">
#include <avr/io.h>
#include <avr/pgmspace.h>

//====================================================================
// Macro to access strings defined in PROGMEM above 64kB
//--------------------------------------------------------------------
#define FAR(var) \
({ uint_farptr_t tmp; \
__asm__ ( \
"ldi %A0, lo8(%1)" "\n\t" \
"ldi %B0, hi8(%1)" "\n\t" \
"ldi %C0, hh8(%1)" \
: "=d" (tmp) \
: "i" (&(var))); \
tmp; \
})
//-------------------------------------------------------------------

//===================================================================
// Define a section above 64kiB (FAR_SECTION)
// and add the required linker argument below
// -Wl,--section-start=.far_section=0x10000
//--------------------------------------------------------------------
#define FAR_SECTION __attribute__((__section__(".far_section")))
//--------------------------------------------------------------------

//====================================================================
// Just a Sample
//--------------------------------------------------------------------

char MyString[] FAR_SECTION = "Hier liegt mein FAR-Teststring!";
char MyBmp64[] FAR_SECTION = {0xAA,0xBB,0xCC,0xDD,0xEE,0xFF,0x00};

int main(void)
{
char MyChar;
DDRC = 0xFF;
do
{
MyChar = pgm_read_byte_far(FAR(MyBmp64));
PORTC = MyChar;
}
while(MyChar);
}
</syntaxhighlight>

D.h. man muss
* Das Makro FAR im Quellcode einfügen
* Die Definition der neuen Sektion FAR_SECTION einfügen
* Die Variablen mit dieser Sektion kennzeichnen
* Dem Linker mittels Kommandozeilenoption diese Sektion mitteilen

Der Zugriff auf diese Variablen kann nur mittels direkter Pointerarithmetik erfolgen, eine Indizierung von Arrays mit variablem Index ist nicht möglich.

<syntaxhighlight lang="c">
int n=3;
MyChar = pgm_read_byte_far(FAR(MyBmp64)+n);
</syntaxhighlight>

=== __flash und Embedded-C ===

Ab Version 4.7 unterstützt avr-gcc ''Adress-Spaces'' gemäß dem Embedded-C Dokument ISO/IEC TR18037. Der geläufigste Adress-Space ist <tt>__flash</tt>, der im Gegensatz zu <tt>progmem</tt> kein GCC-Attribut ist, sondern ein Qualifier und damit ähnlich verwendet wird wie <tt>const</tt> oder <tt>volatile</tt>.

GCC kennt keine eigene Option zum Aktivieren von Embedded-C, es wird als GNU-C Erweiterung behandelt. Daher müssen C-Module, die Address-Spaces verwenden, mit <tt>-std=gnu99</tt> compiliert werden.

<syntaxhighlight lang="c">
static const __flash int value = 10;

int get_value (void)
{
return value;
}
</syntaxhighlight>

# Im Gegensatz zu <tt>progmem</tt> sind keine speziellen Bibliotheksfunktionen oder -makros für den Zugriff mehr notwendig: Der Code zum Lesen der Variable ist "normales" C.
# Die Variable wird im richtigen Speicherbereich (Flash) angelegt.
# <tt>__flash</tt> ist nur zusammen mit read-only Objekten oder Zeigern, d.h. nur zusammen mit <tt>const</tt>, erlaubt.
# Zugriffe wie im obigen Beispiel können (weg)optimiert werden. Das Beispiel entspricht einem "<tt>return 10</tt>". Es besteht keine Notwendigkeit, für <tt>value</tt> überhaupt Flash-Speicher zu reservieren.

Auch Zeiger-Indirektionen sind problemlos möglich. Zu beachten ist, dass <tt>__flash</tt> auf der richtigen Seite des "<tt>*</tt>" in der Zeigerdeklaration bzw. -definition steht:
* '''Rechts vom <tt>*</tt>:''' Der Zeiger selbst liegt im Flash
* '''Links vom <tt>*</tt>:''' Der Zeiger enthält eine Flash-Adresse

<syntaxhighlight lang="c">
// val ist eine Variable im Flash
const __flash int val = 42;

// pval liegt auch im Flash und enthält die Adresse von val
const __flash int* const __flash pval = &val;

char get_val (void)
{
// liest den Wert von val über die in pval abgelegte Adresse
return *pval;
}
</syntaxhighlight>

==== Blöcke ====

Um Speicherbereiche vom Flash in den RAM zu kopieren, gibt es zwei Möglichkeiten: Zum einen können wie bei <tt>progmem</tt> beschreiben die Funktionen der avr-libc wie <tt>memcpy_P</tt>, <tt>memcmp_P</tt>, <tt>movmem_P</tt>, etc. verwendet werden:
<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

// Eine Datenstruktur
typedef struct
{
int id;
char buf[10];
} data_t;

extern void uart_send (const void*, size_t);

void send_data (const __flash data_t *pdata)
{
// buf wird auf dem Stack angelegt
data_t buf;

// Kopiere Daten vom Flash nach buf ins RAM
memcpy_P (&buf, pdata, sizeof (data_t));

// Sende die Daten in buf
uart_send (&buf, sizeof (data_t));
}
</syntaxhighlight>

Zum anderen kann eine Struktur auch über direktes Kopieren ins RAM geladen werden:

<syntaxhighlight lang="c">
#include <stdlib.h>

// Eine Datenstruktur
typedef struct
{
int id;
char buf[10];
} data_t;

extern void uart_send (const void*, size_t);

void send_data (const __flash data_t *pdata)
{
// Kopiere Daten ins RAM. buf wird auf dem Stack angelegt
const data_t buf = *pdata;

// Verwendet die Daten in buf
uart_send (&buf, sizeof (data_t));
}
</syntaxhighlight>

==== Strings ====

Natürlich können auch Strings im Flash abgelegt werden und auch mit Funktionen wie <tt>strcpy_P</tt> aus der avr-libc verarbeitet werden. Zudem ist es möglich, Flash-Zeiger mit der Adresse eines String-Literals zu initialisieren:
<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

#define FSTR(X) ((const __flash char[]) { X } )

const __flash char * const __flash array[] =
{
FSTR ("Hund"), FSTR ("Katze"), FSTR ("Maus")
};

size_t get_len (uint8_t tier)
{
return strlen_P (array[tier]);
}
</syntaxhighlight>

Leider sieht der Embedded-C Draft nicht vor, String-Literale direkt in einem anderen Adress-Space als ''generic'' anzulegen, so dass hier der Umweg über <tt>FSTR</tt> genommen werden muss. Dieses Konstrukt ist nur ausserhalb von Funktionen möglich und kann daher nicht als Ersatz für <tt>PSTR</tt> aus der avr-libc dienen.

Soll <tt>array</tt> ein 2-dimensonales Array sein anstatt ein 1-dimensionales Array von Zeigern, dann geht das ohne große Verrenkungen:

<syntaxhighlight lang="c">
// Die 6 ergibt sich aus 1 plus der Länge des längsten Strings "Katze"
const __flash char array[][6] =
{
"Hund", "Katze", "Maus"
};
</syntaxhighlight>

Weiters besteht die Möglichkeit, <tt>array</tt> analog anzulegen, wie man es mit <tt>PROGMEM</tt> machen würde: Jeder String wird explizit angelegt und seine Adresse bei der Initialisierung von <tt>array</tt> verwendet. Dies entspricht dem ersten Beispiel eines 1-dimensionalen Zeigerarrays:

<syntaxhighlight lang="c">
static const __flash char strHund[] = "Hund";
static const __flash char strKatze[] = "Katze";
static const __flash char strMaus[] = "Maus";

const __flash char * const __flash array[] =
{
strHund, strKatze, strMaus
};
</syntaxhighlight>

==== Casts ====

Embedded C fordert, dass zwei Adress-Spaces entweder disjunkt sind – d.h. sie enthalten keine gemeinsamen Adressen – oder aber ein Space komplett im anderen enthalten ist, also eine Teilmengen-Beziehung besteht. Die Adress-Spaces von avr-gcc sind so implementiert, dass jeder Space Teilmenge jedes anderes ist. Zwar haben Spaces wie RAM und Flash physikalisch keinen Speicherbereich gemein, allerdings ermöglicht diese Implementierung das Casten von Zeigern zu unterschiedlichen Adress-Spaces<ref>Im Gegensatz zu einem Attribute wie <tt>progmem</tt> ist ein (Adress Space) Qualifier Teil des Zeiger-Typs.</ref>:

<syntaxhighlight lang="c">
#include <stdbool.h>

char read_char (const char *address, bool data_in_flash)
{
if (data_in_flash)
return *(const __flash char*) address;
else
return *address;
}
</syntaxhighlight>

Der Cast selbst erzeugt keinen zusätzlichen Code, da eine RAM-Adresse und eine Flash-Adresse die gleiche Binärdarstellung haben. Allerdings wird über den nach <tt>__flash</tt> gecasteten Zeiger anders zugegriffen, nämlich per LPM.

==== Jenseits von __flash ====

Ausser <tt>__flash</tt> gibt es auch folgende Address-Spaces:

* <tt>__flash</tt>''N'', ''N'' = 1..5, sind fünf weitere Spaces, die analog zu <tt>__flash</tt> funktionieren und deren Zeiger ebenfalls 16 Bit breit sind. avr-gcc erwartet, dass die zugehörigen Daten, welche in die Section <tt>.progmem</tt>''N''<tt>.data</tt> abgelegt werden, so lokatiert sind, dass das high-Byte der Adresse (Bits 16..23) gerade ''N'' ist. Dies wird in Binutils noch nicht unterstützt<ref>[http://sourceware.org/PR14406 Binutils PR14406]: Support .progmem<N>.data sections to work with GCC's [http://gcc.gnu.org/PR49868 PR49868].</ref> (Stand Binutils 2.23) Die Unterstützung kann durch ein eigenes Linker-Skript erhalten werden, dass diese Sections wie vom Compiler erwartet lokatiert.
* Address-Space <tt>__memx</tt> implementiert 3-Byte Zeiger und unterstützt Lesen über 64KiB-Segmentgrenzen hinweg. Das MSB (Bit 23) gibt dabei an, ob der Zeiger eine Flash-Adresse enthält (Bit23 = 0) oder eine RAM-Adresse (Bit23 = 1), was folgenden Code erlaubt:

:{|
|-
|<syntaxhighlight lang="c">
const __memx int a_flash = 42;
const int a_ram = 100;

static int get_a (const __memx int* pa)
{
return *pa;
}

int main (void)
{
return get_a (&a_flash) + get_a (&a_ram);
}</syntaxhighlight>
|}Dies bedeutet, dass erst zur ''Laufzeit'' entschieden werden kann, ob aus dem RAM oder aus dem Flash gelesen werden soll, was <tt>__memx</tt> im Vergleich zu den anderen Address-Spaces langsamer macht. Ausserdem ist zu beachten, dass <tt>__memx</tt>-Zeiger zwar 24-Bit Zeiger sind, die zugrundeliegende Adress-Arithmetik jedoch gemäß dem C-Standard erfolgt, also als 16-Bit Arithmetik.

=== __flash, progmem und Portierbarkeit ===

Da ab er aktuellen Compilerversion 4.7 sowohl <tt>__flash</tt> als auch <tt>PROGMEM</tt> und die <tt>pgm_read</tt>-Funktionen zur Verfügung stehen, ergibt sich die Frage, welche Variante "besser" ist und wie zwischen ihnen hin- und her zu portieren ist.

Zunächst sei erwähnt, dass <tt>__flash</tt> kein Ersatz für <tt>PROGMEM</tt> ist, sondern lediglich eine Alternative dazu. Das "alte" progmem wird weiterhin mir gleicher Semantik unterstützt, so dass alter Code ohne Änderungen mit den neueren Compilerversionen übersetzbar bleibt.

Von der Codegüte her dürften sich keine großen Unterschiede ergeben. Es ist nicht zu erwarten, dass die eine oder die andere Variante wesentlich besseren oder schlechteren Code erzeugt — von einer Ausnahme abgesehen: Der Werte beim Zugriff ist zur Compilezeit bekannt und kann daher eliminiert werden.
<syntaxhighlight lang="c">
static const __flash char x[] = { 'A', 'V', 'R' };

char foo (void)
{
return x[2];
}
</syntaxhighlight>
Dies wird übersetzt wie "<tt>return 'R';</tt>", und das Array <tt>x[]</tt> kann komplett wegoptimiert werden und entfallen.

==== progmem → __flash ====

Portierung in diese Richtung bedeutet, alten Code anzupassen. Zwingend ist die Portierung nicht, da <tt>progmem</tt> weiterhin unterstützt wird.
Allerdings ist eine Quelle mit <tt>__flash</tt> besser lesbar, denn der Code wird von den <tt>pgm_read</tt>-Funktionen befreit, die vor allem bei Mehrfach-Indirektion den Code ziemlich verunstalten und unleserlich machen können.
Weiterer Vorteil von <tt>_flash</tt> ist, daß eine striktere Typprüfung erfolgen kann.

Eine Portierung wird man in zwei Schritten vornehmen:

;1. Definitionen von Flash-Variablen werden angepasst:

Vorher:
:{|
|-
|<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

static const char hund[] PROGMEM = "Hund";
static const char katze[] PROGMEM = "Katze";
static const char maus[] PROGMEM = "Maus";

const char * const tier[] PROGMEM =
{
hund, katze, maus
};
</syntaxhighlight>
|}

Nachher:
:{|
|-
|<syntaxhighlight lang="c">
static const __flash char hund[] = "Hund";
static const __flash char katze[] = "Katze";
static const __flash char maus[] = "Maus";

const __flash char * const __flash tier[] =
{
hund, katze, maus
};
</syntaxhighlight>
|}

Der Header <tt>avr/pgmspace.h</tt> wird nicht mehr benötigt. Im Gegensatz zu <tt>progmem</tt> müssen Qualifier immer links von der definierten Variablen stehen; bei Attributen wie <tt>progmem</tt> ist das mehr oder weniger egal.

Nachdem diese Anpassung erfolgreich abgeschlossen ist, folgt Schritt

; 2. Der Code wird von <tt>pgm_reg</tt>-Aufrufen bereinigt:

Vorher:
:{|
|-
|<syntaxhighlight lang="c">
#include <avr/pgmspace.h>

extern const char *tier[];

char first_letter (uint8_t i)
{
const char* ptier = (const char*) pgm_read_word (&tier[i]);
return (char) pgm_read_byte (&ptier[0]);
}
</syntaxhighlight>
|}

Nachher:
:{|
|-
|<syntaxhighlight lang="c">
#include <stdint.h>

extern const __flash char * const __flash tier[];

char first_letter (uint8_t i)
{
return tier[i][0];
}
</syntaxhighlight>
|}

==== __flash → progmem ====

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option – auch bekannt als [[Bootloader]]-Support – können Teile des Flash-Speichers vom Anwendungsprogramm beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktion in einem besonderen Speicherbereich, der Boot-Section des Programmspeichers/Flash, abgelegt ist.

Bei einigen 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]

== EEPROM ==

Möchte man Werte aus einem Programm heraus so speichern, dass sie auch nach dem Abschalten der Versorgungsspannung noch vorhanden sind und nach dem Wiederherstellen der Versorgungsspannung bei erneutem Programmstart wieder zur Verfügung stehen, dann benutzt man das EEPROM.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h der avr-libc definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit), Fließkommawerte (32-Bit, single-precision, float) und Datenblöcke geschrieben und gelesen werden.

Diese Funktionen kümmern sich auch um diverse Details, die bei der Benutzung des EEPROMS normalerweise notwendig sind:
* EEPROM Operationen sind im Vergleich relativ langsam. Man muss daher darauf achten, dass eine vorhergehende Operation abgeschlossen ist, ehe die nächste Operation mit dem EEPROM gestartet wird. Die in der avr-libc implementierten Funktionen aus eeprom.h berücksichtigten dies. Soll beim Aufruf einer EEPROM-Funktion sicher gestellt werden, dass diese nicht intern in einer Warteschleife auf den Abschluss der vorherigen Operation wartet, kann vorher per eeprom_is_ready testen, ob der Zugriff auf den EEPROM-Speicher sofort möglich ist.
* Es ist darauf zu achten, dass die EEPROM Funktionen nicht durch einen Interrupt unterbrochen werden können. Einige Phasen des Zugriffs sind zeitkritisch und müssen in einer definierten Anzahl Takte durchgeführt werden. Durch einen unterbrechenden Interrupt würde diese Restriktion nicht mehr eingehalten. Auch dieses Detail wird von den avr-libc Funktionen berücksichtigt, so dass man sich als C Programmierer nicht darum kümmern muss. Innerhalb der Funktionen werden Interrupts vor der "EEPROM-Sequenz" global deaktiviert und im Anschluss, falls vorher auch schon eingeschaltet, wieder aktiviert.

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 gesamten EEPROM-Speicher, erreichen. Auf jeden Fall sollte man aber eine Abschätzung über die zu erwartende Lebensdauer des EEPROM durchführen. Wird ein Wert im EEPROM im Durchschnitt nur einmal pro Woche verändert, wird die garantierte Anzahl der Schreibzyklen innerhalb der voraussichtlichen Verwendungszeit des Controllers wahrscheinlich nicht erreicht. In diesem Fall lohnt es sich daher nicht, erweiterte Programmfunktionen zu implementieren, mit denen die Anzahl der Schreibzugriffe minimiert wird.

Eine weitere Möglichkeit Schreibzyklen einzusparen besteht darin, dass geprüft wird, ob im EEPROM bereits der zu speichernde Wert enthalten ist und nur veränderte Werte zu schreiben. In aktuelleren Versionen der avr-libc sind bereits Funktionen enthalten, die solche Prüfungen enthalten (eeprom_update_*).

Lesezugriffe können beliebig oft durchgeführt werden. Sie unterliegen keinen Einschränkungen in Bezug auf deren Anzahl.

=== EEMEM ===
Um eine Variable im EEPROM anzulegen, stellt die avr-libc das Makro EEMEM zur Verfügung:

<syntaxhighlight lang="c">
#include <stdint.h>
#include <avr/eeprom.h>

/* Byte */
uint8_t eeFooByte EEMEM = 123;

/* Wort */
uint16_t eeFooWord EEMEM = 12345;

/* float */
float eeFooFloat EEMEM;

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

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

Die grundsätzliche Vorgehensweise ist identisch zur Verwendung von PROGMEM. Auch hier erzeugt man sich spezielle attributierte Variablen (EEMEM erledigt das), die vom Compiler/Linker nicht wie normale Variablen behandelt werden. Compiler/Linker kümmern sich zwar darum, dass diesen Variablen eine Adresse zugewiesen wird, diese Adresse ist dann aber die Adresse der 'Variablen' im EEPROM. Um die dort gespeicherten Werte zu lesen bzw. zu schreiben, übergibt man diese Adresse an spezielle Funktionen, die die entsprechenden Werte aus dem EEPROM holen bzw. das EEPROM neu beschreiben.

Die mittels EEMEM erzeugten 'Variablen' sind also mehr als Platzhalter zu verstehen, denn als echte Variablen. Es geht nur darum, im C Programm symbolische Namen zur Verfügung zu haben, anstatt mit echten EEPROM Adressen hantieren zu müssen - etwas das grundsätzlich aber auch genauso gut möglich ist. Nur muss man sich in diesem Fall dann selbst darum kümmern, dass mehrere 'Variablen' ohne Überschneidung im EEPROM angeordnet werden.

=== 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:

<syntaxhighlight lang="c">
#define EEPROM_DEF 0xFF

void eeprom_example (void)
{
uint8_t myByte;

// myByte lesen (Wert = 123)
myByte = eeprom_read_byte (&eeFooByte);

// der Wert 99 wird im EEPROM an die Adresse der
// Variablen eeFooByte geschrieben
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben

myByte = eeprom_read_byte (&eeFooByteArray1[1]);
// myByte hat nun den Wert 3

// Beispiel fuer eeprom_update_byte: die EEPROM-Zelle wird nur
// dann beschrieben, wenn deren Inhalt sich vom Parameterwert
// unterscheidet. In diesem Beispiel erfolgt also kein Schreib-
// zugriff, da die Werte gleich sind.
eeprom_update_byte(&eeFooByte, myByte);

// 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.

uint8_t fooByteDefault = 222;
if ((myByte = eeprom_read_byte (&eeFooByte)) == EEPROM_DEF)
{
myByte = fooByteDefault;
}
}
</syntaxhighlight>

=== Wort lesen/schreiben ===

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

<syntaxhighlight lang="c">
// lesen
uint16_t myWord = eeprom_read_word (&eeFooWord);

// schreiben
eeprom_write_word (&eeFooWord, 2222);
</syntaxhighlight>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen <code>eeprom_read_block()</code> bzw. <code>eeprom_write_block()</code>. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes als <code>size_t</code>.
<syntaxhighlight lang="c">
uint8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

void eeprom_block_example (void)
{
/* 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 mit etwas Absicherung betr. der Länge */
eeprom_read_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer));

/* und nun mit 16-Bit Array */
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));
}
</syntaxhighlight>

=== Fließkommawerte lesen/schreiben ===

In der avr-libc stehen auch EEPROM-Funktionen für Variablen des Typs float (Fließkommazahlen mit "einfacher" Genauigkeit) zur Verfügung.

<syntaxhighlight lang="c">
#include <avr/eeprom.h>

float eeFloat EEMEM = 12.34f;

float void eeprom_float_example(float value)
{
/* float in EEPROM schreiben */
eeprom_write_float(&eeFloat, value);

/* float aus EEPROM lesen */
return eeprom_read_float(&eeFloat);
}</syntaxhighlight>

=== 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. Die übliche Dateiendung ist .eep, Daten im Intel Hex-Format. Damit können 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 [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]].

Der Inhalt der eep-Datei muss ebenfalls zum Mikrocontroller übertragen werden, 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<ref>vgl. Datenblatt Abschnitt Fuse Bits</ref> nicht die korrekten Werte:
; EESAVE = 0 (programmed): Die Daten im EEPROM bleiben erhalten. Werden sie nicht neu geschrieben, so enthält das EEPROM evtl. Daten, die nicht mehr zum Programm passen.
; EESAVE = 1 (unprogrammed): Beim Programmieren werden die Daten im EEPROM gelöscht, also auf 0xff gesetzt.

Als Sicherung kann man im Programm nochmals die Standardwerte vorhalten, beim Lesen auf 0xFF prüfen und gegebenenfalls einen Standardwert nutzen.

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

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

<syntaxhighlight lang="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);
}
</syntaxhighlight>

oder als Makro:

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

Verwendung:

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

=== 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, dass, 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- und 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 anschließend mit einfachen Funktionen zeichenweise ausgegeben. Es liegt in der Verantwortung des Programmierers, genügend Platz im Puffer für die erwarteten Zeichen bereitzuhalten.

<syntaxhighlight lang="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 );
}
</syntaxhighlight>

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.

<syntaxhighlight lang="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
</syntaxhighlight>

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.

= Anmerkungen =
<references/>

= TODO =
* Aktualisierung Register- und Bitbeschreibungen an aktuelle AVR
* "naked"-Funktionen

[[Kategorie:avr-gcc Tutorial| ]]

C ohne Makefile

2014-01-26T21:34:52Z

M-w:

Während es unbedingt zu empfehlen ist, zum Übersetzen von mittelgroßen und großen Projekten Makefiles zu verwenden, kann es bei sehr kleinen Programmen oder für kurze Tests einfacher sein, das Übersetzen und Übertragen direkt per Kommandozeilenbefehl zu erledigen. Hier wird eine Methode vorgestellt, die es erlaubt, mit einer einzigen Datei auszukommen, die gleichzeitig als Batch-Datei fürs Übersetzen und Übertragen sowie als Quellcode-Datei verwendet wird.

Dieser Trick gelingt sehr gut unter Linux (hier: Ubuntu). Wahrscheinlich ist es ohne größere Probleme möglich, eine Windows-Variante zu erstellen (bitte im Artikel ergänzen).

Am besten kann die Funktionsweise an einer Beispiel-Quellcodedatei gezeigt werden (hier für AVR-Mikrocontroller):

<div class="code"><pre>
# /*
M=atmega328p; F=${0:0:-2}; rm -f "$F".hex; avr-gcc -mmcu=$M -Os \
-funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums \
-Wall -Wstrict-prototypes -std=gnu99 "$F".c -o /run/shm/avr.tmp && \
avr-objcopy -O ihex -R .eeprom /run/shm/avr.tmp "$F".hex && \
avrdude -c usbasp -p $M -B 12 -U flash:w:"$F".hex:i; exit; */

#include <avr/io.h>

int main(void) {
DDRB= 0xFF;
while(1) {
PORTB= 0x03;
// ...
}
return 0;
}

</pre></div>

== Voraussetzungen ==

Neben avr-gcc wird im Beispiel das weit verbreitete Programm [[avrdude]] verwendet. Natürlich kann auch jedes andere Programm zur Übertragung der am Ende erzeugten .hex-Datei verwendet werden. Die Kommandozeilen sind dann entsprechend anzupassen.

== Vorbereitung ==

Die oben im Beispiel gezeigten Kopfzeilen (alles oberhalb von "#include") müssen in die eigene Quellcodedatei kopiert werden. Dort müssen sie ebenfalls ganz am Anfang stehen.

In der zweiten Zeile der Quellcodedatei muss der Name des verwendeten Mikrocontrollers auf den tatsächlich verwendeten Typ geändert werden. Der Compiler akzeptiert den Namen nur in Kleinbuchstaben, also zum Beispiel: <tt>attiny13a</tt>

Damit die Quelldatei als Programm startbar ist, muss einmalig das Ausführungsflag gesetzt werden. Unter Ubuntu kann das am einfachsten so erledigt werden: Rechtsklick auf das Symbol der Quelldatei, Menüpunkt "Eigenschaften", Reiter "Zugriffsrechte", Häkchen bei "Datei als Programm ausführen" setzen.

== Arbeitsweise ==

Die Quelldatei mit den oben gezeigten speziellen Kopfzeilen kann ganz wie gewohnt editiert werden. Zum Übersetzen des Programms bewegt man sich per Kommandozeilenbefehl <tt>cd</tt> in dessen Verzeichnis und ruft es auf, als wäre es ein ganz normales Batch-Kommando. Unter Linux so:

<tt>./meinprogramm.c</tt>

Das Programm wird nun übersetzt, in eine .hex-Datei konvertiert und auf den Mikrocontroller übertragen. 

Geht bei der Übersetzung etwas schief, weil das Programm nicht fehlerfrei übersetzt werden konnte, unterbleibt das Übertragen auf den Mikrocontroller, und die Terminal-Ausgabe zeigt die betreffenden Fehlermeldungen.

== Warum funktioniert es, Kommandozeilenbefehle ''und'' Quellcode in derselben Datei zu verwenden? ==

Für das Programmieren von Mikrocontrollern ist die Antwort darauf nicht wichtig, man kann auch einfach hinnehmen, dass es so ist. Für jeden, der sich intensiver mit den Hintergründen beschäftigen will, hier ein paar Sätze zur Erklärung.

Für die Parser von Compiler und Shell ist der jeweils andere Code "unsichtbar":
* Der C-Compiler interpretiert alles, was zwischen /* und */ steht, als Kommentar und ignoriert den betreffenden Abschnitt. Das #-Zeichen zu Beginn der Datei wird in C als Einleitung für eine Präprozessor-Direktive verstanden. Da dem #-Zeichen aber in der gleichen Zeile keine solche Direktive folgt, wird es vom Compiler als "leere Direktive" angesehen und deshalb ignoriert.
* Der Kommandozeileninterpreter betrachtet das #-Zeichen als Einleitung eines Kommentars und ignoriert daher den Rest der ersten Zeile; er macht gleich mit der zweiten Zeile weiter und arbeitet sich bis zum Kommando "exit" durch. Dort beendet er seine Arbeit und ignoriert deshalb den danach folgenden C-Quellcode.

[[Kategorie:avr-gcc Tutorial]]

C ohne Makefile

2014-01-26T21:34:27Z

M-w: Schreibfehler ausgebessert

Während es unbedingt zu empfehlen ist, zum Übersetzen von mittelgroßen und großen Projekten Makefiles zu verwenden, kann es bei sehr kleinen Programmen oder für kurze Tests einfacher sein, das Übersetzen und Übertragen direkt per Kommandozeilenbefehl zu erledigen. Hier wird eine Methode vorgestellt, die es erlaubt, mit einer einzigen Datei auszukommen, die gleichzeitig als Batch-Datei fürs Übersetzen und Übertragen sowie als Quellcode-Datei verwendet wird.

Dieser Trick gelingt sehr gut unter Linux (hier: Ubuntu). Wahrscheinlich ist es ohne größere Probleme möglich, eine Windows-Variante zu erstellen (bitte im Artikel ergänzen).

Am besten kann die Funktionsweise an einer Beispiel-Quellcodedatei gezeigt werden (hier für AVR-Mikrocontroller):

<div class="code"><pre>
# /*
M=atmega328p; F=${0:0:-2}; rm -f "$F".hex; avr-gcc -mmcu=$M -Os \
-funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums \
-Wall -Wstrict-prototypes -std=gnu99 "$F".c -o /run/shm/avr.tmp && \
avr-objcopy -O ihex -R .eeprom /run/shm/avr.tmp "$F".hex && \
avrdude -c usbasp -p $M -B 12 -U flash:w:"$F".hex:i; exit; */

#include <avr/io.h>

int main(void) {
DDRB= 0xFF;
while(1) {
PORTB= 0x03;
// ...
}
return 0;
}

</pre></div>

== Voraussetzungen ==

Neben avr-gcc wird im Beispiel das weit verbreitete Programm [[avrdude]] verwendet. Natürlich kann auch jedes andere Programm zur Übertragung der am Ende erzeugten .hex-Datei verwendet werden. Die Kommandozeilen sind dann entsprechend anzupassen.

== Vorbereitung ==

Die oben im Beispiel gezeigten Kopfzeilen (alles oberhalb von "#include") müssen in die eigene Quellcodedatei kopiert werden. Dort müssen sie ebenfalls ganz am Anfang stehen.

In der zweiten Zeile der Quellcodedatei muss der Name des verwendeten Mikrocontrollers auf den tatsächlich verwendeten Typ geändert werden. Der Compiler akzeptiert den Namen nur in Kleinbuchstaben, also zum Beispiel: <tt>attiny13a</tt>

Damit die Quelldatei als Programm startbar ist, muss einmalig das Ausführungsflag gesetzt werden. Unter Ubuntu kann das am einfachsten so erledigt werden: Rechtsklick auf das Symbol der Quelldatei, Menüpunkt "Eigenschaften", Reiter "Zugriffsrechte", Häkchen bei "Datei als Programm ausführen" setzen.

== Arbeitsweise ==

Die Quelldatei mit den oben gezeigten speziellen Kopfzeilen kann ganz wie gewohnt editiert werden. Zum Übersetzen des Programms bewegt man sich per Kommandozeilenbefehl <tt>cd</tt> in dessen Verzeichnis und ruft es auf, als wäre es ein ganz normales Batch-Kommando. Unter Linux so:

<tt>./meinprogramm.c</tt>

Das Programm wird nun übersetzt, in eine .hex-Datei konvertiert und auf den Mikrocontroller übertragen. 

Geht bei der Übersetzung etwas schief, weil das Programm nicht fehlerfrei übersetzt werden konnte, unterbleibt das Übertragen auf den Mikrocontroller, und die Terminal-Ausgabe zeigt die betreffenden Fehlermeldungen.

== Warum funktioniert es, Kommandozeilenbefehle ''und'' Quellcode in derselben Datei zu verwenden? ==

Für das Programmieren von Mikrocontrollern ist die Antwort darauf nicht wichtig, man kann auch einfach hinnehmen, dass es so ist. Für jeden, der sich intensiver mit den Hintergründen beschäftigen will, hier ein paar Sätze zur Erklärung.

Für die Parser von Compiler und Shell ist der jeweils andere Code "unsichtbar":
* Der C-Compiler interpretiert alles, was zwischen /* und */ steht, als Kommentar und ignoriert den betreffenden Abschnitt. Das #-Zeichen zu Beginn der Datei wird in C als Einleitung für eine Präprozessor-Direktive verstanden. Da dem #-Zeichen aber in der gleichen Zeile keine solche Direktive folgt, wird es vom Compiler als "leere Direktive" angesehen und deshalb ignoriert.
* Der Kommandozeileninterpreter betrachtet das #-Zeichen als Einleitung eines Kommentars und ignoriert daher den Rest der ersten Zeile; er macht gleich mit der zweiten Zeile weiter und arbeitet sich bis zum Kommando "exit" durch. Dort beendet er seine Arbeit und ignoriert deshalb den danach folgenden C-Quellcode.

[[Kategorie:avr-gcc Tutorial]]

C ohne Makefile

2014-01-22T16:21:32Z

M-w: "C ohne Makefile" neu angelegt

{{Warnung|Diese Seite befindet sich im Aufbau. Die genannten Vorschläge sind im experimentellen Stadium und können Fehler enthalten.}}

Während es unbedingt zu empfehlen ist, zum Übersetzen von mittelgroßen und großen Projekten Makefiles zu nutzen, kann es bei sehr kleinen Programmen oder für kurze Tests einfacher sein, das Übersetze und Übertragen per direkt Kommandozeilenbefehl zu erledigen. Hier wird eine Methode vorgestellt, die es erlaubt, mit einer einzigen Datei auszukommen, die gleichzeitig als Batch-Datei fürs Übersetzen und Übertragen sowie als Quellcode-Datei verwendet wird.

Dieser Trick gelingt sehr gut unter Linux (hier: Ubuntu). Wahrscheinlich ist es ohne größere Probleme möglich, eine Windows-Variante zu erstellen; wer mag, bitte ergänzen.

Am besten kann die Funktionsweise an einer Beispiel-Quellcodedatei gezeigt werden (hier für AVR-Mikrocontroller):

<div class="code"><pre>
# /*
M=atmega328p; F=${0:0:-2}; rm -f "$F".hex; avr-gcc -mmcu=$M -Os \
-funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums \
-Wall -Wstrict-prototypes -std=gnu99 "$F".c -o /run/shm/avr.tmp && \
avr-objcopy -O ihex -R .eeprom /run/shm/avr.tmp "$F".hex && \
avrdude -c usbasp -p $M -B 12 -U flash:w:"$F".hex:i; exit; */

#include <avr/io.h>

int main(void) {
DDRB= 0xFF;
while(1) {
PORTB= 0x03;
// ...
}
return 0;
}

</pre></div>

== Voraussetzungen ==

Neben avr-gcc wird im Beispiel das weit verbreitete Programm [[avrdude]] verwendet. Natürlich kann auch jedes andere Programm zur Übertragung der am Ende erzeugten .hex-Datei verwendet werden. Die Kommandozeilen sind dann entsprechend anzupassen.

== Vorbereitung ==

Die oben im Beispiel gezeigten Kopfzeilen (alles über "#include") müssen in die eigene Quellcodedatei kopiert werden. Dort müssen sie ebenfalls ganz am Anfang stehen.

In der zweiten Zeile der Quellcodedatei muss der Name des verwendeten Mikrocontrollers auf den tatsächlich verwendeten Typ geändert werden. Der Compiler akzeptiert den Namen nur in Kleinbuchstaben, also zum Beispiel: <tt>attiny13a</tt>

Damit die Quelldatei als Programm startbar ist, muss einmalig das Ausführungsflag gesetzt werden. Unter Ubuntu kann das am einfachsten so erledigt werden: Rechte Maustaste auf die Datei, Menüpunkt "Eigenschaften", Reiter "Zugriffsrechte", Häkchen bei "Datei als Programm ausführen" setzen.

== Arbeitsweise ==

Die Quelldatei mit den oben gezeigten speziellen Kopfzeilen kann ganz wie gewohnt editiert werden. Zum Übersetzen des Programms bewegt man sich per Kommandozeile in dessen Verzeichnis und ruft es auf, als wäre es ein ganz normales Batch-Kommando. Unter Linux so:

<tt>./meinprogramm.c</tt>

Das Programm wird nun übersetzt, in eine .hex-Datei konvertiert und auf den Mikrocontroller übertragen. 

Geht bei der Übersetzung etwas schief, weil das Programm nicht fehlerfrei übersetzt werden konnte, unterbleibt auch das Übertragen auf den Mikrocontroller.

== Warum funktioniert es, Kommandozeilenbefehle ''und'' Quellcode in derselben Datei zu verwenden? ==

Für das Programmieren von Mikrocontrollern ist die Antwort darauf nicht wichtig, man kann auch einfach hinnehmen, dass es so ist. Für jeden, der sich intensiver mit den Hintergründen beschäftigen will, hier ein paar Sätze zur Erklärung:

Für die Parser von Compiler und Shell ist der jeweils andere Code "unsichtbar".
* Der C-Compiler interpretiert alles, was zwischen /* und */ steht, als Kommentar und ignoriert den betreffenden Abschnitt. Das #-Zeichen zu Beginn wird in C als Einleitung für eine Präprozessor-Direktive verwendet. Da dem #-Zeichen aber keine solche Direktive folgt, wird es vom Compiler als "leere Direktive" angesehen und deshalb ignoriert.
* Der Kommandozeileninterpreter betrachtet das #-Zeichen als Einleitung eines Kommentars und ignoriert daher den Rest der ersten Zeile; er macht gleich mit der zweiten Zeile weiter und arbeitet sich bis zum Kommando "exit" durch. Dort beendet er die Arbeit und ignoriert deshalb den danach folgenden C-Quellcode.

[[Kategorie:avr-gcc Tutorial]]

STM32 für Einsteiger

2013-12-30T22:43:29Z

M-w: /* Kosten */ Preise ergänzt

Immer wiederkehrend hier im Forum "Mit welchem Mikrocontroller anfangen?". Es gibt eine große Auswahl und eben so viele Empfehlungen. In diesem Artikel soll zu erst geholfen werden ob ein STM32-Prozessor mit Cortex-M3/M4 Kern überhaupt der Richtige für den Start ist.
Nicht für jeden ist der STM32 zu empfehlen, denn die Anforderungen und Wünsche die man realisieren möchte, sowie die eigenen Fähigkeiten sind verschieden.

Es werden meist die Prozessoren AVR, PIC, Arduino, MSP430 und STM32 empfohlen. Seltener auch 8051, LPC und M16C. Alle haben Vorzüge und ebenso auch Nachteile.

= Eigene Fähigkeiten und Wünsche =

Dieser Artikel geht davon aus, dass bereits Elektronik Kenntnisse vorhanden sind. Wenn nicht dann sollte man erst einmal den Artikel "[[Absolute Beginner]]" durcharbeiten, sowie die anderen Artikel aus der Kategorie "[http://www.mikrocontroller.net/articles/Kategorie:Grundlagen Grundlagen]"

Zu erst einmal die Randbedingungen, mit der man sich selbst zu erst einmal einschätzen sollte:
{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Fähigkeit || Empfehlung [[STM32]] || Empfehlung [[AVR]] || Empfehlung PIC || Empfehlung [[MSP430]] || Empfehlung Arduino
|-
| Neueinsteiger, kaum Elektronikkenntnisse, noch nie programmiert || align="center"|O || align="center"|O [http://www.rn-wissen.de/index.php/AVR-Einstieg_leicht_gemacht] [http://www.avr-asm-tutorial.net/avr_de/] || align="center"|O [http://www.sprut.de/] || align="center"|O || align="center"|x
|-
| Wunsch ist SD-Card oder Grafik-Display || align="center"|x || align="center"|x || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en537999] [http://www.microchip.com/pagehandler/en-us/technology/graphics/] || align="center"|x || align="center"|x
|-
| Wunsch ist TCP/IP Netzwerk oder Kamera|| align="center"|x || align="center"|O || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2505&param=en535724] || align="center"|O || align="center"|O
|-
| Möchte die Erkenntnisse beruflich nutzen|| align="center"|x || align="center"|x || align="center"|x || align="center"|x || align="center"|-
|-
| Strom sparende Anwendungen|| align="center"|O || align="center"|x [http://www.atmel.com/technologies/lowpower/default.aspx] || align="center"|x [http://www.microchip.com/pagehandler/en-us/technology/xlp/] || align="center"|x || align="center"|-
|-
| Experimentieren mit Multithreading, RTOS, Schedulern || align="center"|x || align="center"|O [http://www.freertos.org/a00098.html] [http://www.femtoos.org/] || align="center"|O [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en531543&redirects=rtos] || align="center"|- || align="center"|-
|-
| Besonders große, speicherintensive Programme z.B. Grafiken, Fonts || align="center"|bis 2MB Flash bis 256kB SRAM || align="center"|bis 256kB Flash bis 16kB SRAM || align="center"|bis 2MB Flash bis 512kB SRAM || align="center"|bis 512KB Flash bis ? kB SRAM || align="center"|bis 256kB Flash bis 16kB SRAM
|-
| Sehr viel PWM mit komplexem Timing || align="center"|x || align="center"|bedingt, AT90Spwm || align="center"|O || align="center"|O || align="center"|-
|-
| Deutschsprachige Community || align="center"|O || align="center"|x || align="center"|O || align="center"|- || align="center"|x
|-
| Anzahl möglicher HW-Breakpoints || align="center"|4 bis 6 || align="center"|2 || align="center"| 1 bis 10 [http://www.microchip.com/stellent/groups/SiteComm_sg/documents/DeviceDoc/en556761.pdf] || align="center"|2 || align="center"|2
|}
* x = ja
* O = Teilweise, Einschränkungen
* - = nicht empfohlen
* ? = Bitte ergänzen

Nur um nicht zu verwirren, auch wenn Teile "nicht empfohlen" sind, heißt dass nicht dass es mit dem Prozessor nicht geht, vielmehr dass es mehr Aufwand ist das zu realisieren oder mehr Einschränkungen hat.

= Unwichtige Randbedingungen =

Oftmals werden fälschlicherweise Argumente für oder gegen eine µC-Familie ausgesprochen, die in der Praxis '''zum Einstieg''' (bei konkreten Anwendungen kann das anders aussehen) eher unwichtig sind.

* Spannungsversorgung 3,3V / 5V
* 8 (z.B. [[AVR]]), 16 (z.B. [[MSP430]]) oder 32 (z.B. [[STM32]]) Bit
* Interrupt System mit mehr oder weniger Features
* Programmiersprache (Assembler, Basic, C, C++, Pascal)
* Assembler verstehen (Sollte nur theoretisch verstanden werden, ein Programm sollte in einer Hochsprache geschrieben sein)
* DIL Gehäuse - steckbretttauglich (STM32-Prozessoren gibt es auch fertig gelötet auf einem steckbretttauglichen Board zum fünffachen Preis vergleichbarer DIL Mikrocontroller)
* Programmieradapter
* zu 90% reicht doch ein kleiner Prozessor ([[AVR]]/PIC) - und für die restlichen kann man immer noch einen großen nehmen. Warum also nicht gleich einen großen nehmen?

= Kosten =

Grobe Abschätzung was das alles denn kosten wird. Hier sind nur einige Beispiele gezeigt (Einzelpreise bei Bezugsquellen in Deutschland).

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Board || [[STM32]] || [[AVR]] || PIC18/24/32 || [[MSP430]] || Arduino
|-
| Demo-Board || align="center"|[http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419] 9..20€ (incl. Programmieradapter und Debugger) || align="center"|5..500€, z.B. Arduino || align="center"| [http://www.microchipdirect.com/ProductDetails.aspx?Catalog=BuyMicrochip&Category=Starter%20Kits&mid=1&lmid=610 durchschnittlich 18€ .. 50€] || align="center"|[http://www.ti.com/tool/msp-exp430fr5739] ~35€ || align="center"|20€
|-
| Steckbrettaugliches Board || align="center"| s.o. oder [http://re.reworld.eu/de/produkte/s64dil-405/index.htm S64DIL-405] 30€ || align="center"|0,6–5€ als einzelner DIP-IC || align="center"|2-5€ als einzelner IC || align="center"|?? || align="center"|??
|-
| Programmieradapter || align="center"| || align="center"| ab 4€ || align="center"| || align="center"| || align="center"|
|-
| Programmieradapter mit Debugger || align="center"| s.o. oder z.B [http://www.segger.com/j-link-edu.html Segger J-LINK EDU] 50€ (sehr schnell und unterstützt viele Prozessoren) || align="center"|?? || align="center"|PICkit 3 30€ [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] || align="center"|z.B. Dragon 50€ || align="center"|20€ (Man muss DebugWire aktivieren)
|}

Das Demo-Board sollte ein Board sein, nicht zu teuer, um die ersten Erfahrungen zu sammeln. Wenn einem der Prozessor gefällt, so kann man später immer noch mit einem zweiten Demo-Board, z.B. mit Display aufrüsten.

Wenn man gerne mit einem Steckbrett sich die Schaltung zusammen stecken möchte, so kann man entweder die benötigten Drähte am Demo-Board anlöten oder bei z.B. [[AVR]]/[[PIC]] Prozessoren gibt es Ausführungen im DIL Gehäuse, die direkt steckbar sind.

Ein Programmieradapter sollte unbedingt auch einen Debugger beinhalten. Denn für den Start ist es ungemein hilfreich zu sehen was im Prozessor gerade geschieht. Die JTAG-Adapter für einen [[STM32]] Prozessor sind alle Debugger-Tauglich. Für einen [[AVR]] oder [[PIC]] Prozessor gibt es auch oft reine Programmer (oft Selbstbau-Lösungen über die serielle oder parallele Schnittstelle) welche den Mikrocontroller nur beschreiben können. Sinvoller sind hingegen Debugger (bspw. PIC Kit 3 [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] kompatibel zu allen PIC Mikrocontrollern), die die Ausführung eines Mikrocontrollers anhalten können um die aktuelle Position im Programmcode, Variableninhalt, Register, ... auszulesen bzw. zur Laufzeit zu ändern.

Der für den [[STM32]] empfohlene Segger J-LINK EDU ist zwar nicht der günstigste (z.B. auf einem STM32F4DISCOVERY Borad ist auch einer drauf den man für andere STM32 nutzen kann) aber eines der besten, mit sehr guten Software-Tools und nutzbar für alle Prozessoren mit ARM-Kern (ARM7/9/11/... Cortex-Mx). Niemals am Werkzeug sparen und man hat viel mehr Freude bei der Arbeit.

Der "Arduino" ist kein eigenständiger Prozessor, sondern ein fertiges Board mit einer "Arduino" Programmierumgebung (und einem AVR Prozessor), extra geschaffen für Einsteiger. Allerdings ist da der Lerneffekt viel geringer da man den Prozessor mit der Arduino-Software programmiert und nicht direkt die Register.

Ein [[PIC16]] ist ein älterer 8-Bit Mikrocontroller, der durch die [[PIC18]] Reihe abgelöst wurde. Werden komplexere Anforderungen in Zukunft an den Mikrocontroller gestellt (Audio, Grafik), so sollte zu den moderneren [[PIC24]] bzw. [[dsPIC]] (16-Bit) oder gar zu [[PIC32]] (32-Bit MIPS Prozessor) gegriffen werden, wobei letzterer von der Performance vergleichbar mit den STM32 ARM-basierten Mikrocontrollern ist.

= Programmierumgebungen=

Bei den Programmierumgebungen gibt es zu allen Prozessorfamilien kostenlose und Leistungsfähige Software

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! [[STM32]] || [[AVR]] || PIC || [[MSP430]] || Arduino
|-
| align="center"|[http://www.coocox.org/CooCox_CoIDE.htm CooCox] || align="center"|Atmel-Studio || align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPALB X] (IDE inklusive compiler) || align="center"|?? || align="center"|arduino 1.0.5
|}

natürlich gibt es noch viele weitere (für STM32 siehe [[STM32#Programmierung]]), es sollte jedoch nur die einfachsten kostenlose (und ohne Codebegrenzung) für den ersten Einstieg gezeigt werden.

* CooCox Anleitung wie man innerhalb einer Stunde die LED eines Nagel neuen STM32F4DISCOVERY Boards zum blinken bekommt, Artikel: [[STM32 CooCox Installation]]. Diese Anleitung ist eine Schritt-Für-Schritt Anleitung um den aller ersten Start zu vereinfachen.

= Dokumentation=

Bevor man sich für einen Prozessor entscheidet sollte man unbedingt deren Dokumentation mal zumindest überfliegen und auch deren Errata's lesen. Nicht dass man eine Anwendung erstellen möchte und stellt hinterher fest, dass genau dieser Teil so buggy ist das er nicht genutzt werden kann.

Beim [[STM32]] hat die Dokumentation doch recht viele Seiten, viel mehr als bei einem [[AVR]] oder PIC. Dabei ist vieles eher knapp beschrieben, man muss mehr suchen als z.B. bei den AVR-Dokus, um die gewünschten Informationen zu finden. Außerdem gibt es durchaus einige Unklarheiten und Fehler/Widersprüche. Schlussendlich ist es Geschmackssache mit welcher Doku von welchem Hersteller man sich besser zurecht findet.

Bei den PICs gibt es zu jedem Mikrocontroller ein Datenblatt das die wichtigsten Informationen für den alltäglichen Gebrauch enthält. Da bestimmte Peripherie (bspw. I2C, SPI, ... ) aber sehr komplex ist und innerhalb einer Familie (PIC16/18/24/32) sich identisch verhält, gibt es zu jeder Familie die sogenannten Family-Datasheets, welche alle Module im Detail beschreiben.

Parallel zur Dokumentation sollte man sich auch die Demo-Beispiele der Hersteller anschauen, dann wird vieles gleich verständlicher.

Eine Übersicht über die Funktionen gibt es im Artikel: [[STM32]]

= Die Arbeit mit dem STM32=

Zu erst einmal SOOO groß sind die Unterschiede zwischen den einzelnen Prozessoren nicht. Alle haben Ein-/Ausgänge und um mittels einem Port-Pin eine LED ansteuern zu können muss bei jedem Prozessor der Pin erst einmal parametriert werden, egal ob das jetzt ein STM32 oder ein AVR oder ein MSP430 ist. Nur hat man bei einem STM32 doch einige Funktionen mehr, z.B. zuschaltbarer Pull-Up oder Pull-Down Widerstand und spezielle Setz-Rücksetzregister, die andere Prozessoren nicht haben, jedoch das programmieren vereinfachen.
Der Haupt-Unterschied zu den anderen Prozessoren ist, dass der [[STM32]] so viele Peripherie-Module beherbergt, dass man die einzeln immer mit einem Clock aktivieren muss, denn damit lässt sich viel Strom sparen.

Und mal ganz ehrlich die Diskussion welcher µc einfacher zu konfigurieren ist, ist doch absoluter Unsinn. Der Weg ist immer der Gleiche:
*1. Blick ins Datenblatt welche Register für diese Funktion benötigt werden.
*2. Werte ermitteln die in die Register eingetragen werden.
*3. Werte ins Register schreiben. Da machte es GAR KEINEN UNTERSCHIED ob es ein [[AVR]], 8051/2, ARM,...... ist.

Stimmt schon es gibt Unterschiede. Die Register haben anderen Namen, andere Adressen, andere Bitbedeutungen,...
Aber es steht doch alles im Datenblatt. Und ob ich jetzt einen [[AVR]] oder einen ARM das erste mal vor mir liegen hab. Ich brauch in allen Fällen die oben beschriebenen Schritte.

Das Interruptsystem ist bei einem STM32 zusätzlich priorisiert, damit kann man festlegen welcher Interrupt vorrangig bearbeitet wird. Die Prioritätenvergabe ist auch kein Hexenwerk.

Zu allen Prozessoren liefern die jeweiligen Hersteller umfangreiche Demo-Codes und Libraries mit. Meist sind alle in C geschrieben, daher sollte auch die Programmiersprache C verwendet werden. Vor allem auch wenn man berufliche Absichten verfolgt.

Und wenn man einen STM32 kann, dann ist ein Umstieg auf einen LPC17xx (NXP) oder andere Hersteller überhaupt kein Problem (*), denn die bieten ebenfalls Prozessoren mit Cortex-M3 Kern und man kann diese mit der gleichen Programmierumgebung programmieren. Somit ist man nicht zwingend Herstellerabhängig. (* jeder Hersteller verbaut seine eigene Peripherie, die andere Funktionalitäten haben.)

Mit einem STM32 kann man als Hobby-Baster und Professionell nahezu alle Anwendungen realisieren. Der hat genügend RAM und FLASH Speicher und auch genügen Geschwindigkeit. Viele Gehäuse-Varianten um kleine bis hin zu größere Geräte zu erstellen. Viele Schnittstellen, sind im Artikel [[STM32]] beschrieben.

Der einzige Nachteil beim STM32: man muss etwas mehr lesen, da eine Peripherie doch viel mehr Funktionalität hat. Ansonsten kenne ich nicht wirklich einen Grund warum man als Neueinsteiger keinen STM32 nehmen sollte.

= Programmiersprachen =
* Wie bei vielen anderen Controllern wird beim STM32 auch hauptsächlich C und C++ verwendet. Kennen sollte man die Programmiersprache C schon, wenn man davon noch keine Ahnung hat dann sollte man erst mal mittels einem Tutorial auf einem PC ein Konsoleprogramm schreiben, sodass man es einigermaßen kennen lernt. Hier im Forum gibt es ebenfalls Artikel dazu. Zielt man auf die (spätere) Anwendung in der Industrie, sollte aufgrund der Verbreitung auf jeden Fall C (oder C++) gewählt werden; außerdem sind die meisten verfügbaren Libraries in C geschrieben.
* Assembler sollte man nur grob verstehen, Details wie ein Befehl arbeitet ist unwichtig. Selbst wenn man die Zyklen für einen Funktionsaufruf wissen will, so bietet der STM32 (Cortex-M3) einen Cycle-Counter den man auslesen kann; durch die komplexere Pipeline und Cache-Effekte sind die Laufzeiten allerdings nicht genau vorhersehbar. Wird zyklengenause Timing benötigt, sollten Timer verwendet werden - davon hat der STM32 genug.

Der 32bit-Adressraum, der RAM, Flash, I/O-Register vereinheitlicht ansprechen kann (im Gegensatz zu z.B. AVR) ist ideal für eine Verwendung durch Hochsprachen; bei Pointern muss keine zusätzliche Information verwaltet werden, in welche Art Speicher sie zeigen. Die Adresse gibt dies eindeutig an (es gibt nur '''eine''' Adresse 42, und nicht 2 wie bei es für Harvard-Architekturen eigentlich typisch ist (Programmspeicher und Datenspeicher, also z.B. Flash und RAM/IO) und die Hardware spricht automatisch den richtigen Speicher an. Die Möglichkeiten zur Offset-Adressierung, der Barrel-Shifter, Divsions-Einheit, die FPU (bei STM32F4), Interrupt-Modell etc. begünstigen ebenfalls die Erzeugung effizienteren Codes. Außerdem haben die STM32 einfach mehr "rohe Leistung", d.h. mehr Flash/RAM-Speicher und höhere Taktfrequenzen. 
 
'''Folgerung''': Die Programmierung in Hochsprachen ist '''bequemer als bei 8-Bittern''', denn man muss sich einfach weniger Gedanken machen, ob der Compiler ein Programm nun effizent umsetzen kann (kann man natürlich trotzdem machen, um noch mehr Leistung "herauszuquetschen", wenn man will).

= Weitere Randbedingungen für die Entscheidung=

Der wichtige Punkt, der oftmals auch vergessen wird: die Beschaffbarkeit. Wenn jemand einen Renesas M16C oder Fujitsu empfiehlt, dann sucht man erst mal und findet nur wenige vereinzelte die man privat kaufen kann.

Oder auch die Unterstützung im Internet - ist bei einigen Exoten spärlich. Dieses Forum bietet die beste Hilfe für [[AVR]], PIC, [[STM32]] und [[MSP430]].

Andere Prozessoren sind schon sehr alt, bzw. nicht mehr modern da deren Peripherie zum Teil doch recht eingeschränkte Funktionalität bietet. z.B. viele 8051 Typen oder PIC16. Die mögen für Mini-Anwenungen gut sein, aber wer will den schon gerne sich extra für eine Kleinanwendung mit einem kleinen µC auseinandersetzen, wenn er schon einen STM32 kennt, mit dem er alles machen kann (und sich bereits gute Funktionen geschrieben hat)?

Daher mein Resümee: wer nicht gerade auf den Kopf gefallen ist, der kann getrost mit einem STM32 starten. Ein [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419?s_searchtype=keyword STM32F4DISCOVERY] Board kostet nur ca. 20 EUR - und mehr muss für den ersten Start nicht investiert werden - wenn es doch zu komplex sein sollte gibt es hier im Forum auch Hilfe oder man nimmt erst mal ein "Arduino". Jedenfalls sind diese 20 EUR wirklich keine große Investition.

= Weblinks, Foren, Communities, Tutorials =
* [[STM32]] Hauptartikel, [http://www.mikrocontroller.net/articles/STM32#Weblinks.2C_Foren.2C_Communities.2C_Tutorials dortige Linksammlung]
* [http://www.mikrocontroller.net/topic/319328 Diskussion zum Artikel]
* [[STM32 CooCox Installation]]
* [[STM32 Eclipse Installation]]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

STM32 für Einsteiger

2013-12-30T22:34:30Z

M-w: /* Kosten */

Immer wiederkehrend hier im Forum "Mit welchem Mikrocontroller anfangen?". Es gibt eine große Auswahl und eben so viele Empfehlungen. In diesem Artikel soll zu erst geholfen werden ob ein STM32-Prozessor mit Cortex-M3/M4 Kern überhaupt der Richtige für den Start ist.
Nicht für jeden ist der STM32 zu empfehlen, denn die Anforderungen und Wünsche die man realisieren möchte, sowie die eigenen Fähigkeiten sind verschieden.

Es werden meist die Prozessoren AVR, PIC, Arduino, MSP430 und STM32 empfohlen. Seltener auch 8051, LPC und M16C. Alle haben Vorzüge und ebenso auch Nachteile.

= Eigene Fähigkeiten und Wünsche =

Dieser Artikel geht davon aus, dass bereits Elektronik Kenntnisse vorhanden sind. Wenn nicht dann sollte man erst einmal den Artikel "[[Absolute Beginner]]" durcharbeiten, sowie die anderen Artikel aus der Kategorie "[http://www.mikrocontroller.net/articles/Kategorie:Grundlagen Grundlagen]"

Zu erst einmal die Randbedingungen, mit der man sich selbst zu erst einmal einschätzen sollte:
{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Fähigkeit || Empfehlung [[STM32]] || Empfehlung [[AVR]] || Empfehlung PIC || Empfehlung [[MSP430]] || Empfehlung Arduino
|-
| Neueinsteiger, kaum Elektronikkenntnisse, noch nie programmiert || align="center"|O || align="center"|O [http://www.rn-wissen.de/index.php/AVR-Einstieg_leicht_gemacht] [http://www.avr-asm-tutorial.net/avr_de/] || align="center"|O [http://www.sprut.de/] || align="center"|O || align="center"|x
|-
| Wunsch ist SD-Card oder Grafik-Display || align="center"|x || align="center"|x || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en537999] [http://www.microchip.com/pagehandler/en-us/technology/graphics/] || align="center"|x || align="center"|x
|-
| Wunsch ist TCP/IP Netzwerk oder Kamera|| align="center"|x || align="center"|O || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2505&param=en535724] || align="center"|O || align="center"|O
|-
| Möchte die Erkenntnisse beruflich nutzen|| align="center"|x || align="center"|x || align="center"|x || align="center"|x || align="center"|-
|-
| Strom sparende Anwendungen|| align="center"|O || align="center"|x [http://www.atmel.com/technologies/lowpower/default.aspx] || align="center"|x [http://www.microchip.com/pagehandler/en-us/technology/xlp/] || align="center"|x || align="center"|-
|-
| Experimentieren mit Multithreading, RTOS, Schedulern || align="center"|x || align="center"|O [http://www.freertos.org/a00098.html] [http://www.femtoos.org/] || align="center"|O [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en531543&redirects=rtos] || align="center"|- || align="center"|-
|-
| Besonders große, speicherintensive Programme z.B. Grafiken, Fonts || align="center"|bis 2MB Flash bis 256kB SRAM || align="center"|bis 256kB Flash bis 16kB SRAM || align="center"|bis 2MB Flash bis 512kB SRAM || align="center"|bis 512KB Flash bis ? kB SRAM || align="center"|bis 256kB Flash bis 16kB SRAM
|-
| Sehr viel PWM mit komplexem Timing || align="center"|x || align="center"|bedingt, AT90Spwm || align="center"|O || align="center"|O || align="center"|-
|-
| Deutschsprachige Community || align="center"|O || align="center"|x || align="center"|O || align="center"|- || align="center"|x
|-
| Anzahl möglicher HW-Breakpoints || align="center"|4 bis 6 || align="center"|2 || align="center"| 1 bis 10 [http://www.microchip.com/stellent/groups/SiteComm_sg/documents/DeviceDoc/en556761.pdf] || align="center"|2 || align="center"|2
|}
* x = ja
* O = Teilweise, Einschränkungen
* - = nicht empfohlen
* ? = Bitte ergänzen

Nur um nicht zu verwirren, auch wenn Teile "nicht empfohlen" sind, heißt dass nicht dass es mit dem Prozessor nicht geht, vielmehr dass es mehr Aufwand ist das zu realisieren oder mehr Einschränkungen hat.

= Unwichtige Randbedingungen =

Oftmals werden fälschlicherweise Argumente für oder gegen eine µC-Familie ausgesprochen, die in der Praxis '''zum Einstieg''' (bei konkreten Anwendungen kann das anders aussehen) eher unwichtig sind.

* Spannungsversorgung 3,3V / 5V
* 8 (z.B. [[AVR]]), 16 (z.B. [[MSP430]]) oder 32 (z.B. [[STM32]]) Bit
* Interrupt System mit mehr oder weniger Features
* Programmiersprache (Assembler, Basic, C, C++, Pascal)
* Assembler verstehen (Sollte nur theoretisch verstanden werden, ein Programm sollte in einer Hochsprache geschrieben sein)
* DIL Gehäuse - steckbretttauglich (STM32-Prozessoren gibt es auch fertig gelötet auf einem steckbretttauglichen Board zum fünffachen Preis vergleichbarer DIL Mikrocontroller)
* Programmieradapter
* zu 90% reicht doch ein kleiner Prozessor ([[AVR]]/PIC) - und für die restlichen kann man immer noch einen großen nehmen. Warum also nicht gleich einen großen nehmen?

= Kosten =

Grobe Abschätzung was das alles denn kosten wird. Hier sind nur einige Beispiele gezeigt.

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Board || [[STM32]] || [[AVR]] || PIC18/24/32 || [[MSP430]] || Arduino
|-
| Demo-Board || align="center"|[http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419] 9..20€ (incl. Programmieradapter und Debugger) || align="center"|5..500€, z.B. Arduino || align="center"| [http://www.microchipdirect.com/ProductDetails.aspx?Catalog=BuyMicrochip&Category=Starter%20Kits&mid=1&lmid=610 durchschnittlich 18€ .. 50€] || align="center"|[http://www.ti.com/tool/msp-exp430fr5739] ~35€ || align="center"|20€
|-
| Steckbrettaugliches Board || align="center"| s.o. oder [http://re.reworld.eu/de/produkte/s64dil-405/index.htm S64DIL-405] 30€ || align="center"|0,6–5€ als einzelner IC || align="center"|2-5€ als einzelner IC || align="center"|?? || align="center"|??
|-
| Programmieradapter mit Debugger || align="center"| s.o. oder z.B [http://www.segger.com/j-link-edu.html Segger J-LINK EDU] 50€ (sehr schnell und unterstützt viele Prozessoren) || align="center"|?? || align="center"|PICkit 3 30€ [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] || align="center"|z.B. Dragon 50€ || align="center"|20€ (Man muss DebugWire aktivieren)
|}

Das Demo-Board sollte ein Board sein, nicht zu teuer, um die ersten Erfahrungen zu sammeln. Wenn einem der Prozessor gefällt, so kann man später immer noch mit einem zweiten Demo-Board, z.B. mit Display aufrüsten.

Wenn man gerne mit einem Steckbrett sich die Schaltung zusammen stecken möchte, so kann man entweder die benötigten Drähte am Demo-Board anlöten oder bei z.B. [[AVR]]/[[PIC]] Prozessoren gibt es Ausführungen im DIL Gehäuse, die direkt steckbar sind.

Ein Programmieradapter sollte unbedingt auch einen Debugger beinhalten. Denn für den Start ist es ungemein hilfreich zu sehen was im Prozessor gerade geschieht. Die JTAG-Adapter für einen [[STM32]] Prozessor sind alle Debugger-Tauglich. Für einen [[AVR]] oder [[PIC]] Prozessor gibt es auch oft reine Programmer (oft Selbstbau-Lösungen über die serielle oder parallele Schnittstelle) welche den Mikrocontroller nur beschreiben können. Sinvoller sind hingegen Debugger (bspw. PIC Kit 3 [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] kompatibel zu allen PIC Mikrocontrollern), die die Ausführung eines Mikrocontrollers anhalten können um die aktuelle Position im Programmcode, Variableninhalt, Register, ... auszulesen bzw. zur Laufzeit zu ändern.

Der für den [[STM32]] empfohlene Segger J-LINK EDU ist zwar nicht der günstigste (z.B. auf einem STM32F4DISCOVERY Borad ist auch einer drauf den man für andere STM32 nutzen kann) aber eines der besten, mit sehr guten Software-Tools und nutzbar für alle Prozessoren mit ARM-Kern (ARM7/9/11/... Cortex-Mx). Niemals am Werkzeug sparen und man hat viel mehr Freude bei der Arbeit.

Der "Arduino" ist kein eigenständiger Prozessor, sondern ein fertiges Board mit einer "Arduino" Programmierumgebung (und einem AVR Prozessor), extra geschaffen für Einsteiger. Allerdings ist da der Lerneffekt viel geringer da man den Prozessor mit der Arduino-Software programmiert und nicht direkt die Register.

Ein [[PIC16]] ist ein älterer 8-Bit Mikrocontroller, der durch die [[PIC18]] Reihe abgelöst wurde. Werden komplexere Anforderungen in Zukunft an den Mikrocontroller gestellt (Audio, Grafik), so sollte zu den moderneren [[PIC24]] bzw. [[dsPIC]] (16-Bit) oder gar zu [[PIC32]] (32-Bit MIPS Prozessor) gegriffen werden, wobei letzterer von der Performance vergleichbar mit den STM32 ARM-basierten Mikrocontrollern ist.

= Programmierumgebungen=

Bei den Programmierumgebungen gibt es zu allen Prozessorfamilien kostenlose und Leistungsfähige Software

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! [[STM32]] || [[AVR]] || PIC || [[MSP430]] || Arduino
|-
| align="center"|[http://www.coocox.org/CooCox_CoIDE.htm CooCox] || align="center"|Atmel-Studio || align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPALB X] (IDE inklusive compiler) || align="center"|?? || align="center"|arduino 1.0.5
|}

natürlich gibt es noch viele weitere (für STM32 siehe [[STM32#Programmierung]]), es sollte jedoch nur die einfachsten kostenlose (und ohne Codebegrenzung) für den ersten Einstieg gezeigt werden.

* CooCox Anleitung wie man innerhalb einer Stunde die LED eines Nagel neuen STM32F4DISCOVERY Boards zum blinken bekommt, Artikel: [[STM32 CooCox Installation]]. Diese Anleitung ist eine Schritt-Für-Schritt Anleitung um den aller ersten Start zu vereinfachen.

= Dokumentation=

Bevor man sich für einen Prozessor entscheidet sollte man unbedingt deren Dokumentation mal zumindest überfliegen und auch deren Errata's lesen. Nicht dass man eine Anwendung erstellen möchte und stellt hinterher fest, dass genau dieser Teil so buggy ist das er nicht genutzt werden kann.

Beim [[STM32]] hat die Dokumentation doch recht viele Seiten, viel mehr als bei einem [[AVR]] oder PIC. Dabei ist vieles eher knapp beschrieben, man muss mehr suchen als z.B. bei den AVR-Dokus, um die gewünschten Informationen zu finden. Außerdem gibt es durchaus einige Unklarheiten und Fehler/Widersprüche. Schlussendlich ist es Geschmackssache mit welcher Doku von welchem Hersteller man sich besser zurecht findet.

Bei den PICs gibt es zu jedem Mikrocontroller ein Datenblatt das die wichtigsten Informationen für den alltäglichen Gebrauch enthält. Da bestimmte Peripherie (bspw. I2C, SPI, ... ) aber sehr komplex ist und innerhalb einer Familie (PIC16/18/24/32) sich identisch verhält, gibt es zu jeder Familie die sogenannten Family-Datasheets, welche alle Module im Detail beschreiben.

Parallel zur Dokumentation sollte man sich auch die Demo-Beispiele der Hersteller anschauen, dann wird vieles gleich verständlicher.

Eine Übersicht über die Funktionen gibt es im Artikel: [[STM32]]

= Die Arbeit mit dem STM32=

Zu erst einmal SOOO groß sind die Unterschiede zwischen den einzelnen Prozessoren nicht. Alle haben Ein-/Ausgänge und um mittels einem Port-Pin eine LED ansteuern zu können muss bei jedem Prozessor der Pin erst einmal parametriert werden, egal ob das jetzt ein STM32 oder ein AVR oder ein MSP430 ist. Nur hat man bei einem STM32 doch einige Funktionen mehr, z.B. zuschaltbarer Pull-Up oder Pull-Down Widerstand und spezielle Setz-Rücksetzregister, die andere Prozessoren nicht haben, jedoch das programmieren vereinfachen.
Der Haupt-Unterschied zu den anderen Prozessoren ist, dass der [[STM32]] so viele Peripherie-Module beherbergt, dass man die einzeln immer mit einem Clock aktivieren muss, denn damit lässt sich viel Strom sparen.

Und mal ganz ehrlich die Diskussion welcher µc einfacher zu konfigurieren ist, ist doch absoluter Unsinn. Der Weg ist immer der Gleiche:
*1. Blick ins Datenblatt welche Register für diese Funktion benötigt werden.
*2. Werte ermitteln die in die Register eingetragen werden.
*3. Werte ins Register schreiben. Da machte es GAR KEINEN UNTERSCHIED ob es ein [[AVR]], 8051/2, ARM,...... ist.

Stimmt schon es gibt Unterschiede. Die Register haben anderen Namen, andere Adressen, andere Bitbedeutungen,...
Aber es steht doch alles im Datenblatt. Und ob ich jetzt einen [[AVR]] oder einen ARM das erste mal vor mir liegen hab. Ich brauch in allen Fällen die oben beschriebenen Schritte.

Das Interruptsystem ist bei einem STM32 zusätzlich priorisiert, damit kann man festlegen welcher Interrupt vorrangig bearbeitet wird. Die Prioritätenvergabe ist auch kein Hexenwerk.

Zu allen Prozessoren liefern die jeweiligen Hersteller umfangreiche Demo-Codes und Libraries mit. Meist sind alle in C geschrieben, daher sollte auch die Programmiersprache C verwendet werden. Vor allem auch wenn man berufliche Absichten verfolgt.

Und wenn man einen STM32 kann, dann ist ein Umstieg auf einen LPC17xx (NXP) oder andere Hersteller überhaupt kein Problem (*), denn die bieten ebenfalls Prozessoren mit Cortex-M3 Kern und man kann diese mit der gleichen Programmierumgebung programmieren. Somit ist man nicht zwingend Herstellerabhängig. (* jeder Hersteller verbaut seine eigene Peripherie, die andere Funktionalitäten haben.)

Mit einem STM32 kann man als Hobby-Baster und Professionell nahezu alle Anwendungen realisieren. Der hat genügend RAM und FLASH Speicher und auch genügen Geschwindigkeit. Viele Gehäuse-Varianten um kleine bis hin zu größere Geräte zu erstellen. Viele Schnittstellen, sind im Artikel [[STM32]] beschrieben.

Der einzige Nachteil beim STM32: man muss etwas mehr lesen, da eine Peripherie doch viel mehr Funktionalität hat. Ansonsten kenne ich nicht wirklich einen Grund warum man als Neueinsteiger keinen STM32 nehmen sollte.

= Programmiersprachen =
* Wie bei vielen anderen Controllern wird beim STM32 auch hauptsächlich C und C++ verwendet. Kennen sollte man die Programmiersprache C schon, wenn man davon noch keine Ahnung hat dann sollte man erst mal mittels einem Tutorial auf einem PC ein Konsoleprogramm schreiben, sodass man es einigermaßen kennen lernt. Hier im Forum gibt es ebenfalls Artikel dazu. Zielt man auf die (spätere) Anwendung in der Industrie, sollte aufgrund der Verbreitung auf jeden Fall C (oder C++) gewählt werden; außerdem sind die meisten verfügbaren Libraries in C geschrieben.
* Assembler sollte man nur grob verstehen, Details wie ein Befehl arbeitet ist unwichtig. Selbst wenn man die Zyklen für einen Funktionsaufruf wissen will, so bietet der STM32 (Cortex-M3) einen Cycle-Counter den man auslesen kann; durch die komplexere Pipeline und Cache-Effekte sind die Laufzeiten allerdings nicht genau vorhersehbar. Wird zyklengenause Timing benötigt, sollten Timer verwendet werden - davon hat der STM32 genug.

Der 32bit-Adressraum, der RAM, Flash, I/O-Register vereinheitlicht ansprechen kann (im Gegensatz zu z.B. AVR) ist ideal für eine Verwendung durch Hochsprachen; bei Pointern muss keine zusätzliche Information verwaltet werden, in welche Art Speicher sie zeigen. Die Adresse gibt dies eindeutig an (es gibt nur '''eine''' Adresse 42, und nicht 2 wie bei es für Harvard-Architekturen eigentlich typisch ist (Programmspeicher und Datenspeicher, also z.B. Flash und RAM/IO) und die Hardware spricht automatisch den richtigen Speicher an. Die Möglichkeiten zur Offset-Adressierung, der Barrel-Shifter, Divsions-Einheit, die FPU (bei STM32F4), Interrupt-Modell etc. begünstigen ebenfalls die Erzeugung effizienteren Codes. Außerdem haben die STM32 einfach mehr "rohe Leistung", d.h. mehr Flash/RAM-Speicher und höhere Taktfrequenzen. 
 
'''Folgerung''': Die Programmierung in Hochsprachen ist '''bequemer als bei 8-Bittern''', denn man muss sich einfach weniger Gedanken machen, ob der Compiler ein Programm nun effizent umsetzen kann (kann man natürlich trotzdem machen, um noch mehr Leistung "herauszuquetschen", wenn man will).

= Weitere Randbedingungen für die Entscheidung=

Der wichtige Punkt, der oftmals auch vergessen wird: die Beschaffbarkeit. Wenn jemand einen Renesas M16C oder Fujitsu empfiehlt, dann sucht man erst mal und findet nur wenige vereinzelte die man privat kaufen kann.

Oder auch die Unterstützung im Internet - ist bei einigen Exoten spärlich. Dieses Forum bietet die beste Hilfe für [[AVR]], PIC, [[STM32]] und [[MSP430]].

Andere Prozessoren sind schon sehr alt, bzw. nicht mehr modern da deren Peripherie zum Teil doch recht eingeschränkte Funktionalität bietet. z.B. viele 8051 Typen oder PIC16. Die mögen für Mini-Anwenungen gut sein, aber wer will den schon gerne sich extra für eine Kleinanwendung mit einem kleinen µC auseinandersetzen, wenn er schon einen STM32 kennt, mit dem er alles machen kann (und sich bereits gute Funktionen geschrieben hat)?

Daher mein Resümee: wer nicht gerade auf den Kopf gefallen ist, der kann getrost mit einem STM32 starten. Ein [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419?s_searchtype=keyword STM32F4DISCOVERY] Board kostet nur ca. 20 EUR - und mehr muss für den ersten Start nicht investiert werden - wenn es doch zu komplex sein sollte gibt es hier im Forum auch Hilfe oder man nimmt erst mal ein "Arduino". Jedenfalls sind diese 20 EUR wirklich keine große Investition.

= Weblinks, Foren, Communities, Tutorials =
* [[STM32]] Hauptartikel, [http://www.mikrocontroller.net/articles/STM32#Weblinks.2C_Foren.2C_Communities.2C_Tutorials dortige Linksammlung]
* [http://www.mikrocontroller.net/topic/319328 Diskussion zum Artikel]
* [[STM32 CooCox Installation]]
* [[STM32 Eclipse Installation]]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

Bierdeckel-Programmer

2013-12-30T22:29:56Z

M-w: Sachfremden Werbelink entfernt.

Diskussion:STM32 für Einsteiger

2013-12-30T22:20:22Z

M-w:

= Speicher... =
RAM und I/O liegen bei den AVR im gleichen Adressbereich. --[[Benutzer:Haku|Haku]] ([[Benutzer Diskussion:Haku|Diskussion]]) 17:45, 30. Dez. 2013 (CET)

:Das ist wohl richtig. Sogar der Registersatz (32 Register à 8 Bit) liegt dort. --[[Benutzer:M-w|M-w]] ([[Benutzer Diskussion:M-w|Diskussion]]) 23:20, 30. Dez. 2013 (CET)

STM32 für Einsteiger

2013-12-30T21:07:56Z

M-w: Speichergrößen in der Tabelle ergänzt

Immer wiederkehrend hier im Forum "Mit welchem Mikrocontroller anfangen?". Es gibt eine große Auswahl und eben so viele Empfehlungen. In diesem Artikel soll zu erst geholfen werden ob ein STM32-Prozessor mit Cortex-M3/M4 Kern überhaupt der Richtige für den Start ist.
Nicht für jeden ist der STM32 zu empfehlen, denn die Anforderungen und Wünsche die man realisieren möchte, sowie die eigenen Fähigkeiten sind verschieden.

Es werden meist die Prozessoren AVR, PIC, Arduino, MSP430 und STM32 empfohlen. Seltener auch 8051, LPC und M16C. Alle haben Vorzüge und ebenso auch Nachteile.

= Eigene Fähigkeiten und Wünsche =

Dieser Artikel geht davon aus, dass bereits Elektronik Kenntnisse vorhanden sind. Wenn nicht dann sollte man erst einmal den Artikel "[[Absolute Beginner]]" durcharbeiten, sowie die anderen Artikel aus der Kategorie "[http://www.mikrocontroller.net/articles/Kategorie:Grundlagen Grundlagen]"

Zu erst einmal die Randbedingungen, mit der man sich selbst zu erst einmal einschätzen sollte:
{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Fähigkeit || Empfehlung [[STM32]] || Empfehlung [[AVR]] || Empfehlung PIC || Empfehlung [[MSP430]] || Empfehlung Arduino
|-
| Neueinsteiger, kaum Elektronikkenntnisse, noch nie programmiert || align="center"|O || align="center"|O [http://www.rn-wissen.de/index.php/AVR-Einstieg_leicht_gemacht] [http://www.avr-asm-tutorial.net/avr_de/] || align="center"|O [http://www.sprut.de/] || align="center"|O || align="center"|x
|-
| Wunsch ist SD-Card oder Grafik-Display || align="center"|x || align="center"|x || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en537999] [http://www.microchip.com/pagehandler/en-us/technology/graphics/] || align="center"|x || align="center"|x
|-
| Wunsch ist TCP/IP Netzwerk oder Kamera|| align="center"|x || align="center"|O || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2505&param=en535724] || align="center"|O || align="center"|O
|-
| Möchte die Erkenntnisse beruflich nutzen|| align="center"|x || align="center"|x || align="center"|x || align="center"|x || align="center"|-
|-
| Strom sparende Anwendungen|| align="center"|O || align="center"|x [http://www.atmel.com/technologies/lowpower/default.aspx] || align="center"|x [http://www.microchip.com/pagehandler/en-us/technology/xlp/] || align="center"|x || align="center"|-
|-
| Experimentieren mit Multithreading, RTOS, Schedulern || align="center"|x || align="center"|O [http://www.freertos.org/a00098.html] [http://www.femtoos.org/] || align="center"|O [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en531543&redirects=rtos] || align="center"|- || align="center"|-
|-
| Besonders große, speicherintensive Programme z.B. Grafiken, Fonts || align="center"|bis 2 MB Flash bis ? kB SRAM || align="center"|bis 256 kB Flash bis 16 kB SRAM || align="center"|bis 2MB Flash bis ? kB SRAM || align="center"|bis 512KB Flash bis ? kB SRAM || align="center"|bis 256 kB Flash bis 16 kB SRAM
|-
| Sehr viel PWM mit komplexem Timing || align="center"|x || align="center"|bedingt, AT90Spwm || align="center"|O || align="center"|O || align="center"|-
|-
| Deutschsprachige Community || align="center"|O || align="center"|x || align="center"|O || align="center"|- || align="center"|x
|-
| Anzahl möglicher HW-Breakpoints || align="center"|6 || align="center"|2 || align="center"| 1 bis 10 [http://www.microchip.com/stellent/groups/SiteComm_sg/documents/DeviceDoc/en556761.pdf] || align="center"|2 || align="center"|2
|}
* x = ja
* O = Teilweise, Einschränkungen
* - = nicht empfohlen
* ? = Bitte ergänzen

Nur um nicht zu verwirren, auch wenn Teile "nicht empfohlen" sind, heißt dass nicht dass es mit dem Prozessor nicht geht, vielmehr dass es mehr Aufwand ist das zu realisieren oder mehr Einschränkungen hat.

= Unwichtige Randbedingungen =

Oftmals werden fälschlicherweise Argumente für oder gegen eine µC-Familie ausgesprochen, die in der Praxis '''zum Einstieg''' (bei konkreten Anwendungen kann das anders aussehen) eher unwichtig sind.

* Spannungsversorgung 3,3V / 5V
* 8 (z.B. [[AVR]]), 16 (z.B. [[MSP430]]) oder 32 (z.B. [[STM32]]) Bit
* Interrupt System mit mehr oder weniger Features
* Programmiersprache (Assembler, Basic, C, C++, Pascal)
* Assembler verstehen (Sollte nur theoretisch verstanden werden, ein Programm sollte in einer Hochsprache geschrieben sein)
* DIL Gehäuse - steckbretttauglich (STM32-Prozessoren gibt es auch fertig gelötet auf einem steckbretttauglichen Board zum fünffachen Preis vergleichbarer DIL Mikrocontroller)
* Programmieradapter
* zu 90% reicht doch ein kleiner Prozessor ([[AVR]]/PIC) - und für die restlichen kann man immer noch einen großen nehmen. Warum also nicht gleich einen großen nehmen?

= Kosten =

Grobe Abschätzung was das alles denn kosten wird. Hier sind nur einige Beispiele gezeigt.

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Board || [[STM32]] || [[AVR]] || PIC18/24/32 || [[MSP430]] || Arduino
|-
| Demo-Board || align="center"|[http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419] 9..20€ (incl. Programmieradapter und Debugger) || align="center"|5..500€, z.B. Arduino || align="center"| [http://www.microchipdirect.com/ProductDetails.aspx?Catalog=BuyMicrochip&Category=Starter%20Kits&mid=1&lmid=610 durchschnittlich 18€ .. 50€] || align="center"|[http://www.ti.com/tool/msp-exp430fr5739] ~35€ || align="center"|20€
|-
| Steckbrettaugliches Board || align="center"| s.o. oder [http://re.reworld.eu/de/produkte/s64dil-405/index.htm S64DIL-405] 30€ || align="center"|2-5€ als einzelner IC || align="center"|2-5€ als einzelner IC || align="center"|?? || align="center"|??
|-
| Programmieradapter mit Debugger || align="center"| s.o. oder z.B [http://www.segger.com/j-link-edu.html Segger J-LINK EDU] 50€ (sehr schnell und unterstützt viele Prozessoren) || align="center"|?? || align="center"|PICkit 3 30€ [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] || align="center"|z.B. Dragon 50€ || align="center"|20€ (Man muss DebugWire aktivieren)
|}

Das Demo-Board sollte ein Board sein, nicht zu teuer, um die ersten Erfahrungen zu sammeln. Wenn einem der Prozessor gefällt, so kann man später immer noch mit einem zweiten Demo-Board, z.B. mit Display aufrüsten.

Wenn man gerne mit einem Steckbrett sich die Schaltung zusammen stecken möchte, so kann man entweder die benötigten Drähte am Demo-Board anlöten oder bei z.B. [[AVR]]/[[PIC]] Prozessoren gibt es Ausführungen im DIL Gehäuse, die direkt steckbar sind.

Ein Programmieradapter sollte unbedingt auch einen Debugger beinhalten. Denn für den Start ist es ungemein hilfreich zu sehen was im Prozessor gerade geschieht. Die JTAG-Adapter für einen [[STM32]] Prozessor sind alle Debugger-Tauglich. Für einen [[AVR]] oder [[PIC]] Prozessor gibt es auch oft reine Programmer (oft Selbstbau-Lösungen über die serielle oder parallele Schnittstelle) welche den Mikrocontroller nur beschreiben können. Sinvoller sind hingegen Debugger (bspw. PIC Kit 3 [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] kompatibel zu allen PIC Mikrocontrollern), die die Ausführung eines Mikrocontrollers anhalten können um die aktuelle Position im Programmcode, Variableninhalt, Register, ... auszulesen bzw. zur Laufzeit zu ändern.

Der für den [[STM32]] empfohlene Segger J-LINK EDU ist zwar nicht der günstigste (z.B. auf einem STM32F4DISCOVERY Borad ist auch einer drauf den man für andere STM32 nutzen kann) aber eines der besten, mit sehr guten Software-Tools und nutzbar für alle Prozessoren mit ARM-Kern (ARM7/9/11/... Cortex-Mx). Niemals am Werkzeug sparen und man hat viel mehr Freude bei der Arbeit.

Der "Arduino" ist kein eigenständiger Prozessor, sondern ein fertiges Board mit einer "Arduino" Programmierumgebung (und einem AVR Prozessor), extra geschaffen für Einsteiger. Allerdings ist da der Lerneffekt viel geringer da man den Prozessor mit der Arduino-Software programmiert und nicht direkt die Register.

Ein [[PIC16]] ist ein älterer 8-Bit Mikrocontroller, der durch die [[PIC18]] Reihe abgelöst wurde. Werden komplexere Anforderungen in Zukunft an den Mikrocontroller gestellt (Audio, Grafik), so sollte zu den moderneren [[PIC24]] bzw. [[dsPIC]] (16-Bit) oder gar zu [[PIC32]] (32-Bit MIPS Prozessor) gegriffen werden, wobei letzterer von der Performance vergleichbar mit den STM32 ARM-basierten Mikrocontrollern ist.

= Programmierumgebungen=

Bei den Programmierumgebungen gibt es zu allen Prozessorfamilien kostenlose und Leistungsfähige Software

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! [[STM32]] || [[AVR]] || PIC || [[MSP430]] || Arduino
|-
| align="center"|[http://www.coocox.org/CooCox_CoIDE.htm CooCox] || align="center"|Atmel-Studio || align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPALB X] (IDE inklusive compiler) || align="center"|?? || align="center"|arduino 1.0.5
|}

natürlich gibt es noch viele weitere (für STM32 siehe [[STM32#Programmierung]]), es sollte jedoch nur die einfachsten kostenlose (und ohne Codebegrenzung) für den ersten Einstieg gezeigt werden.

* CooCox Anleitung wie man innerhalb einer Stunde die LED eines Nagel neuen STM32F4DISCOVERY Boards zum blinken bekommt, Artikel: [[STM32 CooCox Installation]]. Diese Anleitung ist eine Schritt-Für-Schritt Anleitung um den aller ersten Start zu vereinfachen.

= Dokumentation=

Bevor man sich für einen Prozessor entscheidet sollte man unbedingt deren Dokumentation mal zumindest überfliegen und auch deren Errata's lesen. Nicht dass man eine Anwendung erstellen möchte und stellt hinterher fest, dass genau dieser Teil so buggy ist das er nicht genutzt werden kann.

Beim [[STM32]] hat die Dokumentation doch recht viele Seiten, viel mehr als bei einem [[AVR]] oder PIC. Dabei ist vieles eher knapp beschrieben, man muss mehr suchen als z.B. bei den AVR-Dokus, um die gewünschten Informationen zu finden. Außerdem gibt es durchaus einige Unklarheiten und Fehler/Widersprüche. Schlussendlich ist es Geschmackssache mit welcher Doku von welchem Hersteller man sich besser zurecht findet.

Bei den PICs gibt es zu jedem Mikrocontroller ein Datenblatt das die wichtigsten Informationen für den alltäglichen Gebrauch enthält. Da bestimmte Peripherie (bspw. I2C, SPI, ... ) aber sehr komplex ist und innerhalb einer Familie (PIC16/18/24/32) sich identisch verhält, gibt es zu jeder Familie die sogenannten Family-Datasheets, welche alle Module im Detail beschreiben.

Parallel zur Dokumentation sollte man sich auch die Demo-Beispiele der Hersteller anschauen, dann wird vieles gleich verständlicher.

Eine Übersicht über die Funktionen gibt es im Artikel: [[STM32]]

= Die Arbeit mit dem STM32=

Zu erst einmal SOOO groß sind die Unterschiede zwischen den einzelnen Prozessoren nicht. Alle haben Ein-/Ausgänge und um mittels einem Port-Pin eine LED ansteuern zu können muss bei jedem Prozessor der Pin erst einmal parametriert werden, egal ob das jetzt ein STM32 oder ein AVR oder ein MSP430 ist. Nur hat man bei einem STM32 doch einige Funktionen mehr, z.B. zuschaltbarer Pull-Up oder Pull-Down Widerstand und spezielle Setz-Rücksetzregister, die andere Prozessoren nicht haben, jedoch das programmieren vereinfachen.
Der Haupt-Unterschied zu den anderen Prozessoren ist, dass der [[STM32]] so viele Peripherie-Module beherbergt, dass man die einzeln immer mit einem Clock aktivieren muss, denn damit lässt sich viel Strom sparen.

Und mal ganz ehrlich die Diskussion welcher µc einfacher zu konfigurieren ist, ist doch absoluter Unsinn. Der Weg ist immer der Gleiche:
*1. Blick ins Datenblatt welche Register für diese Funktion benötigt werden.
*2. Werte ermitteln die in die Register eingetragen werden.
*3. Werte ins Register schreiben. Da machte es GAR KEINEN UNTERSCHIED ob es ein [[AVR]], 8051/2, ARM,...... ist.

Stimmt schon es gibt Unterschiede. Die Register haben anderen Namen, andere Adressen, andere Bitbedeutungen,...
Aber es steht doch alles im Datenblatt. Und ob ich jetzt einen [[AVR]] oder einen ARM das erste mal vor mir liegen hab. Ich brauch in allen Fällen die oben beschriebenen Schritte.

Das Interruptsystem ist bei einem STM32 zusätzlich priorisiert, damit kann man festlegen welcher Interrupt vorrangig bearbeitet wird. Die Prioritätenvergabe ist auch kein Hexenwerk.

Zu allen Prozessoren liefern die jeweiligen Hersteller umfangreiche Demo-Codes und Libraries mit. Meist sind alle in C geschrieben, daher sollte auch die Programmiersprache C verwendet werden. Vor allem auch wenn man berufliche Absichten verfolgt.

Und wenn man einen STM32 kann, dann ist ein Umstieg auf einen LPC17xx (NXP) oder andere Hersteller überhaupt kein Problem (*), denn die bieten ebenfalls Prozessoren mit Cortex-M3 Kern und man kann diese mit der gleichen Programmierumgebung programmieren. Somit ist man nicht zwingend Herstellerabhängig. (* jeder Hersteller verbaut seine eigene Peripherie, die andere Funktionalitäten haben.)

Mit einem STM32 kann man als Hobby-Baster und Professionell nahezu alle Anwendungen realisieren. Der hat genügend RAM und FLASH Speicher und auch genügen Geschwindigkeit. Viele Gehäuse-Varianten um kleine bis hin zu größere Geräte zu erstellen. Viele Schnittstellen, sind im Artikel [[STM32]] beschrieben.

Der einzige Nachteil beim STM32: man muss etwas mehr lesen, da eine Peripherie doch viel mehr Funktionalität hat. Ansonsten kenne ich nicht wirklich einen Grund warum man als Neueinsteiger keinen STM32 nehmen sollte.

= Programmiersprachen =
* Wie bei vielen anderen Controllern wird beim STM32 auch hauptsächlich C und C++ verwendet. Kennen sollte man die Programmiersprache C schon, wenn man davon noch keine Ahnung hat dann sollte man erst mal mittels einem Tutorial auf einem PC ein Konsoleprogramm schreiben, sodass man es einigermaßen kennen lernt. Hier im Forum gibt es ebenfalls Artikel dazu. Zielt man auf die (spätere) Anwendung in der Industrie, sollte aufgrund der Verbreitung auf jeden Fall C (oder C++) gewählt werden; außerdem sind die meisten verfügbaren Libraries in C geschrieben.
* Assembler sollte man nur grob verstehen, Details wie ein Befehl arbeitet ist unwichtig. Selbst wenn man die Zyklen für einen Funktionsaufruf wissen will, so bietet der STM32 (Cortex-M3) einen Cycle-Counter den man auslesen kann; durch die komplexere Pipeline und Cache-Effekte sind die Laufzeiten allerdings nicht genau vorhersehbar. Wird zyklengenause Timing benötigt, sollten Timer verwendet werden - davon hat der STM32 genug.

Der 32bit-Adressraum, der RAM, Flash, I/O-Register vereinheitlicht ansprechen kann (im Gegensatz zu z.B. AVR) ist ideal für eine Verwendung durch Hochsprachen; bei Pointern muss keine zusätzliche Information verwaltet werden, in welche Art Speicher sie zeigen. Die Adresse gibt dies eindeutig an (es gibt nur '''eine''' Adresse 42, und nicht 2 wie bei es für Harvard-Architekturen eigentlich typisch ist (Programmspeicher und Datenspeicher, also z.B. Flash und RAM/IO) und die Hardware spricht automatisch den richtigen Speicher an. Die Möglichkeiten zur Offset-Adressierung, der Barrel-Shifter, Divsions-Einheit, die FPU (bei STM32F4), Interrupt-Modell etc. begünstigen ebenfalls die Erzeugung effizienteren Codes. Außerdem haben die STM32 einfach mehr "rohe Leistung", d.h. mehr Flash/RAM-Speicher und höhere Taktfrequenzen. 
 
'''Folgerung''': Die Programmierung in Hochsprachen ist '''bequemer als bei 8-Bittern''', denn man muss sich einfach weniger Gedanken machen, ob der Compiler ein Programm nun effizent umsetzen kann (kann man natürlich trotzdem machen, um noch mehr Leistung "herauszuquetschen", wenn man will).

= Weitere Randbedingungen für die Entscheidung=

Der wichtige Punkt, der oftmals auch vergessen wird: die Beschaffbarkeit. Wenn jemand einen Renesas M16C oder Fujitsu empfiehlt, dann sucht man erst mal und findet nur wenige vereinzelte die man privat kaufen kann.

Oder auch die Unterstützung im Internet - ist bei einigen Exoten spärlich. Dieses Forum bietet die beste Hilfe für [[AVR]], PIC, [[STM32]] und [[MSP430]].

Andere Prozessoren sind schon sehr alt, bzw. nicht mehr modern da deren Peripherie zum Teil doch recht eingeschränkte Funktionalität bietet. z.B. viele 8051 Typen oder PIC16. Die mögen für Mini-Anwenungen gut sein, aber wer will den schon gerne sich extra für eine Kleinanwendung mit einem kleinen µC auseinandersetzen, wenn er schon einen STM32 kennt, mit dem er alles machen kann (und sich bereits gute Funktionen geschrieben hat)?

Daher mein Resümee: wer nicht gerade auf den Kopf gefallen ist, der kann getrost mit einem STM32 starten. Ein [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419?s_searchtype=keyword STM32F4DISCOVERY] Board kostet nur ca. 20 EUR - und mehr muss für den ersten Start nicht investiert werden - wenn es doch zu komplex sein sollte gibt es hier im Forum auch Hilfe oder man nimmt erst mal ein "Arduino". Jedenfalls sind diese 20 EUR wirklich keine große Investition.

= Weblinks, Foren, Communities, Tutorials =
* [[STM32]] Hauptartikel, [http://www.mikrocontroller.net/articles/STM32#Weblinks.2C_Foren.2C_Communities.2C_Tutorials dortige Linksammlung]
* [http://www.mikrocontroller.net/topic/319328 Diskussion zum Artikel]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

STM32 für Einsteiger

2013-12-30T14:52:10Z

M-w: Komplexität der Programme hat mit dem µC nichts zu tun, das ist Sache des Compilers.

Immer wiederkehrend hier im Forum "Mit welchem Mikrocontroller anfangen?". Es gibt eine große Auswahl und eben so viele Empfehlungen. In diesem Artikel soll zu erst geholfen werden ob ein STM32-Prozessor mit Cortex-M3/M4 Kern überhaupt der Richtige für den Start ist.
Nicht für jeden ist der STM32 zu empfehlen, denn die Anforderungen und Wünsche die man realisieren möchte, sowie die eigenen Fähigkeiten sind verschieden.

Es werden meist die Prozessoren AVR, PIC, Arduino, MSP430 und STM32 empfohlen. Seltener auch 8051, LPC und M16C. Alle haben Vorzüge und ebenso auch Nachteile.

= Eigene Fähigkeiten und Wünsche =

Dieser Artikel geht davon aus, dass bereits Elektronik Kenntnisse vorhanden sind. Wenn nicht dann sollte man erst einmal den Artikel "[[Absolute Beginner]]" durcharbeiten, sowie die anderen Artikel aus der Kategorie "[http://www.mikrocontroller.net/articles/Kategorie:Grundlagen Grundlagen]"

Zu erst einmal die Randbedingungen, mit der man sich selbst zu erst einmal einschätzen sollte:
{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Fähigkeit || Empfehlung [[STM32]] || Empfehlung [[AVR]] || Empfehlung PIC || Empfehlung [[MSP430]] || Empfehlung Arduino
|-
| Neueinsteiger, kaum Elektronikkenntnisse, noch nie programmiert || align="center"|O || align="center"|O || align="center"|O [http://www.sprut.de/] || align="center"|- || align="center"|x
|-
| Wunsch ist SD-Card oder Grafik-Display || align="center"|x || align="center"|x || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en537999] [http://www.microchip.com/pagehandler/en-us/technology/graphics/] || align="center"|x || align="center"|x
|-
| Wunsch ist TCP/IP Netzwerk oder Kamera|| align="center"|x || align="center"|O || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2505&param=en535724] || align="center"|O || align="center"|O
|-
| Möchte die Erkenntnisse beruflich nutzen|| align="center"|x || align="center"|x || align="center"|x || align="center"|x || align="center"|-
|-
| Strom sparende Anwendungen|| align="center"|O || align="center"|x || align="center"|x [http://www.microchip.com/pagehandler/en-us/technology/xlp/] || align="center"|x || align="center"|-
|-
| Experimentieren mit Multithreading, RTOS, Schedulern || align="center"|x || align="center"|- || align="center"|O [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en531543&redirects=rtos] || align="center"|- || align="center"|-
|-
| Extrem große Programme || align="center"|x || align="center"|O || align="center"|O || align="center"|O || align="center"|-
|-
| Sehr viel PWM mit komplexem Timing || align="center"|x || align="center"|O || align="center"|O || align="center"|O || align="center"|-
|-
| Deutschsprachige Community || align="center"|O || align="center"|x || align="center"|O || align="center"|- || align="center"|x
|}
* x = ja
* O = Teilweise, Einschränkungen
* - = nicht empfohlen
* ? = Bitte ergänzen

Nur um nicht zu verwirren, auch wenn Teile "nicht empfohlen" sind, heißt dass nicht dass es mit dem Prozessor nicht geht, vielmehr dass es mehr Aufwand ist das zu realisieren oder mehr Einschränkungen hat.

= Unwichtige Randbedingungen =

Oftmals werden fälschlicherweise Argumente für oder gegen eine µC-Familie ausgesprochen, die in der Praxis '''zum Einstieg''' (bei konkreten Anwendungen kann das anders aussehen) eher unwichtig sind.

* Spannungsversorgung 3,3V / 5V
* 8 (z.B. [[AVR]]), 16 (z.B. [[MSP430]]) oder 32 (z.B. [[STM32]]) Bit
* Interrupt System mit mehr oder weniger Features
* Programmiersprache (Assembler, Basic, C, C++, Pascal)
* Assembler verstehen (Sollte nur theoretisch verstanden werden, ein Programm sollte in einer Hochsprache geschrieben sein)
* DIL Gehäuse - steckbretttauglich (STM32-Prozessoren gibt es auch fertig gelötet auf einem steckbretttauglichen Board zum zehnfachen Preis vergleichbarer DIL Mikrocontroller)
* Programmieradapter
* zu 90% reicht doch ein kleiner Prozessor ([[AVR]]/PIC) - und für die restlichen kann man immer noch einen großen nehmen. Warum also nicht gleich einen großen nehmen?

= Kosten =

Grobe Abschätzung was das alles denn kosten wird. Hier sind nur einige Beispiele gezeigt.

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Board || [[STM32]] || [[AVR]] || PIC18/24/32 || [[MSP430]] || Arduino
|-
| Demo-Board || align="center"|[http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419] 9..20€ (incl. Programmieradapter und Debugger) || align="center"|15€ || align="center"| [http://www.microchipdirect.com/ProductDetails.aspx?Catalog=BuyMicrochip&Category=Starter%20Kits&mid=1&lmid=610 durchschnittlich 18€ .. 50€] || align="center"|?? || align="center"|20€
|-
| Steckbrettaugliches Board || align="center"| s.o. oder [http://re.reworld.eu/de/produkte/s64dil-405/index.htm S64DIL-405] 30€ || align="center"|2-5€ als einzelner IC || align="center"|2-5€ als einzelner IC || align="center"|?? || align="center"|??
|-
| Programmieradapter mit Debugger || align="center"| s.o. oder z.B [http://www.segger.com/j-link-edu.html Segger J-LINK EDU] 50€ (sehr schnell und unterstützt viele Prozessoren) || align="center"|?? || align="center"|PICkit 3 30€ [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] || align="center"|?? || align="center"|20€ (Man muss DebugWire aktivieren)
|}

Das Demo-Board sollte ein Board sein, nicht zu teuer, um die ersten Erfahrungen zu sammeln. Wenn einem der Prozessor gefällt, so kann man später immer noch mit einem zweiten Demo-Board, z.B. mit Display aufrüsten.

Wenn man gerne mit einem Steckbrett sich die Schaltung zusammen stecken möchte, so kann man entweder die benötigten Drähte am Demo-Board anlöten oder bei z.B. [[AVR]]/[[PIC]] Prozessoren gibt es Ausführungen im DIL Gehäuse, die direkt steckbar sind.

Ein Programmieradapter sollte unbedingt auch einen Debugger beinhalten. Denn für den Start ist es ungemein hilfreich zu sehen was im Prozessor gerade geschieht. Die JTAG-Adapter für einen [[STM32]] Prozessor sind alle Debugger-Tauglich. Für einen [[AVR]] oder [[PIC]] Prozessor gibt es auch oft reine Programmer (oft Selbstbau-Lösungen über die serielle oder parallele Schnittstelle) welche den Mikrocontroller nur beschreiben können. Sinvoller sind hingegen Debugger (bspw. PIC Kit 3 [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] kompatibel zu allen PIC Mikrocontrollern), die die Ausführung eines Mikrocontrollers anhalten können um die aktuelle Position im Programmcode, Variableninhalt, Register, ... auszulesen bzw. zur Laufzeit zu ändern.

Der für den [[STM32]] empfohlene Segger J-LINK EDU ist zwar nicht der günstigste (z.B. auf einem STM32F4DISCOVERY Borad ist auch einer drauf den man für andere STM32 nutzen kann) aber eines der besten, mit sehr guten Software-Tools und nutzbar für alle Prozessoren mit ARM-Kern (ARM7/9/11/... Cortex-Mx). Niemals am Werkzeug sparen und man hat viel mehr Freude bei der Arbeit.

Der "Arduino" ist kein eigenständiger Prozessor, sondern ein fertiges Board mit einer "Arduino" Programmierumgebung (und einem AVR Prozessor), extra geschaffen für Einsteiger. Allerdings ist da der Lerneffekt viel geringer da man den Prozessor mit der Arduino-Software programmiert und nicht direkt die Register.

Ein [[PIC16]] ist ein älterer 8-Bit Mikrocontroller, der durch die [[PIC18]] Reihe abgelöst wurde. Werden komplexere Anforderungen in Zukunft an den Mikrocontroller gestellt (Audio, Grafik), so sollte zu den moderneren [[PIC24]] bzw. [[dsPIC]] (16-Bit) oder gar zu [[PIC32]] (32-Bit MIPS Prozessor) gegriffen werden, wobei letzterer von der Performance vergleichbar mit den STM32 ARM-basierten Mikrocontrollern ist.

= Programmierumgebungen=

Bei den Programmierumgebungen gibt es zu allen Prozessorfamilien kostenlose und Leistungsfähige Software

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! [[STM32]] || [[AVR]] || PIC || [[MSP430]] || Arduino
|-
| align="center"|[http://www.coocox.org/CooCox_CoIDE.htm CooCox] || align="center"|Atmel-Studio || align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPALB X] (IDE inklusive compiler) || align="center"|?? || align="center"|arduino 1.0.5
|}

natürlich gibt es noch viele weitere (für STM32 siehe [[STM32#Programmierung]]), es sollte jedoch nur die einfachsten kostenlose (und ohne Codebegrenzung) für den ersten Einstieg gezeigt werden.

= Dokumentation=

Bevor man sich für einen Prozessor entscheidet sollte man unbedingt deren Dokumentation mal zumindest überfliegen und auch deren Errata's lesen. Nicht dass man eine Anwendung erstellen möchte und stellt hinterher fest, dass genau dieser Teil so buggy ist das er nicht genutzt werden kann.

Beim [[STM32]] hat die Dokumentation doch recht viele Seiten, viel mehr als bei einem [[AVR]] oder PIC. Dabei ist vieles eher knapp beschrieben, man muss mehr suchen als z.B. bei den AVR-Dokus, um die gewünschten Informationen zu finden. Außerdem gibt es durchaus einige Unklarheiten und Fehler/Widersprüche. Schlussendlich ist es Geschmackssache mit welcher Doku von welchem Hersteller man sich besser zurecht findet.

Bei den PICs gibt es zu jedem Mikrocontroller ein Datenblatt das die wichtigsten Informationen für den alltäglichen Gebrauch enthält. Da bestimmte Peripherie (bspw. I2C, SPI, ... ) aber sehr komplex ist und innerhalb einer Familie (PIC16/18/24/32) sich identisch verhält, gibt es zu jeder Familie die sogenannten Family-Datasheets, welche alle Module im Detail beschreiben.

Parallel zur Dokumentation sollte man sich auch die Demo-Beispiele der Hersteller anschauen, dann wird vieles gleich verständlicher.

Eine Übersicht über die Funktionen gibt es im Artikel: [[STM32]]

= Die Arbeit mit dem STM32=

Zu erst einmal SOOO groß sind die Unterschiede zwischen den einzelnen Prozessoren nicht. Alle haben Ein-/Ausgänge und um mittels einem Port-Pin eine LED ansteuern zu können muss bei jedem Prozessor der Pin erst einmal parametriert werden, egal ob das jetzt ein STM32 oder ein AVR oder ein MSP430 ist. Nur hat man bei einem STM32 doch einige Funktionen mehr, z.B. zuschaltbarer Pull-Up oder Pull-Down Widerstand und spezielle Setz-Rücksetzregister, die andere Prozessoren nicht haben, jedoch das programmieren vereinfachen.
Der Haupt-Unterschied zu den anderen Prozessoren ist, dass der [[STM32]] so viele Peripherie-Module beherbergt, dass man die einzeln immer mit einem Clock aktivieren muss, denn damit lässt sich viel Strom sparen.

Und mal ganz ehrlich die Diskussion welcher µc einfacher zu konfigurieren ist, ist doch absoluter Unsinn. Der Weg ist immer der Gleiche:
*1. Blick ins Datenblatt welche Register für diese Funktion benötigt werden.
*2. Werte ermitteln die in die Register eingetragen werden.
*3. Werte ins Register schreiben. Da machte es GAR KEINEN UNTERSCHIED ob es ein [[AVR]], 8051/2, ARM,...... ist.

Stimmt schon es gibt Unterschiede. Die Register haben anderen Namen, andere Adressen, andere Bitbedeutungen,...
Aber es steht doch alles im Datenblatt. Und ob ich jetzt einen [[AVR]] oder einen ARM das erste mal vor mir liegen hab. Ich brauch in allen Fällen die oben beschriebenen Schritte.

Das Interruptsystem ist bei einem STM32 zusätzlich priorisiert, damit kann man festlegen welcher Interrupt vorrangig bearbeitet wird. Die Prioritätenvergabe ist auch kein Hexenwerk.

Zu allen Prozessoren liefern die jeweiligen Hersteller umfangreiche Demo-Codes und Libraries mit. Meist sind alle in C geschrieben, daher sollte auch die Programmiersprache C verwendet werden. Vor allem auch wenn man berufliche Absichten verfolgt.

Und wenn man einen STM32 kann, dann ist ein Umstieg auf einen LPC17xx (NXP) oder andere Hersteller überhaupt kein Problem, denn die bieten ebenfalls Prozessoren mit Cortex-M3 Kern und man kann diese mit der gleichen Programmierumgebung programmieren. Somit ist man nicht zwingend Herstellerabhängig.

Mit einem STM32 kann man als Hobby-Baster und Professionell nahezu alle Anwendungen realisieren. Der hat genügend RAM und FLASH Speicher und auch genügen Geschwindigkeit. Viele Gehäuse-Varianten um kleine bis hin zu größere Geräte zu erstellen. Viele Schnittstellen, sind im Artikel [[STM32]] beschrieben.

Der einzige Nachteil beim STM32: man muss etwas mehr lesen, da eine Peripherie doch viel mehr Funktionalität hat. Ansonsten kenne ich nicht wirklich einen Grund warum man als Neueinsteiger keinen STM32 nehmen sollte.

= Programmiersprachen =
* Wie bei vielen anderen Controllern wird beim STM32 auch hauptsächlich C und C++ verwendet. Kennen sollte man die Programmiersprache C schon, wenn man davon noch keine Ahnung hat dann sollte man erst mal mittels einem Tutorial auf einem PC ein Konsoleprogramm schreiben, sodass man es einigermaßen kennen lernt. Hier im Forum gibt es ebenfalls Artikel dazu. Zielt man auf die (spätere) Anwendung in der Industrie, sollte aufgrund der Verbreitung auf jeden Fall C (oder C++) gewählt werden; außerdem sind die meisten verfügbaren Libraries in C geschrieben.
* Assembler sollte man nur grob verstehen, Details wie ein Befehl arbeitet ist unwichtig. Selbst wenn man die Zyklen für einen Funktionsaufruf wissen will, so bietet der STM32 (Cortex-M3) einen Cycle-Counter den man auslesen kann; durch die komplexere Pipeline und Cache-Effekte sind die Laufzeiten allerdings nicht genau vorhersehbar. Wird zyklengenause Timing benötigt, sollten Timer verwendet werden - davon hat der STM32 genug.

Der 32bit-Adressraum, der RAM, Flash, I/O-Register vereinheitlicht ansprechen kann (im Gegensatz zu z.B. AVR) ist ideal für eine Verwendung durch Hochsprachen; bei Pointern muss keine zusätzliche Information verwaltet werden, in welche Art Speicher sie zeigen. Die Adresse gibt dies eindeutig an (es gibt nur '''eine''' Adresse 42, und nicht 3 wie beim AVR (Flash, RAM, I/O)) und die Hardware spricht automatisch den richtigen Speicher an. Die Möglichkeiten zur Offset-Adressierung, der Barrel-Shifter, Divsions-Einheit, die FPU (bei STM32F4), Interrupt-Modell etc. begünstigen ebenfalls die Erzeugung effizienteren Codes. Außerdem haben die STM32 einfach mehr "rohe Leistung", d.h. mehr Flash/RAM-Speicher und höhere Taktfrequenzen. 
 
'''Folgerung''': Die Programmierung in Hochsprachen ist '''bequemer als bei 8-Bittern''', denn man muss sich einfach weniger Gedanken machen, ob der Compiler ein Programm nun effizent umsetzen kann (kann man natürlich trotzdem machen, um noch mehr Leistung "herauszuquetschen", wenn man will).

= Weitere Randbedingungen für die Entscheidung=

Der wichtige Punkt, der oftmals auch vergessen wird: die Beschaffbarkeit. Wenn jemand einen Renesas M16C oder Fujitsu empfiehlt, dann sucht man erst mal und findet nur wenige vereinzelte die man privat kaufen kann.

Oder auch die Unterstützung im Internet - ist bei einigen Exoten spärlich. Dieses Forum bietet die beste Hilfe für [[AVR]], PIC, [[STM32]] und [[MSP430]].

Andere Prozessoren sind schon sehr alt, bzw. nicht mehr modern da deren Peripherie zum Teil doch recht eingeschränkte Funktionalität bietet. z.B. viele 8051 Typen oder PIC16. Die mögen für Mini-Anwenungen gut sein, aber wer will den schon gerne sich extra für eine Kleinanwendung mit einem kleinen µC auseinandersetzen, wenn er schon einen STM32 kennt, mit dem er alles machen kann (und sich bereits gute Funktionen geschrieben hat)?

Daher mein Resümee: wer nicht gerade auf den Kopf gefallen ist, der kann getrost mit einem STM32 starten. Ein [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419?s_searchtype=keyword STM32F4DISCOVERY] Board kostet nur ca. 20 EUR - und mehr muss für den ersten Start nicht investiert werden - wenn es doch zu komplex sein sollte gibt es hier im Forum auch Hilfe oder man nimmt erst mal ein "Arduino". Jedenfalls sind diese 20 EUR wirklich keine große Investition.

= Weblinks, Foren, Communities, Tutorials =
* [[STM32]] Hauptartikel, [http://www.mikrocontroller.net/articles/STM32#Weblinks.2C_Foren.2C_Communities.2C_Tutorials dortige Linksammlung]
* [http://www.mikrocontroller.net/topic/319328 Diskussion zum Artikel]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

STM32 für Einsteiger

2013-12-30T12:03:08Z

M-w: Updates, siehe Datenblatt und Forumsdiskussion

Immer wiederkehrend hier im Forum "Mit welchem Mikrocontroller anfangen?". Es gibt eine große Auswahl und eben so viele Empfehlungen. In diesem Artikel soll zu erst geholfen werden ob ein STM32-Prozessor mit Cortex-M3/M4 Kern überhaupt der Richtige für den Start ist.
Nicht für jeden ist der STM32 zu empfehlen, denn die Anforderungen und Wünsche die man realisieren möchte, sowie die eigenen Fähigkeiten sind verschieden.

Es werden meist die Prozessoren AVR, PIC, Arduino, MSP430 und STM32 empfohlen. Seltener auch 8051, LPC und M16C. Alle haben Vorzüge und ebenso auch Nachteile.

= Eigene Fähigkeiten und Wünsche =

Zu erst einmal die Randbedingungen, mit der man sich selbst zu erst einmal einschätzen sollte:
{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Fähigkeit || Empfehlung [[STM32]] || Empfehlung [[AVR]] || Empfehlung PIC || Empfehlung [[MSP430]] || Empfehlung Arduino
|-
| Bereits in der Schule Mikrocontroller programmiert || align="center"|x || align="center"|x || align="center"|x || align="center"|x || align="center"|x
|-
| Neueinsteiger, kaum Elektronikkenntnisse, noch nie programmiert || align="center"|O || align="center"|O || align="center"|O [http://www.sprut.de/] || align="center"|- || align="center"|x
|-
| Wunsch ist SD-Card oder Grafik-Display || align="center"|x || align="center"|x || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en537999] [http://www.microchip.com/pagehandler/en-us/technology/graphics/] || align="center"|x || align="center"|x
|-
| Wunsch ist TCP/IP Netzwerk oder Kamera|| align="center"|x || align="center"|O || align="center"|x [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2505&param=en535724] || align="center"|O || align="center"|O
|-
| Möchte die Erkenntnisse beruflich nutzen|| align="center"|x || align="center"|x || align="center"|x || align="center"|x || align="center"|-
|-
| Strom sparende Anwendungen|| align="center"|O || align="center"|x || align="center"|x [http://www.microchip.com/pagehandler/en-us/technology/xlp/] || align="center"|x || align="center"|-
|-
| Experimentieren mit Multithreading, RTOS, Schedulern || align="center"|x || align="center"|O || align="center"|O [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en531543&redirects=rtos] || align="center"|- || align="center"|-
|-
| Große, komplex strukturierte Programme || align="center"|x || align="center"|O || align="center"|O || align="center"|O || align="center"|-
|-
| Sehr viel PWM mit komplexem Timing || align="center"|x || align="center"|O || align="center"|O || align="center"|O || align="center"|-
|-
| Deutschsprachige Community || align="center"|? || align="center"|x || align="center"|O || align="center"|- || align="center"|x
|}
* x = ja
* O = Teilweise, Einschränkungen
* - = nicht empfohlen
* ? = Bitte ergänzen

Nur um nicht zu verwirren, auch wenn Teile "nicht empfohlen" sind, heißt dass nicht dass es mit dem Prozessor nicht geht, vielmehr dass es mehr Aufwand ist das zu realisieren oder mehr Einschränkungen hat.

= Unwichtige Randbedingungen =

Oftmals werden fälschlicherweise Argumente für oder gegen eine µC-Familie ausgesprochen, die in der Praxis '''zum Einstieg''' (bei konkreten Anwendungen kann das anders aussehen) eher unwichtig sind.

* Spannungsversorgung 3,3V / 5V
* 8 (z.B. [[AVR]]), 16 (z.B. [[MSP430]]) oder 32 (z.B. [[STM32]]) Bit
* Interrupt System mit mehr oder weniger Features
* Programmiersprache (Assembler, Basic, C, C++, Pascal)
* Assembler verstehen (Sollte nur theoretisch verstanden werden, ein Programm sollte in einer Hochsprache geschrieben sein)
* DIL Gehäuse - steckbretttauglich (STM32-Prozessoren gibt es auch fertig gelötet auf einem steckbretttauglichen Board zum zehnfachen Preis vergleichbarer DIL Mikrocontroller)
* Programmieradapter
* zu 90% reicht doch ein kleiner Prozessor ([[AVR]]/PIC) - und für die restlichen kann man immer noch einen großen nehmen. Warum also nicht gleich einen großen nehmen?

= Kosten =

Grobe Abschätzung was das alles denn kosten wird. Hier sind nur einige Beispiele gezeigt.

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Board || [[STM32]] || [[AVR]] || PIC18/24/32 || [[MSP430]] || Arduino
|-
| Demo-Board || align="center"|[http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419] 9..20€ (incl. Programmieradapter und Debugger) || align="center"|15€ || align="center"| [http://www.microchipdirect.com/ProductDetails.aspx?Catalog=BuyMicrochip&Category=Starter%20Kits&mid=1&lmid=610 durchschnittlich 18€ .. 50€] || align="center"|?? || align="center"|20€
|-
| Steckbrettaugliches Board || align="center"| s.o. oder [http://re.reworld.eu/de/produkte/s64dil-405/index.htm S64DIL-405] 30€ || align="center"|2-5€ als einzelner IC || align="center"|2-5€ als einzelner IC || align="center"|?? || align="center"|??
|-
| Programmieradapter mit Debugger || align="center"| s.o. oder z.B [http://www.segger.com/j-link-edu.html Segger J-LINK EDU] 50€ (sehr schnell und unterstützt viele Prozessoren) || align="center"|?? || align="center"|PICkit 3 30€ [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] || align="center"|?? || align="center"|20€ (Man muss DebugWire aktivieren)
|}

Das Demo-Board sollte ein Board sein, nicht zu teuer, um die ersten Erfahrungen zu sammeln. Wenn einem der Prozessor gefällt, so kann man später immer noch mit einem zweiten Demo-Board, z.B. mit Display aufrüsten.

Wenn man gerne mit einem Steckbrett sich die Schaltung zusammen stecken möchte, so kann man entweder die benötigten Drähte am Demo-Board anlöten oder bei z.B. [[AVR]]/[[PIC]] Prozessoren gibt es Ausführungen im DIL Gehäuse, die direkt steckbar sind.

Ein Programmieradapter sollte unbedingt auch einen Debugger beinhalten. Denn für den Start ist es ungemein hilfreich zu sehen was im Prozessor gerade geschieht. Die JTAG-Adapter für einen [[STM32]] Prozessor sind alle Debugger-Tauglich. Für einen [[AVR]] oder [[PIC]] Prozessor gibt es auch oft reine Programmer (oft Selbstbau-Lösungen über die serielle oder parallele Schnittstelle) welche den Mikrocontroller nur beschreiben können. Sinvoller sind hingegen Debugger (bspw. PIC Kit 3 [http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130] kompatibel zu allen PIC Mikrocontrollern), die die Ausführung eines Mikrocontrollers anhalten können um die aktuelle Position im Programmcode, Variableninhalt, Register, ... auszulesen bzw. zur Laufzeit zu ändern.

Der für den [[STM32]] empfohlene Segger J-LINK EDU ist zwar nicht der günstigste (z.B. auf einem STM32F4DISCOVERY Borad ist auch einer drauf den man für andere STM32 nutzen kann) aber eines der besten, mit sehr guten Software-Tools und nutzbar für alle Prozessoren mit ARM-Kern (ARM7/9/11/... Cortex-Mx). Niemals am Werkzeug sparen und man hat viel mehr Freude bei der Arbeit.

Der "Arduino" ist kein eigenständiger Prozessor, sondern ein fertiges Board mit einer "Arduino" Programmierumgebung (und einem AVR Prozessor), extra geschaffen für Einsteiger. Allerdings ist da der Lerneffekt viel geringer da man den Prozessor mit der Arduino-Software programmiert und nicht direkt die Register.

Ein [[PIC16]] ist ein älterer 8-Bit Mikrocontroller, der durch die [[PIC18]] Reihe abgelöst wurde. Werden komplexere Anforderungen in Zukunft an den Mikrocontroller gestellt (Audio, Grafik), so sollte zu den moderneren [[PIC24]] bzw. [[dsPIC]] (16-Bit) oder gar zu [[PIC32]] (32-Bit MIPS Prozessor) gegriffen werden, wobei letzterer von der Performance vergleichbar mit den STM32 ARM-basierten Mikrocontrollern ist.

= Programmierumgebungen=

Bei den Programmierumgebungen gibt es zu allen Prozessorfamilien kostenlose und Leistungsfähige Software

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! [[STM32]] || [[AVR]] || PIC || [[MSP430]] || Arduino
|-
| align="center"|[http://www.coocox.org/CooCox_CoIDE.htm CooCox] || align="center"|Atmel-Studio || align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPALB X] (IDE inklusive compiler) || align="center"|?? || align="center"|arduino 1.0.5
|}

natürlich gibt es noch viele weitere (für STM32 siehe [[STM32#Programmierung]]), es sollte jedoch nur die einfachsten kostenlose (und ohne Codebegrenzung) für den ersten Einstieg gezeigt werden.

= Dokumentation=

Bevor man sich für einen Prozessor entscheidet sollte man unbedingt deren Dokumentation mal zumindest überfliegen und auch deren Errata's lesen. Nicht dass man eine Anwendung erstellen möchte und stellt hinterher fest, dass genau dieser Teil so buggy ist das er nicht genutzt werden kann.

Beim [[STM32]] hat die Dokumentation doch recht viele Seiten, viel mehr als bei einem [[AVR]] oder PIC. Dabei ist vieles eher knapp beschrieben, man muss mehr suchen als z.B. bei den AVR-Dokus, um die gewünschten Informationen zu finden. Außerdem gibt es durchaus einige Unklarheiten und Fehler/Widersprüche. Schlussendlich ist es Geschmackssache mit welcher Doku von welchem Hersteller man sich besser zurecht findet.

Bei den PICs gibt es zu jedem Mikrocontroller ein Datenblatt das die wichtigsten Informationen für den alltäglichen Gebrauch enthält. Da bestimmte Peripherie (bspw. I2C, SPI, ... ) aber sehr komplex ist und innerhalb einer Familie (PIC16/18/24/32) sich identisch verhält, gibt es zu jeder Familie die sogenannten Family-Datasheets, welche alle Module im Detail beschreiben.

Parallel zur Dokumentation sollte man sich auch die Demo-Beispiele der Hersteller anschauen, dann wird vieles gleich verständlicher.

Eine Übersicht über die Funktionen gibt es im Artikel: [[STM32]]

= Die Arbeit mit dem STM32=

Zu erst einmal SOOO groß sind die Unterschiede zwischen den einzelnen Prozessoren nicht. Alle haben Ein-/Ausgänge und um mittels einem Port-Pin eine LED ansteuern zu können muss bei jedem Prozessor der Pin erst einmal parametriert werden, egal ob das jetzt ein STM32 oder ein AVR oder ein MSP430 ist. Nur hat man bei einem STM32 doch einige Funktionen mehr, z.B. zuschaltbarer Pull-Up oder Pull-Down Widerstand und spezielle Setz-Rücksetzregister, die andere Prozessoren nicht haben, jedoch das programmieren vereinfachen.
Der Haupt-Unterschied zu den anderen Prozessoren ist, dass der [[STM32]] so viele Peripherie-Module beherbergt, dass man die einzeln immer mit einem Clock aktivieren muss, denn damit lässt sich viel Strom sparen.

Und mal ganz ehrlich die Diskussion welcher µc einfacher zu konfigurieren ist, ist doch absoluter Unsinn. Der Weg ist immer der Gleiche:
*1. Blick ins Datenblatt welche Register für diese Funktion benötigt werden.
*2. Werte ermitteln die in die Register eingetragen werden.
*3. Werte ins Register schreiben. Da machte es GAR KEINEN UNTERSCHIED ob es ein [[AVR]], 8051/2, ARM,...... ist.

Stimmt schon es gibt Unterschiede. Die Register haben anderen Namen, andere Adressen, andere Bitbedeutungen,...
Aber es steht doch alles im Datenblatt. Und ob ich jetzt einen [[AVR]] oder einen ARM das erste mal vor mir liegen hab. Ich brauch in allen Fällen die oben beschriebenen Schritte.

Das Interruptsystem ist bei einem STM32 zusätzlich priorisiert, damit kann man festlegen welcher Interrupt vorrangig bearbeitet wird. Die Prioritätenvergabe ist auch kein Hexenwerk.

Zu allen Prozessoren liefern die jeweiligen Hersteller umfangreiche Demo-Codes und Libraries mit. Meist sind alle in C geschrieben, daher sollte auch die Programmiersprache C verwendet werden. Vor allem auch wenn man berufliche Absichten verfolgt.

Und wenn man einen STM32 kann, dann ist ein Umstieg auf einen LPC17xx (NXP) oder andere Hersteller überhaupt kein Problem, denn die bieten ebenfalls Prozessoren mit Cortex-M3 Kern und man kann diese mit der gleichen Programmierumgebung programmieren. Somit ist man nicht zwingend Herstellerabhängig.

Mit einem STM32 kann man als Hobby-Baster und Professionell nahezu alle Anwendungen realisieren. Der hat genügend RAM und FLASH Speicher und auch genügen Geschwindigkeit. Viele Gehäuse-Varianten um kleine bis hin zu größere Geräte zu erstellen. Viele Schnittstellen, sind im Artikel [[STM32]] beschrieben.

Der einzige Nachteil beim STM32: man muss etwas mehr lesen, da eine Peripherie doch viel mehr Funktionalität hat. Ansonsten kenne ich nicht wirklich einen Grund warum man als Neueinsteiger keinen STM32 nehmen sollte.

= Programmiersprachen =
* Wie bei vielen anderen Controllern wird beim STM32 auch hauptsächlich C und C++ verwendet. Kennen sollte man die Programmiersprache C schon, wenn man davon noch keine Ahnung hat dann sollte man erst mal mittels einem Tutorial auf einem PC ein Konsoleprogramm schreiben, sodass man es einigermaßen kennen lernt. Hier im Forum gibt es ebenfalls Artikel dazu. Zielt man auf die (spätere) Anwendung in der Industrie, sollte aufgrund der Verbreitung auf jeden Fall C (oder C++) gewählt werden; außerdem sind die meisten verfügbaren Libraries in C geschrieben.
* Assembler sollte man nur grob verstehen, Details wie ein Befehl arbeitet ist unwichtig. Selbst wenn man die Zyklen für einen Funktionsaufruf wissen will, so bietet der STM32 (Cortex-M3) einen Cycle-Counter den man auslesen kann; durch die komplexere Pipeline und Cache-Effekte sind die Laufzeiten allerdings nicht genau vorhersehbar. Wird zyklengenause Timing benötigt, sollten Timer verwendet werden - davon hat der STM32 genug.

Der 32bit-Adressraum, der RAM, Flash, I/O-Register vereinheitlicht ansprechen kann (im Gegensatz zu z.B. AVR) ist ideal für eine Verwendung durch Hochsprachen; bei Pointern muss keine zusätzliche Information verwaltet werden, in welche Art Speicher sie zeigen. Die Adresse gibt dies eindeutig an (es gibt nur '''eine''' Adresse 42, und nicht 3 wie beim AVR (Flash, RAM, I/O)) und die Hardware spricht automatisch den richtigen Speicher an. Die Möglichkeiten zur Offset-Adressierung, der Barrel-Shifter, Divsions-Einheit, die FPU (bei STM32F4), Interrupt-Modell etc. begünstigen ebenfalls die Erzeugung effizienteren Codes. Außerdem haben die STM32 einfach mehr "rohe Leistung", d.h. mehr Flash/RAM-Speicher und höhere Taktfrequenzen. 
 
'''Folgerung''': Die Programmierung in Hochsprachen ist '''bequemer als bei 8-Bittern''', denn man muss sich einfach weniger Gedanken machen, ob der Compiler ein Programm nun effizent umsetzen kann (kann man natürlich trotzdem machen, um noch mehr Leistung "herauszuquetschen", wenn man will).

= Weitere Randbedingungen für die Entscheidung=

Der wichtige Punkt, der oftmals auch vergessen wird: die Beschaffbarkeit. Wenn jemand einen Renesas M16C oder Fujitsu empfiehlt, dann sucht man erst mal und findet nur wenige vereinzelte die man privat kaufen kann.

Oder auch die Unterstützung im Internet - ist bei einigen Exoten spärlich. Dieses Forum bietet die beste Hilfe für [[AVR]], PIC, [[STM32]] und [[MSP430]].

Andere Prozessoren sind schon sehr alt, bzw. nicht mehr modern da deren Peripherie zum Teil doch recht eingeschränkte Funktionalität bietet. z.B. viele 8051 Typen oder PIC16. Die mögen für Mini-Anwenungen gut sein, aber wer will den schon gerne sich extra für eine Kleinanwendung mit einem kleinen µC auseinandersetzen, wenn er schon einen STM32 kennt, mit dem er alles machen kann (und sich bereits gute Funktionen geschrieben hat)?

Daher mein Resümee: wer nicht gerade auf den Kopf gefallen ist, der kann getrost mit einem STM32 starten. Ein [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419?s_searchtype=keyword STM32F4DISCOVERY] Board kostet nur ca. 20 EUR - und mehr muss für den ersten Start nicht investiert werden - wenn es doch zu komplex sein sollte gibt es hier im Forum auch Hilfe oder man nimmt erst mal ein "Arduino". Jedenfalls sind diese 20 EUR wirklich keine große Investition.

= Weblinks, Foren, Communities, Tutorials =
* [[STM32]] Hauptartikel, [http://www.mikrocontroller.net/articles/STM32#Weblinks.2C_Foren.2C_Communities.2C_Tutorials dortige Linksammlung]
* [http://www.mikrocontroller.net/topic/319328 Diskussion zum Artikel]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

Bierdeckel-Programmer

2013-11-29T20:18:56Z

M-w: Verbesserung der Schaltung

Datei:Bierdeckel verdrahtung.png

2013-11-29T20:15:07Z

M-w: M-w lud eine neue Version von „Datei:Bierdeckel verdrahtung.png“ hoch: neue Bierdeckel-Version: 100-nF-Kondensator hinzugefügt, MISO-Widerstand entfernt.

Verdrahtungsplan für den Bierdeckel-Programmer

Linksammlung

2013-09-19T20:14:36Z

M-w: /* Programmierhard- und Software */

Auf dieser Seite werden Links zu anderen interessanten Mikrocontroller- und Elektronikseiten gesammelt.
'''
Die alte Linkseite findet man [http://www.mikrocontroller.net/en/links hier].

Hinzufügen von Links:
# [http://www.mikrocontroller.net/wikisoftware/index.php?title=Linksammlung&action=edit Bearbeiten] anklicken
# Link unter der entsprechenden Kategorie eintragen
# "Artikel speichern" klicken

== Suchen & Finden ==

''Verkauf einem hungrigen Mann einen Fisch und du hast ein Geschäft gemacht, bring ihm das Angeln bei und du hast einen Kunden verloren! (asmo)''

* [http://www.supplyframe.com/ SupplyFrame] - Datasheet and Electronic Spec Search Engine
* [http://www.globalspec.com/ GlobalSpec] - The Engineering Search Engine
* [http://www.alldatasheet.com/ alldatasheet] - Datasheet Search
* [http://www.datasheetarchive.com/ datasheetarchive] - Datasheet Search
* [http://www.datasheetcatalog.com/ datasheetcatalog] - Datasheet Search
* [http://www.msarnoff.org/chipdb/ ChipDB] - Pinouts von gängigen µCs.


== [[AVR]] ==

=== Herstellerseiten ===

* [http://www.atmel.com/products/avr/ Atmel.com] Herstellerseiten
* [http://www.atmel.com/dyn/products/product_whatchanged.asp?category_id=163&family_id=607 Atmel.com updates] Liste der letzten Änderungen in Datenblättern und Beispielcode für AVR(8) und AVR32
* [http://www.msc-ge.com/de/produkte/elekom/mc/atmel/avr_start.html AVR Produktinfos] AVR Infos vom Atmel Distributor MSC Vertriebs GmbH
* [http://www.siebert-group.com/ Siebert Group] Siebert Group Industrie Electronik

=== Information (Foren, Mailinglisten, Linksammlungen) ===
* [http://progforum.com Batronix Elektronik Forum] Gut besuchtes Forum für allgemeine Elektronik, Mikrocontroller und Programmierung
* [http://www.avrfreaks.net/ AVR Freaks] AVR Forum, Samples, Tutorials, User-Projekte, GCC für AVR (Registrierung empfohlen)
* [http://avr-asm.tripod.com Atmel AVR ASM Site]
* [http://www.mikrocontroller.net Mikrocontroller.net] - AVR Tutorials, Examples, LINKS, Forum (D)


* [http://www.ipass.net/hammill/newavr.htm Atmel AVR Embedded Microcontroller Resources]
* [http://members.tripod.com/Stelios_Cellar/AVR/AVR%20Info.html Stelios Cellar Atmel AVR Info Page] - Samples, Links
* [http://www.elektronik-projekt.de Elektronik Projekt] - Hauptthemen sind AVR und Roboter


* [http://popularmicrocontrollers.com/ AVR Microcontrollers] - A web site about AVR microcontrollers


=== Entwicklungswerkzeuge (Compiler/Assembler/Debugger/Tools/Libraries) ===

==== C ====
* [http://sourceforge.net/projects/winavr WinAVR] (pronounced "whenever") is a suite of executable, open source software development tools for the Atmel AVR series [for the] Windows platform" (includes GNU GCC)
* [http://sourceforge.net/projects/kontrollerlab KontrollerLab] is a free GPL open-source development environment based on KDE, using the avr-gcc, UISP and AVRDUDE
* [http://www.nongnu.org/avr-libc/ avr-libc] avr-gcc's "standard"-library

* [http://hubbard.engr.scu.edu/embedded/avr/avrlib/ Procyon AVRlib] a lot of device drivers and Visual-Studio link for avr-gcc
* [http://rod.info/avr.html rod.info on AVR] esp. for AVR GNU development tools setup under Linux
* [http://www.sisy.de SiSy AVR] - graphische Entwicklungsumgebung mit C/C++ Codegenerierung aus Struktogrammen und Klassendiagrammen
* [http://shop.embedit.de/product__206.php AtmanAVR C/C++ IDE]
* [http://www.iar.com IAR Embedded Workbench]
* [http://www.hpinfotech.com CodeVisionAVR] C-Compiler für AVRs mit Terminal
* [http://www.myAVR.de myAVRWorkpad] kompakte Entwicklungsumgebung für AVRs mit Terminal
* [http://www.amctools.com/vmlab.htm VMLab] komplette IDE mit Debugger und Simulator (auch Peripheriehardware)
* [http://www.forestmoon.com/Software/AvrIoDesigner/ AVR IO Designer] is a utility to generate initialization source code in C/C++ for the various devices, ports and registers of Atmel AVR processors. The intent is to allow the user to explore the devices specific to a selected processor and experiment with settings thru a user interface that assists in understanding the complexities involved. The user can also assign custom variable names to PORT IO pins thereby keeping track of the IO resources in use. These names are emitted in the generated code for use in the user’s program. (Windows .NET 2.0 erforderlich)
* [http://www.piconomic.co.za/avrlib/index.html Piconomic AVRLIB] is a collection of firmware for Atmel AVR microcontrollers. The aim is to share source code, experience and expertise (in the eye of the beholder) with the community of engineers, scientists and enthusiasts.
* [http://www.imagecraft.com/devtools_AVR.html Imagecraft] Der ICCAVR C Compiler fuer AVR von Imagecraft.

==== Assembler ====

* [http://avr-asm.tripod.com Atmel AVR ASM Site]
* [http://www.tavrasm.org/ tavrasm] - Toms Linux (Atmel) AVR Assembler
* [http://www.avr-asm-tutorial.net/gavrasm/index_de.html gavrasm] - Gerds Linux/Win/DOS AVR Assembler
* [http://avra.sourceforge.net/ avra] - avra ATMEL AVR Assembler für Linux, FreeBSD, AmigaOS und Win32
* [http://algrom.net/english.html Algorithm Builder] - graphische Makro-Assembler Entwicklungsumgebung
* [http://www.sisy.de SiSy AVR] - graphische Entwicklungsumgebung mit Assembler Codegenerierung aus Programmablaufplänen
* [http://www.sbprojects.com/sbasm/sbasm.htm SB-Assembler] - Freeware Cross-Assembler unter DOS. (6502, 6800, 6801, 6804, 6805, 6809, 68HC08, 68HC11, Z8, Z80, Z180, 8080, 8085, 8021, 8041, 8048, 8051, AVR, PIC1684,...)
* [http://www.myAVR.de myAVRWorkpad] kompakte Entwicklungsumgebung für AVRs mit Terminal
* [http://john.ccac.rwth-aachen.de:8000/as/ Macro Assembler AS] - AS is a portable macro cross assembler for a variety of microprocessors and -controllers
* [http://shop-pdp.kent.edu/ashtml/asxxxx.htm ASxxxx Cross Assemblers] - The ASxxxx assemblers are a series of microprocessor assemblers written in the C programming language. (1802, S2650, C/MP, MSP430, 61860, 6500, 6800(6802/6808), 6801(6803/HD6303), 6804, 6805, 68HC(S)08, 6809, 68HC11, 68HC(S)12, 68HC16, 740, 8048(8041/8022/8021) 8051, 8085(8080), DS8xCxxx, AVR, Z80, F2MC8L/FX, GameBoy(Z80), H8/3xx, Cypress PSoC(M8C), PIC, Rabbit 2000/3000, Z8, Z80(HD64180)) linux & windows, source code
* [http://www.i8086.de/asm/8086-88-asm.html 8086/88 Assembler Befehlsreferenz] - Informationen zum Befehlssatz, Registern und Speicheradressierung

==== Disassembler ====

* [http://www.datarescue.com/idabase/ IDA-Pro] -Disassembler und Debugger für fast alle bekannten Prozessoren. Evaluation Version verfügbar. Tagline: ''The most advanced tool for Hostile Code Analysis, Vulnerability and Software Reverse Engineering''
* [http://www.jassenbaum.de/ja-tools/ ReAVR] - Disassembler und ACXutility Binary Tool
* [http://www.visi.com/~dwinker/revava/ revava] - Disassembler
* [http://dev.frozeneskimo.com/software_projects/vavrdisasm vAVRdisasm] - Free AVR Disassembler
* [http://www.johannes-bauer.com/mcus/avrdisas/ avrdisas] - AVR Mikrocontroller Disassembler für Linux (und Win32)


==== BASIC ====
* [http://www.mcselec.com/bascom-avr.htm Bascom AVR]
* [http://www.fastavr.com FastAVR] - und mit 'ASM' Ausgabe, Nokia3310 LCD Unterstützung
* [http://www.nettypes.de/mbasic mikrocontrollerBASIC Freeware] - mit Simulator für ATmega32, ATmega128 und C-CONTROL.
* [http://www.mikroe.com/en/compilers/mikrobasic/avr/ mikroBasic] - Comprehensive, stand-alone Basic compiler for AVR microcontrollers
* [http://home.arcor.de/EDAconsult/Page3/index.html?c~3.1 MCS BASIC-52] - Original-Übersetzung 1988 INTEL MCS BASIC-52 USERS MANUAL 220 Seiten frei Download als PDF
* [http://www.DieProjektseite.de Beetle-Basic] Leistungsfähiges Basic-Betriebssystem im AVR.
* [http://www.mikrocontroller.net/articles/AVR_BASIC AVR_BASIC] Open Source Freeware: Minimalistischer Basic-Interpreter im AVR.
* [http://gcbasic.sourceforge.net/ Great Cow BASIC] "Open Source BASIC programming tools for Microchip PIC and Atmel AVR microcontrollers"

==== Pascal ====
* [http://www.e-lab.de AVRco Pascal Compiler] - AVR Pascal Compiler mit umfangreicher Funktionslibrary
* [http://www.mikroe.com/en/compilers/mikropascal/avr/ mikroPascal] - Comprehensive, stand-alone Pascal compiler for AVR microcontrollers

==== Forth ====
* [http://www.robo-forth.de www.robo-forth.de] - AVR Forth Compiler mit umfangreicher Funktionslibrary für Servos, Motore und Sensoren
* [http://amforth.sourceforge.net/ amforth] - Forth for Atmel ATmega micro controllers von Matthias Trute. [http://www.mikrocontroller.net/topic/55807#430816 Diskussion]

==== Java ====
* [http://www.harbaum.org/till/nanovm NanoVM] - Java VM für AVR-Mikrocontroller ([[NanoVM|deutsches Wiki]])
* [http://www.fam-frenz.de/stefan/compiler.html SJC] - Java-Compiler (erzeugt AVR-Maschinencode) für AVR-Mikrocontroller ([[SJC]])

==== Ada ====
* [http://avr-ada.sourceforge.net/ AVR-Ada] - Ada Compiler innerhalb von GCC (GNAT) für AVR. Enthält eine kleine Laufzeitbibliothek ohne Tasking und ohne Exceptions. [http://www.mikrocontroller.net/topic/168823#1614208]

==== Virgil ====
* [http://compilers.cs.ucla.edu/virgil/index.html The Virgil Programming Language] is designed for building robust, flexible, and scalable software systems on embedded hardware platforms. Virgil builds on ideas from object-oriented, statically typed languages like Java, providing a clean, consistent source language. Its compiler system provides an efficient implementation for resource-constrained environments.

==== LabVIEW ====
* http://www.ni.com/embedded/ Informationen zu LabVIEW, der graphischen Entwicklungsumgebung von National Instruments
* http://www.labviewforum.de/ Deutsches Labview-Forum
* [http://web.me.com/iklln6/automation/LabVIEW.html Communicating Arduino-->LabVIEW]

==== Python ====
* [http://code.google.com/p/python-on-a-chip/ python-on-a-chip] (pymite). There are two sample projects in the source tree. One for an 8-bit Atmel ATmega103 (but any AVR/ATmega with 4 KB RAM or more will do) and one for the 32-bit Atmel AT91SAM7S64 running on the AT91SAM7S-EK evaluation board. (GPL Lizenz)

==== Openeye ====

* OpenEye ist eine Kombination aus PC-Programm (Windows, Delphi) und einer Monitor-Routine im AVR. Die Daten aus dem AVR werden mit RS232 übertragen und können fürs Debuggen der laufenden Anwendung benutzt werden. OpenEye wurde vom User Martin Vogel (oldmax) geschrieben [http://www.mikrocontroller.net/topic/143144#1326244].

==== Modkit ====

[http://blog.modk.it/ Modkit] is a new kind of graphical programming environment that makes programming things in the physical world as easy as dragging and dropping little virtual code blocks in a web browser.. Heavily inspired by the Scratch programming environment (from MIT Media Lab's Lifelong Kindergarten Group), Modkit enables anyone including kids, artists and inventors to build with electronic kits and components including motors, sensors, lights, sound and the popular Arduino and Arduino compatible development boards... (Text vom Makezine)

=== Tutorials und Beispiele ===

* [http://www.meinemullemaus.de/elektronik/avr_workshop/index.html AVR Mikrocontroller] Einfühung in AVR Mikrocontroller mit Nachbau des Spiels "Senso".
* [http://www.avrbeginners.net AVRBeginners.net] Beginners Guides to AVRs
* [http://www.wikidorf.de/reintechnisch/Inhalt/AVRProjekt-9V-LED-Lampe reintechnisch.de] AVR Tutorial: 9V-LED-Lampe
* [http://www.schaltungsforum.de Das Schaltungsforum] ist eine Seite für Anfänger und Profis welche ständig mit Tutorials erweitert wird. Stellt Eure Projekte online. Die Seite befindet noch im Aufbau und Eure Mithilfe ist erwünscht.
* [http://www.mikrocontrollerspielwiese.de mikrocontrollerspielwiese.de] ist eine Seite, die an Anfänger gerichtet ist und Experimente und fertige Projekte komplett mit Code und Eagle-Dokumenten zur Verfügung stellt.
* [http://www.elo-web.de/elo/mikrocontroller-und-programmierung/avr-anwendungen ELO-AVR-Anwendungen] bietet eine wachsende Sammlung kleinerer AVR-Projekte, überwiegend für die ATTiny-Serie.
* [http://www.schramm-software.de/tipps/ AVR-Tipps] Programmier-Tipps und AVR-Experimente.
* [http://www.uwe-kerwien.de/pll/pll-synthesizer.htm PLL-Synthesizer Tutorial] kleines praxisorientiertes PLL-Tutorial zur Funktion, Reparatur und Steuerung einer PLL-Schaltung mit AVR ATtiny2313 über 3-Leiter-Bus
* Arduino
** [http://tronixstuff.wordpress.com/tutorials/ t r o n i x s t u f f] - Arduino Tutorials (engl.)
** [http://www.earthshinedesign.co.uk/ASKManual/Site/ASKManual.html The Complete Beginners Guide to the Arduino]
** [http://www.codeproject.com/KB/system/ArduinoVB.aspx Arduino with Visual Basic] by Carl Morey auf codeproject.com

==== C ====
* [[AVR-GCC-Tutorial]]
* [http://www.smileymicros.com/QuickStartGuide.pdf Quick Start Guide for using the WinAVR Compiler with ATMEL's AVR Butterfly] ([http://www.smileymicros.com www.smileymicros.com], PDF)
* [http://www.avrtutor.com/tutorial/thermo/contents.htm avrtutor] - an attempt to provide a real tutorial for the ATMEL AVR microcontrollers.
* [http://www.sparkfun.com/commerce/present.php?p=BEE-1-PowerSupply Spark Fun Electronics] - Beginning Embedded Electronics (Atmega8, englisch)
* [http://metku.net/index.html?path=articles/microcontroller-part-1/index_eng metku.net] - How to get started with microcontrollers (ATtiny45, Steckbrett)
* [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial XMEGA-C-Tutorial] - Tutorial über Atxmega
* [http://www.jtronics.de/avr-projekte/xmega-tutorial.html XMEGA Tutorial in C] - Tutorial ATxmega (unter anderen am ATxmega128A3U)

==== C++ ====
* [http://www.avr-cpp.de/ www.avr-cpp.de] - Tutorial für AVR C++ und myAVR Bibliotheken

==== Assembler ====
* [http://avr-asm.tripod.com Atmel AVR ASM Site]
* [http://www.avr-asm-tutorial.net Atmel AVR Microcontroller Assembler Tutorial] (D)
* [[AVR-Studio]]

==== Bascom ====
* [http://www.mcselec.com/ MCS Elektronik] BASCOM AVR Demo zum Download

==== Pascal ====
* [http://www.elektronik-projekt.de/content/download/avrco_tut2.pdf AVRco Pascal Tutorial] - von Markus
* [http://www.ibrtses.com/embedded/avr.html ein paar Seiten zum AVR] (ASM und Pascal) von ibrt

==== Ada ====
* [http://sourceforge.net/apps/mediawiki/avr-ada/index.php?title=Tutorial AVR-Ada Tutorial]

=== Hardware (Prototypen-Platinen-Boards etc.) ===

* [http://retrodan.tripod.com Atmel AVR Butterfly Site]
* [http://www.kanda.com Kanda] Starter Kits and Development Tools for different Microcontrollers
* [http://www.dontronics.com Dontronics] Starter Kits and Development Tools for different Microcontrollers, Linkpages for AVR and PIC
* [http://www.mikrocontroller.com mikrocontroller.com] u.a. Platine AVR-Ctrl, AVR-Webserver (D)
* [http://mikrocontroller.cco-ev.de/eng/ AVR webserver] RTL8019, 3COM (E)
* [http://www.microcontroller-starterkits.de Microcontroller-Starterkits] Starter Kits for different Microcontrollers (D)
* [http://www.olimex.com Olimex Ltd.] DevelopmentBoards and Tools
* [http://www.krause-robotik.de Krause Robotik] Controller Boards & Zubehör
* [http://www.robotikhardware.de robotikhardware.de] Controller Boards
* [http://www.embedded-it.de/microcontroller/microcontroller-module.php Embedded-IT] USB Module auf AVR Basis sowie Ethernut kompatible Embedded Ethernet Mikrocontroller Boards für Industrie und Hobby auf ARM mit Nut/OS Betriebssystem
* [http://www.ssv-embedded.de SSV Embedded Systems] 32-bit Mikrocontrollermodule und -boards, Starter Kits etc.
* [http://shop.embedit.de/browse_002_21__.php Embedit] Mikrocontrollermodule und -boards
* [http://www.display3000.com Display3000] Farbdisplays, Mikrocontrollermodule und -boards mit TFT-Farbdisplays; Experimentierplatinen und Ansteuerplatinen für TFT Farbdisplays
* [http://www.myavr.de myAVR] Einsteigerboards und Zubehör
* [http://www.siphec.com/ SIPHEC] Development Boards für AVR, MSP430, USB
* [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MTY5OTgxOTk=&w=OTk4OTY4&ts=0 ATMEL Evaluations-Board Bausatz] ([http://www.pollin.de/shop/downloads/D810038B.PDF PDF]) und [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MzU5OTgxOTk=&w=OTk4OTY4&ts=0 ATMEL Funk-Evaluations-Board Bausatz] ([http://www.pollin.de/shop/downloads/D810046B.PDF PDF]) von Pollin
* [http://www.lochraster.org/etherrape/ Etherrape] Atmaga 644 mit Ethernet und TCP/IP als Bausatz.
* [http://www.ic-board.de/index.php?cat=c4_Programmer.html AVR Programmieradapter],[http://www.ic-board.de/index.php?cat=c3_Funkmodule.html ZigBee-ready Funkmodule/Funk-USB-Sticks] und [http://www.ic-board.de/index.php?cat=c13_ICradio-Bundles.html Funk Starterkits] von In-Circuit
* [http://www.ic-board.de/index.php?cat=c2_ICnova-Module.html AVR32 AP7000 Linux Board] mit 2xEthernet, TFT, Audio, SDCARD, USB-Host/Devive, Funk...
* [http://www.das-labor.org/wiki/Laborboard Das Laborboard] von das-labor.org (DIY)
* [http://six.media.mit.edu:8080/6 number six] - Open Source Design, Atmega32. Alle Pins sind auf eine 2x20 Pol Wannenstiftleiste herausgeführt.
* http://www.maares.de/tools USB Memory Stick am AVR Butterfly. AVR Butterfly Trägerplatine zum Anschluß von VDRIVE, VMUSIC, RFM12.
* [http://www.wiring.org.co/ Wiring] is an open source programming environment and electronics i/o board for exploring the electronic arts, tangible media, teaching and learning computer programming and prototyping with electronics.
* [http://www.chip45.com/ chip45] Atmel AVR Module und Boards mit USB, RS232/485, CAN, Ethernet, Funkmodule, sowie ISP Programmieradapter.
* [http://www.rakers.de/catalog Dr. Rakers] AVR Boards und Experimentierplatinen mit USB, Ethernet, RS232, CAN, LCD etc. in hochwertiger Qualität zu günstigen Preisen.
* [http://nibo.nicai-systems.de Roboterbausatz Nibo] - autonomer Roboter mit einem ATmega128 und einem ATmega88
* [http://www.aevum-mechatronik.de Modularis] - AVR Mikrocontroller-Boards (z.T. mit Zusatz-Speicher und USB) die über Flachbandkabel erweitert werden können. Es gibt bis jetzt Zubehör-Module mit Taster, Motor H-Brücke, XBee und Winkelsensor.
* [http://www.schramm-software.de/bausatz/ Schramm-Software] - AVR Mikrocontroller-Bausätze
* [http://www.alvidi.de/ Alvidi] - Headerboards mit AVR & AVR32 Controllern
* [http://www.steitec.net/ Steinert Technologies] - Thailändischer Anbieter von Mikrocontroller Boards (AVR, ARM7, ARM9, PIC, dsPIC, PSoC, uvm.)
* Arduino
** [http://www.arduino.cc/ Arduino] Homepage
** [http://www.freeduino.org/ Freeduino.org] - Riesige Linksammlung zu dem '''Ardunio'''(R) AVR-Board (Kit) und dessen Clones und Mutanten (DIY oder Kit)
** [http://www.freeduino.de/ freeduino.de] - Anleitungen und Tutorials, Arduino Wiki, Blog, Tools in Deutsch
** [http://shieldlist.org/ Arduino Shield List]
* [http://www.fritzing.org Fritzing] nützliches Programm für viele Betriebsysteme zur Unterstützung eines Brettboard-Aufbaus(ungetestet).
* [http://www.specialprint.eu Specialprint] InkjetDruck für den digitalen Direktdruck von Ätzmasken, Lötstoppmasken, Frontplatten, Kennzeichnungen
* [http://www.onlinesteuerung.de Onlinesteuerung.de] USB Bausatz. Technische Geräte per PC, Browser, Netzwerk, Ethernet, TCP/IP, Internet, Excel, Timer oder Sensoren schalten.
* [http://8devices.com/product/3/wi-fi-4-things Carambola WiFi module] Open hardware Linux friendly (OpenWRT) WiFi 802.11n OEM module
* [http://www.atxmega-board.de ATxMegaBoard und ATxMegaStick] Entwicklungsboards, zum Einstig in die Welt der ATxMegas
* [http://thinkembedded.ch/AVR:::21.html Thinkembedded Webshop, Schweiz] div. Olimex Demoboarde ab SFr 18.- / 14 Euro

=== Programmierhard- und Software ===
* [http://www.obdev.at/products/avrusb/avrdoper.html AVR-Doper] Einfach nachzubauender, STK500-kompatibler Programmer mit USB-Anschluss. Beherrscht auch HVSP, nicht jedoch HVPP. Open Source.
* [http://www.bsdhome.com/avrdude/ AVRDUDE] AVR ISP-Programmerierwerkzeug für Unix/Linux/BSD und Windows. Kommandozeile [http://sourceforge.net/projects/avrdude-gui/ (oder mit GUI)], AVR Butterfly-Unterstützung
* [http://www.lancos.com/prog.html PonyProg] neben AVR für diverse seriell programmierbare Bauteile (Grafische Nutzeroberfläche und Kommandozeile), siehe auch [[Pony-Prog Tutorial]]
* [http://savannah.nongnu.org/projects/uisp/ uisp] AVR ISP-Programmierwerkzeug für Unix/Linux/BSD und Windows (Kommandozeile)
* [http://www.myplace.nu/avr/yaap/ yaap]
* [http://www.xs4all.nl/~sbolt/e-index.html SP12]
* [http://www.mikrocontroller-projekte.de/Mikrocontroller/AVR-Prog/AVR-Programmer.html AVR910 kompatibler Programmer] mit aktueller, beschleunigter Firmware.
* [http://www.der-hammer.info/hvprog STK500 kompatibler Programmer] als Nachbauprojekt. Siehe auch [[STK500]]
* [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=73&products_id=41 Preiswerter Standard ISP (STK200 kompatibel)]
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/evertool/ Evertool] kombinierter ISP & [[JTAG]] Programmer (kompatibel zum "original" Atmel AVRISP und Atmel JTAGICE)
* [http://www.olimex.com Olimex] (Bulgarischer Anbieter) Kostengünstig
* [http://www.avr-projekte.de/isp.htm AVR910-USB Programmer] incl. USB-Modul und USB->Seriell Wandler
*[http://www.fischl.de/usbasp/ USBasp] – USB-Programmer bestehend aus ATmega8 (kein spezieller USB-Chip notwendig)
* [https://guloshop.de/shop/Mikrocontroller-Programmierung/guloprog-der-Programmer-von-guloshop-de::70.html USBasp – USB-Programmer guloprog] (ca. 5,00 €) mit Signalwandlerfunktion, bestehend aus ATtiny85 (kein spezieller USB-Chip notwendig)
* [[Bierdeckel-Programmer]] – USBasp mit ATtiny85, sehr wenige Bauteile, leicht nachzubauen
* [http://home.arcor.de/bernhard.michelis Amadeus-USB] - Highspeed-Programmer für PIC18, PIC24, dsPIC30, PIC32, dsPIC33 und AVR. Bietet auch Möglichkeiten zur Fehlersuche.
* [http://www.e-dsp.com Signalgenerator] - Signalgenerator software
* [http://www.piketec.com/products/tpt.php Time Partition Testing (TPT)] - Test-, und Testauswertewerkzeug für eingebettete Systeme
* [http://shop.myavr.de/Programmer.htm?sp=artlist_kat.sp.php&katID=16 mySmartUSB] - USB Programmer (ab 15€) kombiniert auch mit USB-UART-Bridge, STK500v2/AVR910/AVR911 kompatibel, ISP HV-seriell, HV-parallel
* [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=73&products_id=161 USB-Programmer für Bascom Programmierer]
* [http://www.virtualserialport.com/ Virtual Serial Port] Software for serial port communication and null-modem emulation
* [http://www.helmix.at/hapsim/index.htm HAPSIM graphischer Simulator ] zu graphischen Simulation von Tasten /LED /LCD und Terminal in AVR Studio Freeware !!!
* [http://www.ic-board.de/index.php?cat=c4_Programmer.html AVR Programmieradapter und JTAGICE MKII]
* [http://www.myavr.de/download.php?suchwort=ProgTool myAVR ProgTool] nette Programmieroberfläche (free)
* [http://b9.com/elect/avr/kavrcalc/ KAVRCalc] is a free calculator to assist in programming AVR microcontrollers (Baudrate, Watchdog, Timer, ...)
* [http://www.chip45.com/CrispAVR-USB CrispAVR-USB] STK500 V2 kompatibler ISP Adapter mit USB Schnittstelle für Atmel AVR Mikrocontroller (1,8V-5,5V).
* [http://ucom-ir.nicai-systems.de UCOM-IR] - Programmieradapter mit USB Schnittstelle (AT90USB162) und IR-Sender/Empfänger, STK500 V2 kompatibel
* [http://www.anagate.de/products/programmers.htm AnaGate Programmer] Serielle Programmer mit LAN-Anschluss für I2C und SPI inkl. Programmier-API für Windows/Linux (Shop)
* [http://www.halec.de/roloFlash/?ref=wiki_links.mikrocontroller.net roloFlash] - mobiles Flashgerät ohne PC (standalone), flexibel durch eingebaute Skriptsprache roloBasic
* [http://www.ehajo.de/Bausaetze/AVR-ISP-Stick AVR-ISP-Stick] Sehr günstiger (6,90€!) und bereits über 500 mal bewährter AVR-Programmer mit USB-Anschluss

=== Projekte und Quellcodebibliotheken ===

====Bibliotheken====
* [http://www.sigem-elektronik.de/elektro/cad/eagle/biblio/eaglebib.htm Cadsoft Eagle Bibliotheken]
* [http://www.nongnu.org/avr-libc/ AVR Libc]
* [http://hubbard.engr.scu.edu/embedded/avr/avrlib/docs/html/index.html Procyon AVRlib]
* [http://homepage.hispeed.ch/peterfleury Peter Fleury's Pages] - UART / LCD (HD44780) / I²C (TWI)/ AVR-GCC Bibliotheken, STK500v2 Bootloader
*[http://sourceforge.net/projects/avrfix Fixed Point Library Based on ISO/IEC Standard DTR 18037 for Atmel AVR microcontrollers, u.a. Cordic-Algorithmen] und [http://www.enti.it.uc3m.es/wises07/presentations/session2/05%20-%20Fixed%20Point%20Library%20According%20to%20ISOIEC%20Standard%20DTR%2018037%20for%20Atmel%20AVR%20ProcessorsWISES07-fixedpointlibrary%20-%20Elmenreich.pdf Kurzbeschreibung dazu als Powerpoint-PDF TU Wien Febr. 2007]

==== Betriebssysteme & Co. ====
* [http://www.tinyos.net/ TinyOS] - Komponentenbasiertes Betriebssystem für Sensorknoten. Bringt eigene C-ähnliche Hochsprache nesC mit.
* [http://www.chris.obyrne.com/yavrtos/ YAVRTOS] - Yet Another Atmel® AVR® Real-Time Operating System von Chris O'Byrne (C, Atmega32, GPL3 Lizenz)
* [http://www.freertos.org/ FreeRTOS] is a portable, open source, mini Real Time Kernel - a free to download and royalty free RTOS that can be used in commercial applications. (AVR, MSP430, PIC, ARM7, ...)
* [http://www.barello.net/avrx/index.htm AvrX Real Time Kernel] (IAR ASM oder IAR/GCC C, GPL2 Lizenz)
* [http://scmrtos.sourceforge.net/ scmRTOS] - Single-Chip Microcontroller Real-Time Operating System (C++, AVR, MSP430, Blackfin, ARM7, FR (Fujitsu, [http://www.opensource.org/licenses/mit-license.php MIT Lizenz]).
* [http://www.circuitcellar.com/avr2004/DA3650.html csRTOS] - cooperative single-stack RTOS aus dem Circuit Cellar AVR 2004 Design Contest. [http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_id=987&item_type=project csRTOS port to ATmega32] und [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=50743&start=all&postdays=0&postorder=asc Diskussion] auf www.avrfreaks.net führte zur Weiterentwicklung als [http://www.mtcnet.net/~henryvm/4AvrOS/ 4AvrOS] - cooperative scheduler
* [http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_type=project&item_id=230 OPEX] - freeware cooperative scheduler with lots of calendar and I/O functions von Steve Childress (Download auf www.avrfreaks.net ggf. Registrierung notwendig)
* [http://www.mikrocontroller.net/topic/12176#79672 Scheduler] von Peter Dannegger
* [http://www.mikrocontroller.net/topic/25087#186454 RTC-Scheduler] von ape
* [http://www.sics.se/~adam/pt/ Protothreads] - Lightweight, Stackless Threads in C (open source BSD-style license)
* [http://www.micrium.com/products/rtos/kernel/rtos.html uC/OS-II] is a real time operating system developed by Jean J. Labrosse. You can obtain the source code for the OS by buying Labrosse's excellent book ''MicroC/OS-II The Real-Time Kernel (2nd edition)''. [http://www.ee.lut.fi/staff/Julius.Luukko/ucos-ii/avr/index.shtml Port for AVR (gcc 3.x)] and [http://www.myplace.nu/avr/ucos/index.htm AVR (gcc 2.x)].
* [http://freshmeat.net/projects/qp/ QP] is a lightweight, portable framework/RTOS for embedded systems (ARM, Cortex-M3, 8051, AVR, MSP430, M16C, HC08, NiosII, and x86). GPL (und kommerzielle Lizenz verfügbar)
* [http://www.femtoos.org/ Femto OS] von Ruud Vlaming ist ein preemptives Betriebssystem für die kleinsten Mikrocontroller aus der AVR Serie bis ca. 16 KB ROM und 1 KB RAM. Spezielle Targets sind: ATtiny861/461/261. Geschrieben in C. Freie Software, GPLv3. Artikel in Elektor Februar 2010
* [http://www.projects-lab.com/?p=344 kaOS] is a real-time, multithreaded, preemptive operating system for the ATmega32 microcontroller, which loads and executes programs from a Secure Digital or MMC card. Authors Nicholas Clark & Adam Liechty. (Circuit Cellar AVR Wettbewerb 2006)
* [http://helium.sourceforge.net/ Helium] is a minimalistic real-time kernel for the HC(S)08 core by Freescale and Atmel AVR.
* [http://dev.bertos.org/ BeRTOS] is a completely free, open source, real time operating system (RTOS) suitable for embedded platforms. Runs on many microprocessors and microcontrollers, ranging from 8 bits to 32 bits CPUs and even PCs.
* [http://funkos.sourceforge.net/ funkos] Targets: AVR, XMEGA, MSP430, Cortex M3, Open Source
* Vergleich zwischen [http://antipastohw.blogspot.com/2009/11/4-operating-systems-for-arduino.html 4 Operating Systems for the Arduino] auf [http://antipastohw.blogspot.com Liquidware Antipasto]
** '''DuinOS''' by RobotGroup (FreeRTOS Portierung)
** [http://www.skewworks.com/pyxis/ Pyxis OS] by ArduinoWill
** '''ArduinoMacOS''' by Mark
** '''TaOS''' by Ziplock
* [http://atomthreads.com/ Atomthreads] is a free, lightweight, portable, real-time scheduler for embedded systems. (BSD Lizenz)
* [http://www.shift-right.com/xmk/ XMK] (eXtreme Minimal Kernel) ist ein freies Echtzeitbetriebssystem für Mikrocontroller (AVR, H8, R8C, M16C).
* [http://irtos.sourceforge.net/index.html.en iRTOS] is an free Real Time Operating System. The iRTOS kernel is free to download and use under the terms of LGPL. It can be used in commercial applications. iRTOS is designed for tiny 8 bit microconroller chips with little RAM usage. OS can be installed also in 16 and 32 bit processor units.
* [http://sites.google.com/site/cocoosorg/avr-projects/home cocoOS] is a cooperative task scheduler, based on coroutines and it is written in C. (STK500, Atmega16)
* [http://www.DieProjektseite.de BasicBeetle] Basic-Betriebssystem im AVR
* Shells für Arduino:
** [http://biot.com/arsh/ ARSH]
** [http://www.battledroids.net/downloads/avrsh.html AVRSH]
** [http://bitlash.net/wiki/start BITLASH]
** [http://sourceforge.net/projects/fruitshell/ FRUITSHELL]
** [http://www.gisvold.co.uk/~gisvold/drupal/node/1484 BREAKFAST]
* [http://nootropicdesign.com/toolduino/ toolduino] is a simple software tool that lets you easily interact with your Arduino hardware so you can test the circuits you create. Toolduino is written in the [http://processing.org/ Processing] languange and is available for Windows, Mac OS X, and Linux. Toolduino uses the the [http://www.arduino.cc/playground/Interfacing/Processing Arduino library for Processing] to communicate with an Arduino board so you can manipulate output pins and read inputs. The Arduino must be running the [http://firmata.org/wiki/Main_Page Firmata] firmware that comes with the Arduino IDE. (LGPL)
* [http://www.mueller-torres.de/avr.php MOPS] - A small C and Assembly based operating system for the ATMEL AVR® 8-Bit RISC controller family.
* [http://www.hk-businessconsulting.de/rts.htm RTS(Realtime Tasking System)] - Betriebssystemkern mit Echtzeiteigenschaften, Lizenz: EUPL V. 1.1

==== Projektsammlungen ====

* [http://www.DieProjektseite.de Die Elektronik-Projektseite und Heimat des BasicBeetle] Hauptthema ist der BasicBeetle. Ein modularer, leistungsfähiger, in Basic programmierbarer Mikrorechner speziell für Steuerungen. Mit vielen Programmen, Tiipps und Tricks, Informationen...
* [http://www.Happy-Micro.de Happy-Micro.de] Die Internetsite für Hobbyelektroniker, Mikrocontroller-Anwender, Programmierer und alle, die Spaß an Computern und Elektronik haben. Bei Happy-Micro.de steht der Spaß am Entwickeln von Programmen und Schaltungen im Vordergrund. Jeder Benutzer hat die Möglichkeit auch als Autor mitzumachen und seine Schaltungen oder Programme zu veröffentlichen. Freier Bilderdownload für die eigene Homepage. ''(Seite wurde geschlossen!)''
* [http://iwenzo.de Elektronik und Informationen] Wissenswertes aus der Unterhaltungselektronik..
* [http://instruct1.cit.cornell.edu/courses/ee476/FinalProjects/ Cornell University ECE 476 Microcontroller Design Final Projects]
* [http://www.serasidis.gr/ Serasidis Vasilis' AVRsite] u.a. GLCD, SMS, PAL
* [http://www.riccibitti.com Alberto Ricci Bitti] u.a. PAL Video-Interface
* [http://www.ulrichradig.de Mikrocontroller and more] AVR - Projekte (Ethernet, LCD, Relaiskarte usw.) und mehr
* [http://home.arcor.de/burkhard-john/index.html Burkhard John] (D)
* [http://www.avrprojects.net/ AVRmicrocontrollerprojects] u.a. Text-LCD, Schrittmotor, Thermometer
* [http://hem.bredband.net/robinstridh/ Robin Stridh] Rotor-Anzeige, Video-Interface
* [http://www.dertien.dds.nl/content/avrprojects.html dertien.dds.nl AVR-Projects]
* [http://www.microsps.com MicroSPS.com] Grafische Programmierung des AVR mit EAGLE
* [http://www.h-mpeg.de h-mpeg Festplatten mp3 Player] IDE Ansteuerung, IDE Filesystem, LCD Ansteuerung etc. in 8K Code. Quelltext unter GPL
* [http://www.embedtronics.com/ embedtronics.com]
* [http://www.siwawi.arubi.uni-kl.de/avr_projects M. Thomas' AVR Projekte] untern Anderem AVR Butterfly avr-gcc-port, DB101 gcc-port, BC100 gcc-port, Bootloader, Programmier- und Debughardware, Software-UART, DS1820-Lib., experimentelle avrdude-Versionen, AVR und CAN mit MCP2515 
* [http://www.mictronics.de Michaels Electronic Projects] AVR Projekte (EN) - ua. Sony/Becker CD/MD Wechsler Emulator, RDS-Decoder, GPS Infos, OBD J1850 VPW Interface, USB<>CAN Bus Interface. Informationen zu CD Wechsler Protokollen. MP3stick - MP3 Player mit ATmega128, color LCD, SD/MMC Karte und VS1011b
* [http://www.stahlbucht.de/elektronik/node13/ node13] modulares AVR 8515 Projekt: eine Controller-Platine, an die sich weitere Ein-Ausgabemodule (Tastenfeld, LEDs, LCD-Modul) anschliessen lassen
* [http://www.mikrocontroller-projekte.de www.mikrocontroller-projekte.de] Diverse Projekte mit AVR Controllern. AVR910 Programmer, Testboard und Modellbauelektronik
* [http://www.roboternetz.de/phpBB2 Roboternetz-Mikrocontroller Projekte.de] Diverse Projekte mit AVR und anderen Controllern, insbesondere im Bereich Robotik
* [http://www.avr-projekte.de AVR-Projekte.de] Belichtungstimer, FT232RL Schaltungen,LED-Fading über Fernbedienung, HD44780-LCD über USB und Seriell, AVR910-USB Programmer, Basteleien: Ätzmaschine,Kompressor.
* [http://openeeg.sourceforge.net/ openeeg.sourceforge.net] Das OpenEEG Projekt befasst sich mit der Entwicklung eines preiswerten Elektro-Enzephalographie (EEG) Geräts und dessen freier Steuersoftware zur Messung elektrischer Gehirnströme. Sein µPC-Herz ist ein AT90S4433 bzw. ein ATmega8. Ziel sind auch verschiedene EEG Anwendungen z. B. im Bereich mentaler Trainingsmethoden (Neurofeedback).
* [http://www.amateurfunkbasteln.de/ www.amateurfunkbasteln.de] Seite von Michael Wöste (DL1DMW) u.a. CPU-Board mit AT89C2051, AT89C4051 oder AVR AT90S2313, CPU-Board mit Atmel AT90S8535, Experimentierplatine mit ATmega103, Programmer für AT89C2051/AT89C4051, 32-Kanal-Logik-Analysator bis 40 MHz (Entwurf von David L. Jones)
* [http://www.atmel.com/dyn/products/app_notes.asp?family_id=607 Atmel - AVR 8-Bit RISC - Application Notes] Anwendungshinweise und Beispiele vom Hersteller
* [http://www.projects.cappels.org/ Dick Cappels' Project Pages]
* [http://see-by-touch.sourceforge.net/index.html SeebyTouch - Blinden-Seh-Ersatzsystem] Computerbilder fühlen durch ein einfaches Gerät (Bauanleitung) und freier Software (für 10 Betriebssysteme) - eine neue Erfahrung für alle
* [http://www.loetstelle.net www.loetstelle.net] Verschiedene kleinere AVR-Projekte rund um LEDs, z. B. RGB Dimmer, Moodlight. Diverse Elektronikprojekte und Grundlagen
* [http://www.dietmar-weisser.de Selbstbauprojekte Elektronik] kleine Sammlung von Elektronikprojekten zum Thema Leiterplattenfertigung, Hochfrequenztechnik und Mikrocontroller.
* [http://www.myplace.nu/avr/ Jesper's AVR pages] Yampp MP3 Player, Yaap Programmer, DDS mit 2313+R2R, Gitarrentuner, Frequenzzähler.
* [http://www.microsyl.com/ MicroSyl MCU] MP3 Player, MegaLoad, HCLoad, Propeller Clock, Freq Meter, BarCode Reader, Door Bell, OneWire Lib, Text LCD Lib, Graph LCD Lib, Nokia LCD Lib, Led Sign with MMC MemoryCard, Intercom
* [http://www.jeroen.homeunix.net/ http://www.jeroen.homeunix.net/] Aufbau eines elektronischen Rouletts auf basis eines AVRs
* [http://thomaspfeifer.net thomaspfeifer.net] Reflow-Ofen, Laminator-Temperaturregelung, USB-Atmel-Programmer, SMD-Tricks u.v.m.
* [http://www.scienceprog.com Scienceprog - embedded theory and projects] - AVR, ARM theory and projects
* [http://www.iuse.org Hausautomatisierung] - CAN-Bus mit ATmega32-Controllern und Bedienfeldern, Admin-Tools zum Updaten via CAN, Traffic Dumper etc.
* [http://www.myevertool.de AVRSAM] - AT91SAM7S Header Board annährend 100% Pinkompatibel zu den folgenden AVR Mikrocontroller: AT90S8535 / ATMEGA8535 / ATMEGA16 / ATMEGA32
* [http://members.aon.at/hausbus Hausbus Home] - Hausbus-Projekt unter Verwendung von ATmega8, ATtiny13 und ATmega128
* [http://www.thomas-wedemeyer.de/elektronik/AVR/avr-dcf-clock.html AVR-DCF-Clock] - DCF-Uhr mit bunter LED-Anzeige - ATmega8
* [http://www.grasbon.de/genuhr.html GenuhR] - DCF-Funkuhr / Wecker/ Timer mit LED-Punktmatrixanzeige. Das Projekt beschreibt den Aufbau des kompletten Gerätes beginnend beim Schaltplan bis hin zur Montage in ein Gehäuse.
* [http://www.avrguide.com/ AVR Projektsammlung] bei www.avrguide.com
* AVR Synth http://www.elby-designs.com/avrsynth/avrsyn-about.htm http://www.jarek-synth.strona.pl/
* [http://elm-chan.org/he_e.html Electronic Lives Manufacturing] - Aufbauten in Fädeldrahttechnik, tlw. auf Japanisch, aber mit englischen Sourcecodes
* AVR Synthesizer http://www.avrx.se/
* [http://www.wedis-basteleck.de/ Wedis-Basteleck] - Modellbahn DCC-Servo-Zubehördecoder DCC Servo Decoder mit ATmega8 / Servo Differenzierbaugruppe für Modellbau
* http://web.archive.org/web/20050415222337/http://www.hebel23.de/ RDS RADIO: ATMega32, TEA5757, T6963C, TDA7330B in C
* [http://www.gasenzer.dk Analog/Digital and MPU Eletronic Projects] PAL/VGA Terminal, CallerID, Ethernet, Wireless Bridge, LPC2214, AT91RM9200, Sony Unilink Controlled Wireless MP3 Player.
* [http://www.circuitcellar.com/avr2004/ Circuit Cellar AVR Design Contest 2004] mit Projektbeschreibungen
* [http://www.circuitcellar.com/avr2006/ Circuit Cellar AVR Design Contest 2006] mit Projektbeschreibungen
* [http://www.heesch.net/microcontroller.aspx/ Homepage von Stefan Heesch] - AVR Mikrokontroller Projekte, z.B. WLAN und AVR, netzwerkgesteuertes RGB Licht, IDE-Interface, DS1821 Thermometer, Morse-Dekoder u.a.
* [http://www.schaltungsforum.de Das Schaltungsforum] ist eine Seite für Anfänger und Profis welche ständig mit Tutorials erweitert wird. Stellt Eure Projekte online. Die Seite befindet noch im Aufbau und Eure Mithilfe ist erwünscht.
* [http://avrprojekte.de/] Viele Projekte mit LEDs(LED-Matrixen) und AVRs
* [http://arduino.milkcrate.com.au/ little-scale's arduino page]
* [http://www.sebastianweidmann.de www.sebastianweidmann.de] Grundlagen zum Thema Platinen ätzen, Bohren, Durchkontaktierungen und Projekte Tipps/Tricks mit Atmel AVR Microcontrollern
*[http://www.jtronics.de/avr-projekte.html Junghans Electronic Page] u.a Nokia 3310 LCD Ansteuerung in "C"(aktualisiert 2010), TWI/USI, Quadcopter
* [http://www.familie-finke.com/ http://www.familie-finke.com/] Die Website von Thomas Finke mit diversen Elektronikprojekten, wie z.B. STK-LAN (AVR im Netzwerk mit HTTPD, SNMP,...), UV-LED-Belichter, HPGL-Plotter.
* [http://phil-zone.de/ Philips Projektsammlung] Elektronik Projekte (µC,CMOS,Analog,...), Tutorials und nützliche Online-Tools
* [http://www.iuac.res.in/~elab/phoenix/index.html Phoenix] allows you to develop science experiments by connecting sensor / control elements to a computer and access them through software. The project was started by Inter University Accelerator Centre, with the objective of improving the laboratory facilities at Indian Universities, and growing with the support of the user community. Phoenix depends heavily on Python language. The data acquisition, analysis and writing simulation programs to teach science and computation. The hardware design is freely available. The project is based on Free Software tools and the code is distributed under GNU GPL. (Atmega16)
* [http://code.google.com/p/usb-pwm-generator/ USB PWM Generator] Low Cost PWM Generator, über USB Programmierbar. 1Hz - 120khz Duty Cycle 1 - 99 %.

==== Schnittstellen & Protokolle ====
===== Ethernet (TCP/IP...) =====
* Kostengünstige und schnelle WLAN Anbindung an Mikrocontroller mit Wiz610wi. Bezugsquelle inkl. praktischer Adapterplatine bei: [http://www.shop.display3000.com/elektronikmodule/ethernet-wlan/index.html Display3000]
* [http://www.laskater.com/projects/uipAVR.htm TCP/IP Stack für AVR] mit Realtek RTL8019AS oder Axis AX88796 Netzwerk-Chips (open source für avr-gcc und Imagecraft). Passende Hardware in [http://www.edtp.com/ diesem online-shop]
* [http://www.ethernut.de Ethernut] - AVR based Hardware with Ethernet-Interface, Multithreading OS, Software and Hardwaredesign is free
* [http://www.embedded-it.de/microcontroller/eNet-sam7X.php eNet-sam7X] Embedded Ethernet Modul im DIL64 Format mit kompletten OpenSource Board Support Packake auf Ethernut / Nut/OS Basis. Industrie geeignet
* [http://www.ethersex.de/index.php/Feature_Liste Ethersex] - Trotz des bescheuerten Namens sehr empfehlenswert. Viele flexibel einbindbare Module für diverse Hardware.
* [http://wiki.neo-guerillaz.de OpenMCP] Bekanntes Board auf Basis des ATmega2561 und ENC28j60. Läuft auch auf dem AVR-NETIO und dem myAVR.
* [http://www.cesko.host.sk/IgorPlugUDP/IgorPlug-UDP%20(AVR)_eng.htm IgorPlug-UDP AVR] - Ethernet & UDP/IP in Software implementiert
* [http://members.home.nl/bzijlstra/software/examples/RTL8019as.htm] RTL8019 Bascom
* [http://members.home.nl/bzijlstra/software/examples/RTL8019as.htm AVR und RTL8019]
* [http://avr.auctionant.de/avr-ip-webcam AVR IP Webcam]
* http://mikrocontroller.cco-ev.de/de/webcam.php
* [http://avr.auctionant.de/avrETH1/ avrETH1 - Webserver mit enc28j60 und Webcam-Support]
* [http://www.sics.se/~adam/uip/ uIP-Stack, Teil des Contiki OS]
* [http://www.sics.se/~adam/lwip/ LwIP-Stack]
* [http://www.harbaum.org/till/spi2cf/ WLAN-Implementierung auf Basis einer PRISM-CF-Karte und uIP]
* http://www.circuitcellar.com/AVR2006/winners/DE/AT2581.htm MEGA128(CAN) PCMCIA
* [http://www.ic-board.de/index.php?cat=c2_ICnova-Module.html AVR32 AP7000 Linux Board] mit 2xEthernet, TFT, Audio, SDCARD, USB-Host/Devive, Funk...
* [https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet AVR-Board mit Ethernet mit dem ENC28J60 von Microchip]
* [http://www.roland-riegel.de/mega-eth/ AVR-Ethernet-Board mit extra SRAM, SD/MMC, USB und zugehöriger Software]

===== CAN =====
* [http://www.canathome.de/ Can@Home] - CAN als "Installationsbus", u.a. mit AVRs (D)
* [http://www.iuse.org/ www.iuse.org] - Hausautomatisierung auf CAN Basis
* [http://www.port.de/ www.port.de] - Professionelle CAN/CANopen Entwicklungswerkzeuge
* [http://can-wiki.info CAN-WIKI] - spezielle Wiki Site für CAN bus (Englisch)
* [[CAN-Bus]] - Eintrag in diesem Wiki
* [[CAN als Hausbus]] - Eintrag in diesem Wiki
* [http://www.canhack.de/ www.canhack.de] - Ein Forum, dass sich mit dem CAN bus im Auto beschäftigt
* [http://www.edevices.lt/ www.edevices.lt ] - USB2CAN inexpensive USB to CAN bus converter

===== USB =====
* [http://www.embedded-it.de/microcontroller/microcontroller-module.php eUSB-162 und eUSB-LCD] - At90USB162 basiertes universelles USB Prototypen / Mikrocontroller Modul und USB Terminal Interface für HD44780 kompatible LCDs auf Basis der Lufa Library
* [http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm Igor-Plug] - USB Device interface in AVR Firmware - no extra Interface IC needed, read the License
* [http://www.obdev.at/products/vusb/index-de.html V-USB] – USB-Implementation in C nach gleichem Prinzip wie Igor-Plug, aber einfacher zu verwenden, GPL-ähnliche Lizenz (Nutzung des Projekts ''erfordert'' Veröffentlichung), englisch kommentierter Code
* [http://www.xs4all.nl/~dicks/avr/usbtiny/ USBTiny] – weitere Software-USB-Implementierung in C; sehr ähnlich AVR-USB; steht aber unter GPL; relativ wenige Beispiele
* MJoy USB Joystick Controller on AVR ATmega8
* [http://www.ime.jku.at/tusb/ TUSB3210-Controller, HID, LIBUSB] Ein Projektseminar, in dem es darum ging, die USB-Schnittstelle des TUSB3210 zu aktivieren und die Daten eines ADC an den PC zu senden. USB-Implementierung für µC und PC.
* [http://www.b-redemann.de Steuern und Messen mit USB - FT232, 245 und 2232] Das aktuelle Buch zu den USB-Controllern von FTDI. Viele Beispielprogramme in C, zwei Projektbeschreibungen: I²C-Bus mit LM75A und ein Web-Projekt. Bauteilesatz und USB-Modul mit dem FT2232 zum schnellen Einstieg in die Thematik. Buch / Teilesatz über Segor oder dieser Seite erhältlich.
* [http://www.eltima.com/products/usb-over-ethernet/ USB to Ethernet Connector] - Share your USB devices via LAN/Internet
* [http://www.ixbat.de Viele kleine USB Projekte] Rund um die Bibliothek usbn2mc http://usbn2mc.berlios.de. Dies ist eine einfache Bibliothek für den USBN9604/03 von National Semiconductor
* [http://www.rahand.eu Mega8D12] - Schritt für Schritt zum virtuellen COM-Port. Ein Einsteiger-Tutorial zur CDC-Klasse mit Schaltung und Firmware (ATmega8 und PDIUSBD12).
* http://www.maares.de/tools USB_ISO: Isolierter Schnittstellenwandler USB auf RS232 (TTL) mit FT232RL und ADUM1402. Galvanische Trennung für das Zielsystem.
* [http://www.embedded24.net USB HID Host Treiber] - USB HID Treiber DLL für Windows (Demo Projekte für Visual Studio 2010 C++, C# und VB).

===== DMX512 =====
* [http://Dworkin-DMX.de Konverter RS232 zum DMX512] Steuerung DMX-fähigen Geräten mit einem PC. Es gibt Low cost Variante zum selber basteln.
* [http://www.hoelscher-hi.de/hendrik/light/profile.htm Hennes Sites] Bauanleitungen für DMX-Dimmerpacks, DMX-Switchpacks, PWM-Controller, ... Tutorial für Senden und Empfangen von DMX-Daten mit AVRs.
* [http://www.lj-skinny-development.de/lj2000/ DMX Lichtanlage im Selbstbau] Projekt für den Selbstbau einer kompletten Lichtanlage zur Steuerung über DMX. Projekt beinhaltet alles was man für den Betrieb einer eigenen Lichtanlage benötigt (Mischpult, Steuersoftware, Dimmer, Scanner mit Iris, Shutter-Dimmer, 2 rotierenden Goborädern, 2 Farbrädern, CMY-Farbmischeinheit, Prisma, Fokus ...).
* [http://digital-enlightenment.de Digital Enlightenment ]Verschiedene DMX-Selbstbauprojekte

===== PS2 =====
* [http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_id=1086&item_type=project&timestamp=2007-09-04%2018:34:41 PC keyboard to an AVR]

===== LANC =====
* [http://dsc.ijs.si/3dlancmaster/ 3D LANC Master from Damir Vrancic] is a device which keeps in synchronisation some of Sony camcorders by using LANC (CONTROL-L, ACC) protocol. (Open Hardware + Open Source, Atmega8).
* [http://jochendony.homeip.net/content/view/22/26/ LANC Lib] for AVRGCC. Read and write LANC commands.
* [http://blog.makezine.com/archive/2008/12/controlling_sony_camcorders_with_th.html Controlling Sony camcorders with the Arduino]

===== MMC/SD-Card =====
* [http://www.roland-riegel.de/sd-reader/index.html MMC/SD card reader example application] von Roland Riegel (Atmega8, Atmega168 für FAT16)
* [http://www.captain.at/electronic-atmega-mmc.php MMC Flash] bzw. [http://www.captain.at/electronic-atmega-sd-card.php SD Flash ] Memory Extension für Atmegas von Captain. (Atmega16, Atmega32)
* http://arm.hsz-t.ch MMC, SD, SDHC Kartentreiber für ARM7 Mikrocontroller
* [http://www.mikrocontroller.net/articles/FAT32 Wiki und FAT16/32 Bibliothek für atmega]

==== LC-Displays ====

===== Text (character-mode) HD44780 =====
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray
* [http://www.sprut.de/electronic/lcd/index.htm Spruts LCD-Seite]
* [http://elm-chan.org/docs/lcd/lcd3v.html Standard-LCD auf 3V betreiben (eng)]
* [http://www.harbaum.org/till/lcd2usb LCD2USB, LCD mit AVR am USB betreiben]
* [http://www.simon-brenner.ch/projekte/lcd-display 4x40 LCD Projekt, Microchip]

===== Grafik T6963C etc. =====

* http://www.holger-klabunde.de/avr/avrboard.htm#t6963
* [[Projekt T6963-LCD-Ansteuerung]] nur PC, keine Änderung seit Juli 2006
* avrfreaks.net - TOSHIBA_LCD_T6963C, AVR Graphics
* http://www.mikrocontroller.net/topic/48456 C
* http://www.mikrocontroller.net/topic/54563 C
* http://www.mikrocontroller.net/topic/48584 ASM
* [http://passworld.co.jp/ForumMSP430/viewtopic.php?t=47 Grafik LCDs] - 128 x 112 Grayscale für MSP430 und andere uCs.
* http://www.display3000.com/ Farb-TFT-Module inkl. Mikrocontroller (ATMega128; ATMega2561 und AT90CAN128)
* [http://www.tklinux.de/sed1330.html SED1330 an ATMega]. Library für SED 1330 controller an ATmega
In der Codesammlung gibt es auch für andere Controller was.

===== Siemens S55/C60 =====
* [http://www.module.ro/siemens_lcd.html S55-Display Pinbelegung]
* [http://www.mikrocontroller.net/topic/22643 Forumbeitrag]

===== Siemens S65/M65/CX65 =====
* [http://www.superkranz.de/christian/S65_Display/DisplayIndex.html S65-Display] vom Siemens S65/M65/CX65, 132x176 Pixel, 65536 Farben, günstig als Ersatzteil zu bekommen.

===== Nokia 3210/3310 =====
* [http://www.jtronics.de/avr-projekte.html Bibliothek für Nokia 3310 Lcd Ansteuerung in "C" von http://www.jtronics.de - sehr gut (aktualisiert 2010)]
* [http://www.microsyl.com MicroSyl.Com]

* [http://www.deramon.de/nokia3310lcd.php Deramon.de]


===== Nokia 6100 LCD =====

* [http://www.myplace.nu/mp3/download/download.php Yampp 7 Software Download Seite]: Archiv "yampp-7 with colour LCD firmware" enthält avr-gcc/avr-as Routinen für 6100-LCDs mit Philips- oder Epson-Controller (nicht direkt eine "Library")
*[http://www.e-dsp.com/controlling-a-color-graphic-lcd-epson-s1d15g10-controller-with-an-atmel-avr-atmega32l/ S1D15G10]: Routine code für den Epson S1D15G10 Controller
*[http://thomaspfeifer.net/nokia_6100_display.htm Nokia 6100 Display am AVR] Anzeige von RGB-Bildern (für avr-gcc)
*[http://www.optixx.org/ www.optixx.org] Code zur Ansteuerung von Philips und Epson
*[http://www.zipfelmaus.com/nokia6100lcd_en/ http://www.zipfelmaus.com/nokia6100lcd_en/] --> unter Download: Tool zum Konvertieren von BMPs in h-Files zum Ausgeben auf dem Display

===== KS0108 =====
* [http://hubbard.engr.scu.edu/embedded/avr/avrlib Procyon avrlib (GPL)]
* avrfreaks UP
* apetech.de nicht mehr erreichbar http://www.mikrocontroller.net/topic/68316

====GPS====
* http://www.holger-klabunde.de/avr/avrboard.htm#GPSdisplay GPS-Daten auf LCD
* [http://www.geoclub.de/forum57.html www.geoclub.de] - Elektronik beim Geocaching
* [http://passworld.co.jp/ForumMSP430/viewtopic.php?t=22 passworld.co.jp] - Do It Yourself GPS

== [[8051|8051 / MCS51]] ==
* [http://mcu8051ide.sourceforge.net/ MCU 8051 IDE] - MCU 8051 IDE is a new modern graphical IDE for microcontrollers based on 8051. MCU 8051 IDE is noncommercial open-source software for Linux.
* [http://www.rakers.de/catalog Dr. Rakers] Entwicklungssystem mit C-Compiler, BASIC-Compiler und Makroassembler für alle 8051-Mikrocontroller (80C552, 80C515(C), 80C537). Auch für Hobbyisten bezahlbar.
* [http://www.progshop.com/versand/software/prog-studio/index.html Prog-Studio] - Moderne Assembler Entwicklungsumgebung für 8051 Mikrocontroller mit Debugger, Edit & Continue, Code-Folding, Intelli-Sense, Monitorung und mehr
* [http://www.yCModule.de yCModule: µController-Systeme] - Preisgünstige µController-Module, ISP-Programmiertools und Applikationsboards
* [http://www.erikbuchmann.de/ Erik Buchmanns Mikrocontroller-Seite] - Assemblerkurs und mehrere Projekte
* [http://www.holger-klabunde.de/projects/8051.htm Experimentierboard für 8051 Controller] von Holger Klabunde.
* [http://www.woe.de.vu/ World Of Electronics] - Projekte mit den 8051-Controllern von Atmel
* [http://www.thomas-wedemeyer.de/elektronik/8051/8051.html Controllerplatine mit SAB80C535]
* [http://www.maxim.ph.tc Selbstbau-Programmer] für 2051er
* [http://www.nomad.ee/micros/8052bas.html 8052 BASIC Projects] - IDE-Interface
* [http://home.t-online.de/home/s.holst/sh51/index.html Mikrokontroller sh51] Schaltplan für 80C535-Board
* 8051-Makroassembler [http://plit.de/asem-51/ ASEM-51] (Freeware)
* [http://sdcc.sourceforge.net/ SDCC - Small Device C Compiler] - freier ANSI-C compiler für Intel 8051, Maxim DS80C390 und Zilog Z80 kompatible Controller.
* [http://sdccokr.dl9sec.de/ The SDCC Open Knowledge Resource]
* [http://www.wickenhaeuser.de/ Wickenhäuser C Compiler] - Preisgünstiger C Compiler
* [http://home.tiscali.cz:8080/~cz056018/lanc_a.htm LANC-Remote] Projekt von Jiří Šmach zur Steuerung von Videorekordern oder Camcordern über das Control-L (LANC) Protokoll mit Hilfe eines AT89C2051.
* [http://www.microcontroller-starterkits.de Microcontroller-Starterkits] Starter-Kits für verschiedene Microcontroller (D) preisgünstige Platinen (ab 12,95 Euro für AT89S8252). Beim uC-Dualboard : Das Board ist nutzbar mit AVR-Controllern und 8051-Controllern!
* [http://turbo51.com Turbo51 - Free Pascal compiler for 8051]
* [http://self8051.de/ self8051.de] - Dein Nachschlagewerk - Befehlsreferenz, Eigenschaften, Derivate
* [http://cmon51.sourceforge.net/ CMON51] - freier Onboard Monitor und Debugger, anpassbar an unterschiedliche 8051 kompatible Mikrocontroller
* [http://et-tutorials.de/632/kostenloser-mikrocontroller-kurs/ Mikrocontroller Video Tutorial] Video-Tutorial für Einsteiger (C-Kurs + Einführung 8051)

== MSP430 ==
* [http://www.mikekohn.net/micro/naken430asm_msp430_assembler.php naken430msp] - MSP430 Assembler von Michael Kohn (GPL)
* [http://www.mathar.com MSP430 Tutorials] - Tutorials, Anleitungen und viele Beispielprojekte mit dem MSP430-Mikrocontroller
* [http://www.student-zw.fh-kl.de/~stwi0001/imp/msp430/pwm430/index.htm Pulsweitenmodulation mit dem MSP430] - sehr ausführliche Einführung
* [http://www.thomas-wedemeyer.de/elektronik/msp430/msp430.html Kleine Projekte mit dem MSP430] - Schaltplan und Layout zu einem MSP430F149-Board und einem ADXL-G-Sensor mit MSP430
* [http://tinymicros.com/embedded/MSP430/ The MSP430 Bugspray Database] - umfangreiche Datenbank für Bugs in MSP430-Controllern
* [http://msp430.info MSP430.info] - Portalseite für MSP430; Info, Projekte (MIDI, USB)
* [http://groups.yahoo.com/group/msp430 Yahoo group MSP430] - lebhaftes Forum mit vielen MSP430-Experten
* [http://homepage.hispeed.ch/py430/mspgcc/ mps430-gdb und Eclipse] - Eine Anleitung von Chris Liechti
* [http://passworld.co.jp/ForumMSP430 Forum MSP430] - Projekte mit MSP430 (GPS, BlueTooth usw...)
* TI Design-Wettbewerb: http://www.designmsp430.com/View.aspx (Dateien liegen evtl. in /projects/) [2011-01-24: redirect zum TI Wiki, Projekte nicht mehr vorhanden]
* [http://www.sics.se/project/mspsim MSPsim] - a Java-based simulator of MSP430 sensor network platforms (BSD License (revised))
* [http://develissimo.net/de/msp430entwicklung MSPGCC + Eclipse + msp430-gdbproxy / Linux / Debian / Ubuntu] - Anleitung / Tutorial zur Installation der MSPGCC Toolchain + Eclipse + msp430-gdbproxy für Linux / Debian / Ubuntu Lang=Deutsch und Englisch
* [http://travisgoodspeed.blogspot.com/ Travis Goodspeed's Blog] - Home of the [http://goodfet.sourceforge.net/ GoodFET] Programmer
* [http://www.43oh.com/ Four-Three-Oh!]
* [http://thinkembedded.ch/MSP430:::10.html Webshop mit MSP430 Olimex Demoboarden und Programmer]

=== MSP430 Launchpad ===
* [http://processors.wiki.ti.com/index.php/MSP430_LaunchPad_(MSP-EXP430G2)?DCMP=launchpad&HQS=Other+OT+launchpadwiki MSP430 LaunchPad Wiki] bei TI
* [http://hackaday.com/2010/08/11/how-to-launchpad-programming-with-linux/ How-to: Launchpad programming with Linux] auf hackaday.com
* [http://springuin.nl/en/articles/launchpadwindows TI Launchpad programming and debugging with Open Source tools on Windows] (Eclipse, MSPGCC4, Insight, msp430-gdbproxy)
* [http://osx-launchpad.blogspot.com/ MSP430 LaunchPad toolchain for Mac OS X]

=== EZ430 Chronos ===
* [http://processors.wiki.ti.com/index.php/EZ430-Chronos?DCMP=Chronos&HQS=Other+OT+chronoswiki EZ Chronos Wiki] bei TI

== ARM ==

=== Herstellerseiten ===
* [http://www.arm.com ARM] - Entwickler des ARM-Prozessorkerns (kein Hersteller von ICs)
* [http://infocenter.arm.com ARM Infocenter] Sammlung Technischer Informationen

* [http://www.analog.com/ Analog Devices] ADuC7xxx ARM7TDMI Serie unter ''Analog Microcontrollers''
* [http://www.atmel.com/products/AT91/ Atmel AT91 Startseite]
* [http://www.at91.com AT91.COM] - Atmel ARM Informationsseite (Forum, Beispielcodes etc.)
* [http://www.cirrus.com/en/products/pro/techs/T7.html Cirrus Logic]
* [http://www.energymicro.com/ Energy Micro] EFM32 mit Cortex M0+,M3,M4
* [http://www.freescale.com/mac7100 Freescale MAC7100]
* [http://www.hilscher.com Hilscher netX] (ARM926 core)
* [http://www.infineon.com/cms/en/product/microcontrollers/32-bit-industrial-microcontrollers-based-on-arm-registered-cortex-tm-m/channel.html?channel=db3a30433c1a8752013c3e221b9d004f Infineon XMCxxxx] Cortex M0,M4
* [http://www.intel.com/design/intelxscale/ Intel XSCALE Startseite], siehe auch [http://www.marvell.com/ Marvell]
* [http://www.luminarymicro.com/ Luminiary Micro (TI)] Controller mit Cortex M3 core
* [http://www.standardics.nxp.com/microcontrollers/ NXP (ehemals Philips) Microcontroller Startseite] für sämtliche Mikrocontroller (ARM7, ARM9, Cortex-M0, -M3, MCS51 etc.), neben LPC2000, LPC3000 auch die LH7xxxx BlueStreak-Serie (ehemals Sharp Microelectronics)
* [http://www.lpc2000.com lpc2000.com] Infoseite für NXP (ex. Philips) LPC1700 Cortex-M3 basierende Typen, LPC2000, ARM7 basierende Typen und LPC3000, ARM9 basierende Typen. Auch andere Cortex-M3 Bausteine sind erfasst
* [http://www.okisemi.com/eu/1.Products/ARM32bit.html OKI ARM-Controller Startseite]
* [http://www.samsung.com/Products/Semiconductor/ Samsung] ARM7/9 unter ''Mobile SoC''
* [http://mcu.st.com/mcu/ STMicroelectronics (ST) Microcontroller Startseite] u.a. STR7, STR9, STM32 Support-Forum
* [http://www.ti.com/ Texas Instruments] TMS470 ARM7TDMI Serie
* [http://www.toshiba.com/taec/ Toshiba] Controller mit ARM9 und Cortex-M3 core

=== Information (Foren, Mailinglisten, Linksammlungen) ===
* [http://forum.energymicro.com Lizard Lounge -] Energy Micros Forum für EFM32
* [http://m8051.blogspot.no/2012/11/efm32-low-power-series-part-2-low-power.html Blog über Low Power Modes der EnergyMicro uC]
* [http://www.neko.ne.jp/~freewing/cpu/arm_olimex/ Freewing Linksammlung] zu den NXP (ex. Philips) LPC-ARM7-Controllern (Assemblerbeispiele u.a. für Nokia 3310-GLCD)
* [http://www.open-research.org.uk/ARMuC ARM Microcontroller Wiki]
* [http://arm.hsz-t.ch arm.hsz-t.ch] Einfühung in ARM7 Mikrocontroller und uClinux.
* [http://tech.groups.yahoo.com/group/ADuC7000/ ADuC7000 Yahoo-Group]
* [http://www.at91.com AT91 Forum] (Atmel Rousset)
* [http://tech.groups.yahoo.com/group/AT91SAM/ AT91SAM Yahoo-Group]
* [http://en.mikrocontroller.net/forum/17 arm-elf-gcc WinARM Forum] (auch für Yagarto)
* [http://www.codesourcery.com/archives/arm-gnu/maillist.html Sourcery G++ Lite Edition User Forum/Mailing-List]
* [http://tech.groups.yahoo.com/group/gnuarm/ GNUARM Yahoo-Group]
* [http://www.keil.com/forum/ Keil/ARM Forum]
* [http://groups.yahoo.com/group/lpc2000/ LPC2000 Yahoo-Group]
* [http://www.mcu-related.com MCU related] Neuigkeiten zu MCUs, überwiegend ARM / Cortex-M3 basierend mit Vergleichen von RTOS und anderen Entwicklungstools
* [http://forum.sparkfun.com/ Sparkfun Foren]
* [http://mcu.st.com/mcu/modules.php?name=Splatt_Forums STMicroelectronis Forum]
* [http://www.stm32circle.com/ Forum for STM32 moderated by Raisonance] Sehr viele Beispielprogramme in Source fuer STM32 und den Primer2 von Raisonance

=== Entwicklungswerkzeuge (Compiler/Assembler/Debugger/Tools) ===
==== IDEs ====
* [http://www.st-angliamicro.com/software.asp Anglia Idealist IDE und Anglia Toolchain] GNU toolchain für Win32-hosts inkl. Beispielen für STR7, STR9 und STM32. IDE kostenlos aber registrierungspflichtig
* [http://atollic.com/ attolic] TrueSTUDIO
* [http://www.codesourcery.com/gnu_toolchains/ Codesourcery] GNU Toolchains für ARM (Hosts: Linux, MS Windows, Solaris; Targets: "bare-metal", arm-linux, SybianOS)
* [http://devkitpro.org/ devkitPro/devkitARM] GNU-Toolchain für MS-Windows "Hosts". Vor allem auf GBA abgestimmt aber auch für andere ARM-Controller geeignet
* [http://www.ghs.com/ Green Hills Software]
* [http://www.hitex.de Hitex] IDE für diverse Compiler, Debugger
* [http://www.iar.com IAR] Embedded Workbench, kommerzielle IDE/Compiler, codegrößenbeschränkte Evaluierungsversion verfügbar
* [http://www.isystem.com/ iSYSTEM] Integrated Development Environment, USB/JTAG interface, OnChip Emulation and Trace
* [http://www.keil.com Keil/ARM MDK-ARM] kommerzielle IDE/Compiler, unterstützt zwei Compiler (ARM RealView, GNU/gcc), codegrößenbeschränkte Evaluierungsversion verfügbar (IDE/Compiler unbeschränkt für GNU), guter Debugger, sehr guter Simulator, Simulator und Debugger in der Evaluierungsversion auch bei Nutzung der GNU-Toolchain mit Größenbeschränkung
* [http://mct.de/download.html#free MCT Demoversion C-Compiler für ARM und 68k] ARM C-Compiler basiert auf GCC laut Herstellerinformation jedoch mit Codegrößenbeschränkung 
* [http://www.mpeforth.com www.mpeforth.com] - A free Forth system with 125 page manual for all Philips LPC2xxx CPUs with at least 64k Flash and 16k RAM and cystal frequency of 10, 12, or 14.7456 MHz.
* [http://www.raisonance.com/ Raisonance] Ride, RKit-ARM
* [http://www.rowley.co.uk/ Rowley] Kommerzielle IDE für GNU-Compiler, eigene libc (nicht newlib), Debugger (inkl. gutem Support für Wiggler)
* [http://h-storm.tantos.homedns.org/gcc_arm.htm Tantos gcc for ARM Targets] eine weitere ARM-GNU-Toolchain für MS-Windows "Hosts"
* [http://www.yagarto.de Yagarto] GNU arm-eabi-Toolchain, Eclipse, OpenOCD für Win32 inkl. Setup
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/index.html#winarm WinARM] eine an WinAVR angelehnte Sammlung von Entwicklungswerkzeugen (binutils, arm-elf-gcc, newlib, ''newlib-lpc'', Programmers Notepad, ''Beispiel-Makefiles und Beispielcode'') für alle ARM-Controller. Beispiele für Philips LPC2000 und Atmel AT91SAM7S (ARM7TDMI) u.a.
* [http://code.google.com/p/dissy/ Dissy] is a disassembler for Linux and UNIX which supports multiple architectures and allows easy navigation through the code. Dissy is implemented in Python and uses objdump for disassembling files.
* [http://www.sinelabore.com sinelaboreRT] - generiert leicht lesbaren C-Code aus einer Zustandsmaschine. Die Generierung berücksichtig speziell die Bedürfnisse eingebetteter Echtzeitsysteme.
* http://arm.hsz-t.ch Entwicklungsumgebung für ARM7 Mikrocontroller basierend auf der Knoppix CD. Keine Harddisk installation nötig für uClinux.
==== HW Debugger/Programmer ====
* [http://openocd.berlios.de/web/ OpenOCD] Open On-Chip Debugger: Schnittstelle ("gdb-Server") zwischen verschiedenen JTAG-Interfaces (u.a. auf FTDI2232-Basis, "Wiggler"-ParPort und andere) und GNU-debugger (gdb/Insight-gdb) Flash-Programmierfunktion für LPC2k, AT91SAM7S, LM3S, STM32 und viele andere interne und externe Flashspeicher (Open Source, GPL, unter anderem auf MS Windows und Linux lauffähig)
* [http://macraigor.com/full_gnu.htm OCDLibRemote] Schnittstelle zwischen WIGGLER-kompatibler JTAG Hardware und dem GNU-Debugger (gdb)
* [http://gdb-jtag-arm.sourceforge.net/ GDB-JTAG-ARM] GDB JTAG Tools
* [http://jtagpack.sourceforge.net/ JTAG-Pack] GDB JTAG Tools
* [http://www.hjtag.com H-JTAG] RDI-Interface für Wiggler, Flash-Funktionen für diverse interne und externe Speicher
* [http://www.clibb.de/ lpc21isp] Flashutility für LPC21xx, ISP via "Bootloader" ("multiplattform")

*[http://www.abatron.ch Abatron] BDI1000 & BDI2000, On-Chip Debuggers für ARM, 68k, Coldfire uvm.
* [http://www.amontec.com Amontec] JTAGkey, JTAGkey2(P): JTAG-Adapter auf Basis des FTDI2232(H)
* [http://www.hjtag.com/product_intro.html H-JTAG USB Emulator]
* [http://www.keil.com Keil/ARM ULINK/ULINK2/ULINK-ME] JTAG-Adapter, USB-Anschluss, wird von Keil uVision unterstützt, ULINK2 teilw. auch von Codesourcery G++ (lt. Hestellerangaben)
* [http://www.kristech.eu Kristech] USB-Scarab, JTAG Adapter, kommt mit eigener Debugger-UI, kompatibel zu Olimex
* [http://www.lauterbach.de Lauterbach] TRACE32 JTAG-Adapter, USB und Ethernet-Anschluss, eigene Software
* [http://www.olimex.com Olimex] JTAG-Adapter: Wiggler-Nachbau (ParPort) und Adapter auf Basis des FTDI2232 (USB)
* [https://www.olimex.com/Products/ARM/JTAG/ARM-JTAG-COOCOX/ Olimex ARM-JTAG-COOCOX] CoLinkEx nachbau von Olimex (daher siehe CoLinkEx)
* [http://www.coocox.org/Colinkex.htm CoLinkEx] günstiger JTAG/SWD Programmer von Coocox.com, nicht alle uC unterstützt, siehe [http://www.coocox.org/Colinkex.htm Website], unterstützt,CoIDE, Keil MDK-ARM, IAR sowie Eclipse.
* [http://www.ronetix.at/peedi.html Ronetix Peedi]
* [http://www.segger.de Segger J-Link] JTAG-Adapter, USB-Anschluss, unterstützt z. B. von IAR, Keil uVision (via RDI) (OEM: IAR J-Link, SAM-ICE)
* [http://www.signalyzer.com/ Signalyzer] Signalyzer Tool, u.a. JTAG-Adapter auf Basis des FTDI2232
* [http://www.versaloon.com/ Simon Qians Versaloon]

=== Tutorials und Beispiele ===
* [http://www.dreamislife.com/arm/ LPC210x ARM7 Microcontroller Tutorial] - Assembler-Beispiele (arm-elf-as) für das Olimex LPC-MT-Board (Philips LPC2106 ARM7TDMI)
* [http://re-eject.gbadev.org/index.php gcc-Assembler für ARM] - Befehlsübersicht
* [http://patater.com/gbaguy/gbaasm.htm GBA ASM Tutorial] - ARM7 Assembler Tutorial mit arm-elf-as ("gcc") (Allgemein und GBA)
* [http://www.robsite.de/daten/tutorials/devgba/gba_asm1.html GBA Assembler Tutorial] - ARM7TDMI, Schwerpunkt auf GBA
* [http://www.sparkfun.com/tutorial/ARM/ARM_Cross_Development_with_Eclipse.pdf Eclipse+CDT+gnuarm-Tutorial]
* [http://mct.de/download/armsamples/map.html Beispiele in C, für ARM7-Controller von Philips und ADI]
* [http://www.embedded.com/design/opensource/201802580 Embedded.com: Building Bare-Metal ARM Systems with GNU] Teil 10, Links zu den Teilen 1-9 auf der Seite
* [http://www.sparkfun.com/datasheets/DevTools/SAM7/at91sam7%20serial%20communications.pdf AT91SAM7 Serial Communications] von James P. Lynch (PDF, www.sparkfun.com)
* [http://www.kaczurba.pl/aduc ADuC7000 Tutorial] von Witold Kaczurba (www.kaczurba.pl)
* [http://www.redacom.ch/keillab/ Schweizer Gondelbahnsteuerung über Webserver auf ETT STM32F ARM KIT Board in Keil RTOS mit Webcam ]
* [http://www.mySTM32.de Tutorial für das STM32F4 Discovery in C und C++ (UML)]

=== Projekte und Quellcodebibliotheken ===
* [http://hubbard.engr.scu.edu/embedded/arm/armlib/ Procyon ARMlib-LPC2100] - Treiber, Beispiele (Lizenz: GPL, kaum weiterentwickelt)
* [http://www.standardics.nxp.com/support/documents/?type=software NXP BlueStreak] Code für LH7xxxx (ehemals Sharp)
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/index.html M. Thomas' ARM Projekte] "Projectvorlagen" für AT91SAM7 und LPC2000 mit GNU-Toolchain Einsteiger-Projekte für AT91SAM7, LPC2000, ADuC7000 u.a. (u.a. Blinky, UART, Interrupt, C++, GLCD mit KS0108, DS18x20, DCF77, Anpassungen von FAT16/32-Libraries) 
* [http://mcu.st.com/ STMicro] Treiber und Beispiel für STR7, STR9 und STM32
* [http://wiki.sikken.nl/index.php?title=LPCUSB LPCUSB] - Open-source [[USB]] stack for the built-in USB controller in LPC214x microcontrollers von Bertrik Sikken. [http://lpcusb.cvs.sourceforge.net/lpcusb/host/benchmark/main.c?revision=1.2&view=markup Sample code]
* [http://www.olimex.com Olimex] Einige Beispiele auf den "Produktseiten" der ARM Boards.
* [[ARM MP3/AAC Player]]
* [http://www.jcwren.com/arm/ J.C. Wrens Beispielprojekt] für LPC214x
* [http://www.keil.com/download/list/arm.htm Beispiele von Keil] abgestimmt auf deren Boards und Realview-Toolchain, Portierung auf andere Boards und Compiler relativ einfach, Lizenz beachten.
* [http://www.luminarymicro.com/ Luminary Micro Driverlib] für Stellaris Cortex-M3
* [http://r2d2.stefanm.com/gps-tracker.html GPS-Tracker] mit Navigation auf LPC2103-Basis (Complier: GCC)
* [http://elua.berlios.de elua] Lua für ARM-controller
* [http://freemodbus.berlios.de/ FreeMODBUS] "A Modbus ASCII/RTU and TCP implementation" (für STR71x, AT91SAM7, LPC214x, auch: AVR, MSP430 u.a.)
* [http://bettyhacks.com BettyHacks] Freie Firmware für die "interaktive TV-Fernbedienung" betty-tv (ARM7tdmi, 2MB Flash, 160 x 128 Pixel 2 bit LCD, CC1100, IR, Lautsprecher,..)
*[http://cdn.energymicro.com/dl/zip/Simplicity_Studio_Setup.exe Download Simlicity Studio], Tool mit vollständiger Dokumentation und vielen Beispielen zu Energy Micro EFM32 Cortex M0+/M3/M4 uC.

=== Betriebssysteme ===
* [http://agnix.sourceforge.net/ Agnix]
* [http://www.bertos.org/ BeRTOS] is a completely free, open source, real time operating system (RTOS) suitable for embedded platforms. Runs on many microprocessors and microcontrollers, ranging from 8 bits to 32 bits CPUs and even PCs.
* [http://chibios.sourceforge.net/ ChibiOS/RT]
* [http://www.stm32circle.com/resources/upgrade.php Circle-OS for STM32] Kostenloses OS, sehr klein mit Basisfunktionen fuer STM32
* [http://coocox.org/ CoOS]
* [http://sources.redhat.com/ecos/ eCos] - "Real-Time-Operating-System" o.a. auch für ARM7
* [http://www.freertos.org/ FreeRTOS (.org!)] - "Real-Time-Kernel" unter anderem für ARM7 (LPC2xxx) auch AVR, MSP430, '51er
* [http://sourceforge.net/projects/funkos/ FunkOS]
* [http://l4ka.org/ L4Ka]
* [http://developer.toradex.com/software-resources/arm-family/linux/source-code Linux für Toradex Module] basierend auf Intel XScale und Nvidia Tegra
* [http://www.linux4sam.org Linux4SAM] Informationen, Anleitungen und Code zur Anwendung von Linux auf AT91SAM9xxx
* [http://www.freertos.com/ NicheTask] (URL ist www.freertos.com aber hat nichts mit FreeRTOS(.org) zu tun)
* [http://www.ethernut.de/en/software/index.html Nut/OS] Echtzeitbetriebssystem für Mikrocontroller (ARM, AVR, AVR32, Cortex M3 u.A). Multitasking und vollständiger TCP/IP Stack inklusive. Leicht zu erlernen und viele Beispiele
* [http://nuttx.sourceforge.net/ NuttX RTOS] (ARM7TDMI port for TI TMS320C5471 also called a C5471 or TMS320DM180).
* [http://www.phoenix-rtos.org/ Phoenix-RTOS]
* [http://picoos.sourceforge.net/ PicoOS]
* [http://prex.sourceforge.net Prex] is a portable real-time operating system for embedded systems. The small, reliable, and low power kernel is written in the C language based on microkernel design. The file system, Unix process, and networking features are provided by user mode tasks. (ARM, i386, geplant: MIPS, PowerPC, Hitachi-SH und Win32)
* [http://www.rtems.org/ RTEMS]
* [http://code.google.com/p/rt-thread/ rt-thread]
* [http://sourceforge.net/projects/scmrtos/ scmRTOS]
* [http://www.tnkernel.com/downloads.html TNKernel] - "Real-Time-Kernel" [[TNKernel]] ist ein kompakter und sehr schneller Echtzeitkernel unter anderem für ARM7 (Philips LPC2106/LPC21XX/LPC22xx, Samsung S3C44B0X, Atmel AT91SAM7S128, STMicroelectronics STR711FR2)
* [http://www.ucos-ii.com/ uC/OS-II RTOS]

=== Hardware (Prototypen-Platinen etc.) ===


* [http://www.armkits.com/ Embest] Philips, Samsung und Atmel ARM Boards und Module, JTAG-Hard- und Software
* [http://www.waveplayer.de/ Embedded-Waveplayer] mit ARM7-Prozessor EP7309 (MIDI- und RS232-Steuerung)
* [http://www.embeddedartists.com/ Embedded Artists] bietet verschiedene preisgünstige Platinen (ab 25 Euro für LPC213x Familie)
* [http://www.embedded-it.de/microcontroller/microcontroller-module.php Embedded-IT] eNet-sam7X: Ethernut kompatible Embedded Ethernet Mikrocontroller Boards für Industrie und Hobby auf ARM mit Nut/OS Betriebssystem sowie USB Module auf AVR Basis
* [http://www.hiteg.com Hiteg] SAMSUNG und Intel XScale basierende boards. (Deutsches Unternehmen in China)
* [http://www.hitex.de/ Hitex] Starter-Kits für Philips LPC2000, ST STR7, Atmel AT91M
* [http://www.iar.com/ IAR] Starter-Kits für Atmel, Oki, Philips, ST und TI
* [http://www.ic-board.de/index.php?cat=c12_ICswift-Module.html ic-board.de] Kommunikationsplattform auf Basis des AT91SAM7X256 mit Ethernet, USB, CAN und Funk Schnittstellen
* [http://www.keil.com/ Keil] Philips LPC2000 und ST STR7/9 Boards und Starter-Kits
* [http://www.lpctools.com/ LPCTools] bietet verschiedene Starter Kits für die LPC2000-Familie
* [http://www.makingthings.com/ MakingThings] Make Controller Kit (AT91SAM7X256)
* [http://mct.de/index.html MCT Paul und Scherer] Starterkits für ARM7 (NXP LPC2000, ADI ADUC7000)
* [http://shop.mikrocontroller.net Mikrocontroller.net Shop] Platinen mit AT91SAM7, LPC2xxx, JTAG
* [http://www.microcontroller-starterkits.de Microcontroller-Starterkits] Starter-Kits für verschiedene Microcontroller (D) preisgünstige Platinen (ab 12,95 Euro für LPC2129 und 2194) sowie Entwicklungsboard komplett bestückt
* [http://stores.ebay.de/Micro-Research Micro-Research] Development- und Header-Boards für LPC2000 und ADuC7000
* [http://www.olimex.com Olimex] Bulgarischer Anbieter günstiger ARM Prototypen- und Header-Boards (LPC2000, STR7, AT91SAM, ADI, TI, OKI u.a.)
* [http://www.propox.com/?lang=en Propox]
* [http://www.mcu-raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer2 from Raisonance] Focus auf STM32 mit sehr grossem Forum im STM32circle
* [http://www.revely.com/ Revely] Evaluations- und Demo-Boards mit Sharp ARM Controllern. Teilweise mit SVGA-Anschluss.
* [http://www.skpang.co.uk/catalog/index.php SKPang electronics] Entwicklungsboards für diverse ARM7/9 (UK)
* [http://www.dilnetpc.com SSV Embedded Systems] bietet verschiedene Starter Kits für die verschiedenen DIL/NetPC u.a. (A)DNP/9200 SBC mit AT91RM9200
* [http://www.taskit.de taskit] [https://www.ledato.de/shop_content.php?coID=10 Development- und Header-Boards für AT91SAM7S/X], AT91RM9200, AT91SAM9
* [http://www.toradex.com Toradex] ARM DevKits (XScale, Nvidia Tegra) (Schweiz)
* [http://thinkembedded.ch/ARM:::6.html Thinkembedded Webshop] Demoboarde,Debugger Cortex M (Schweiz)

== [[PIC]] ==

=== Herstellerseiten ===
* [http://www.microchip.com Microchip] Hersteller der PIC Microcontroller
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010014&part=SW006011 Microchip C18 Student Edition] - die "Student Edition" des Microchip C18 C Compilers für die PIC18 Serie ist kostenlos verfügbar.
* [http://www.powercontact.de Elektronikentwicklung von Systemtechnik LEBER] Offizieller Microchip Design Partner für professionelles Microcontroller Design und Hersteller von Leistungsstellern, Thyristorstellern und Halbleiterelais...

=== Entwicklungstools / Tutorials / Foren ===
* [http://www.osterer.co.at www.osterer.co.at] Entwicklungs-Board mit integrierten Programmer/Debugger für PIC18F4550.
* [http://www.martins-elektronikwelt.tk www.martins-elektronikwelt.tk] ICD1-Debugger-Nachbau im Kleinstformat u. SMD Technik (so groß wie eine halbe Scheckkarte).
* [http://www.sprut.de/electronic/pic/index.htm PIC-Microchip-Controller (www.sprut.de)] Diese Seite soll dem Anfänger die ersten Schritte in die Welt der Microcontroller der Firma Microchip erleichtern. Betrachtet werden die 14-Bit-Controller der Serien PIC16Fxxx bzw PIC12Fxxx.
* http://www.waitingforfriday.com/ Wer anstatt mit Delphi (sprut.de) lieber mit C++ oder C# arbeiten möchte, findet bei Simon Inns ein USB-Framework und zahlreiche interessante und anpassbare Anwendungen.
* [http://pic-projekte.de/ PIC-Projekte.de] Tutorials (u.a. für PIC C) und Projekte mit erklärten Codesnipseln (geeignet für Anfänger), [http://pic-projekte.de/phpBB3/ deutschsprachiges PIC Forum]
* [http://www.fernando-heitor.de PIC: Programmierung in CCS (www.fernando-heitor.de)] Dies ist eine weitere Seite, die dem Anfänger, der sich mit PICs beschäftigt, auf die Beine hilft. Sie befasst sich hauptsächlich mit dem CCS-Compiler und hat dazu ein sehr gutes Tutorial. Ausserdem bietet die Seite ein Forum speziell für PIC Mikrocontroller.
* [http://www.cc5x.de CC5X] Programmierkurs für PIC-Mikrocontroller in C (CC5X Compiler)] Programmierkurs mit Beispielen und Schaltplänen, fertige Hardware- und Softwarelösungen. In diesem Kurs sind auch einige Unterprogramme detailliert erklärt.
* [http://www.microchipc.com/ MicrochipC.com] Programmieren von PIC-Microcontrollern mit C. (Enthält auch Links und Bootloader für diverse PICs.)
* [http://www.amodio.biz/projects/PIC10BaseT/index.html Internetworking with Microchip Microcontrollers - PIC18F4620+ENC28J60]
* [http://pic18fusb.online.fr/wiki/wikka.php?wakka=WikiHome Wiki about Microchip USB PIC] (PIC18F2550, PIC18F4550...)
* [http://members.aon.at/electronics/pic/picpgm/index.html PICPgm - A free and simple PIC Development Programmer Software for Windows and Linux] Einfacher PIC Programmer für Windows und Linux. Unterstützt eine Vielzahl von PIC-Chips und wird ständig erweitert. Derzeit können PIC10F, PIC12F, PIC16F, PIC18F, PIC24H sowie dsPIC30F und dsPIC33F programmiert werden.
* [http://www.stolz.de.be InCircuit-Programmer und -Debugger (www.stolz.de.be)] Einfacher Nachbau des Microchip ICD2s. Zum Programmieren und Debuggen.
* [http://www.winpicprog.co.uk WinPicProg] Programmer und Tutorials für Anfänger von Nigel Goodwin (Englisch)
* [http://usbpicprog.org/ usbpicprog], an open source Microchip PIC programmer for the USB port. A wxWidgets based (cross platform) application to communicate with the usbpicprog hardware / firmware. This application is known to function well on Linux, Windows (XP or later) and Macosx.
* [http://www.tigal.com EasyPIC3, EasyPIC4, Easy8051A, EasyAVR, Easy-was-weiss-ich (www.tigal.com)] - Distributor für Produkte von [http://www.mikroelektronika.co.yu mikroelektronika] und weiteren Herstellern
*[http://www.pro-zukunft.de Pro Zukunft] Evaluation-Board für PIC16F84A, hands-on-training und Print-Lehrgang. Für Schulen, Ausbildungsbetriebe & Hobbyelektroniker.
* [http://www.wselektronik.at www.wselektronik.at] Bausatz für "Full Speed ICD2" (USB2.0, Debugger, Programmer) oder Fertiggerät erhältlich.
* [http://www.uchobby.com/index.php/2008/04/19/pic-development-linux-style/ How to setup for PIC microcontroller development on Linux] von Steven Moughan
* [http://www.dattalo.com/gnupic/gpsim.html#docs gpsim] is a full-featured software simulator for Microchip PIC microcontrollers distributed under the GNU General Public License.
* [http://www.mtoussaint.de/yapide.html YaPIDE] aims to be a fully featured Microchip PIC simulator for Linux (and probably other UNIXes). YaPIDE is a GUI only application. If you need a commandline based PIC simulator there is the excellent '''gpsim'''. The simulator kernel currently supports the PIC 16F628.
* [http://piklab.sourceforge.net/ Piklab] is an integrated development environment for applications based on Microchip PIC and dsPIC microcontrollers similar to the MPLAB environment. It integrates with several compiler and assembler toolchains (like gputils, sdcc, c18) and with the simulator '''gpsim'''. It supports the most common programmers (serial, parallel, ICD2, Pickit2, PicStart+) and debuggers (ICD2).
* [http://dev.frozeneskimo.com/software_projects:vpicdisasm vPICdisasm] is a Microchip PIC Mid-Range family firmware disassembler. This single-pass disassembler can read Intel HEX and Motorola S-Record formatted files containing valid PIC firmware. (GPL)
* [http://pikdev.free.fr/ PiKdev] is a simple graphic IDE for the development of PIC-based applications. It currently supports assembly language. C language is also supported for PIC 18 devices. PiKdev is developed in C++ under Linux and is based on the KDE environment.
* [http://www.yenka.com/en/Yenka_PICs/ Yenka PICs] lets you write routines using simple flowcharts, and test them on-screen, before using them to program real PIC or PICAXE chips. To help spread the news about Yenka, we're offering free copies of Yenka PICs for use at home or school.
* [http://gcbasic.sourceforge.net/ Great Cow BASIC] "Open Source BASIC programming tools for Microchip PIC and Atmel AVR microcontrollers"
* [http://openprog.altervista.org/OP_eng.html Open Programmer] - An open source [[USB]] programmer for [[PIC]] micros, [[I2C]]-[[SPI]]-MicroWire [[EEPROM]]s, some ATMEL [[AVR]] micros, generic I2C/SPI devices and (soon) other devices. Can work as [[ICD]] debugger.

=== Projektsammlungen/Einzelprojekte ===
* [http://www.martins-elektronikwelt.tk www.martins-elektronikwelt.tk] Viele Projekte mit den PIC Mikrocontrollern, u.a. SMS-Schaltzentrale, SD/MMC-FAT32-MP3-Player, Lichtschranken, Funk-Wetterempfänger, PS/2 am PIC usw.
* [http://www.Firmware-On-Demand.com Firmware-On-Demand] Umfangreiche Firmware-Bibliothek.
* [http://pic-projekte.de/hd44780_c18.html XLCD Librarie] Anleitung zum Ansteuern des HD44780 unter Verwendung der C18 XLCD Librarie
* [http://www.rentron.com www.rentron.com] Anfänger-taugliche Projekte für PIC und [[8051]] von Reynolds Electronics (Englisch)
* [http://www.circuitcellar.com/microchip2007/ Microchip 16-Bit Embedded Control 2007 Design Contest] bei [http://www.circuitcellar.com/ Circuit cellar]
* [http://mondo-technology.com/ Mondo Technologiy] Grosse Ansammlung von PIC-Projekten, u.a. SuperProbe: Logic Probe,(Auf der linken Seite ganz oben) Logic pulser, Frequency Counter, Event Counter, Voltmeter, Diode Junction Voltage, Capacitance Measurement, Inductance Measurement, Signal Generator, Video Patern, Serial Ascii, Midi Note, R/C Servo, Square Wave, Pseudo Random Number, ir38, PWM in einem... (PIC16F870)
* [http://micrognurtos.sourceforge.net uGNU/RTOS] is a microcontroller-targeted serial real time operating system. It has been ported to USART capable Microchip PIC16 devices. It supports I/O operations and some internal registry operations. The user can interact with the chip through the RS-232 serial cable and a shell. The user can type a small list of commands and see the results on the chip's outputs. (LGPL)
* [http://pic-projekte.de www.PIC-Projekte.de] Hier finden sich einige interessante Projekte mit PIC Mikrocontrollern (z.B. Anleitung zum Ansteuern eines HD44780 komp. LCD von eA, Ansteuern eines KS0107/8 Controllers in ASM mit PIC) sowie Erklärungen zu den dazugehörigen Programmabschnitten. Außerdem gibt es eine Anleitung zum Herrstellen von Platinen. Besuchen Sie das [http://pic-projekte.de/phpBB3/index.php PIC-Forum] und diskutieren Sie mit bei spannenden Themen. Wenn Sie Fragen zu PIC µC der Firma Micochip haben, dann sind Sie hier richtig aufgehoben!
* [http://pic16f628a.blogspot.com/ Experiments with PIC16F628A] - PIC Programming in C

*Stevy's Homepage http://stevy.bplaced.com Pic Projekte die in C geschriebn wurden z.B 3D Engine, Grafik Display Ansteuerungen, Oszilloskip usw
* [http://www.simon-brenner.ch/projekte/rgb-led-stripe RGB Stripe mit 16bit Bus, realisiert mit PIC12F629]
* [http://scifi.pages.at/drakesoft/aulem_mypong/ Spiel PONG] auf einer 16x16 LED Matrix mit Ton, realisiert auf einem AVR.
* [http://hackinglab.org/ Pinguino Webpage] und [http://wiki.pinguino.cc/index.php/Main_Page Pinguino Wiki] ist ein Arduino-ähnliches Open Source und Open Hardware Projekt für 8-Bit (PIC18F2550, PIC18F4550) Mikrocontroller.

== [[Z8]] ==
* [http://groups.yahoo.com/group/z8encore/ Yahoo! Groups : z8encore] Yahoo-Gruppe, die sich mit den Z8 Encore! Mikrocontrollern beschäftigt (Anmeldung bei Yahoo erforderlich).
* [[Zilog Encore Experimentierplatine]] (Z8F6421 Familie mit DIP-40 Gehäuse)
*[http://www.thpeter.net Zilog Projekte] (Ein Z8Encore und ZNEO Projekt und viele Tips zum Programmieren und Debuggen)


== Programmierbare Logik ([[CPLD]]/[[FPGA]]/[[GAL]]) ==

* [http://www.opencores.org/ OpenCores.org], VHDL Sourcen
* [http://www.fpga4fun.com/ fpga4fun], umfangreiche Seite mit Einführung und Beispielen, berücksichtigt Xilinx & Altera
* [http://opencollector.org/history/freecore/ Freecore], unter 'Module library' gibt's einige freie Designs
* [https://digilent.us/ Digilent], Hersteller verschiedener FPGA/CPLD-Boards (u.a. Xilinx Spartan Starter Kit)
* [http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=39 Terasic], Anbieter von Altera FPGA-Boards
* [http://shop.trenz-electronic.de/catalog/ Trenz Elektronik], verkauft verschiedene FPGA/CPLD-Boards
* [http://www.xess.com/index.html XESS], Anbieter von FPGA-Boards (Xilinx), unter Support gibts es eine Menge Beispiele
* [http://members.optushome.com.au/jekent/FPGA.htm Private Seite von John Kent], enthält eine Menge Links und auch einige Designs
* [http://www.openpicide.org openPICIDE], Picoblaze IDE für Windows, Linux und Mac
* [http://www.mediatronix.com/Tools.htm Mediatronix tools], Picoblaze und DSP tools
* [http://www.ixo.de/info/usb_jtag/ ixo.de usbjtag] - USB-JTAG Adapter, fast kompatibel zu Altera USB-Blaster, wahlweise basierend auf FT245+CPLD oder Cypress FX2 Controller
* [http://www.fpgacpu.org/links.html FPGA CPU Links]
* [http://www.fpga-forum.com/wbb Forum mit allgemeinen Diskussionen zum Thema FPGA und FAQ's speziell zu den Cesys FPGA Karten]
* [http://www.cesys.biz Online Shop für Cesys FPGA Karten]

== DSP ==

* [http://www.tetrix-systems.de/embedded.html combined embedded Linux-DSP Solutions]
* [http://open.neurostechnology.com/node/1020 TI c54x DSP Compilertools (ohne Debugger)] frei für Open Source Projekte.

== Wettbewerbe (Contests) ==

Verschiedene Hersteller veranstalten zur Promotion ihrer Produkte Designwettbewerbe, aus denen teilweise komplette Projektunterlagen hervorgehen (Schaltung, Source).

'''2013'''
*[http://www.digilentinc.com/events/ddc2013/ digilent Design contest 2013]
*[http://www.ebv.com/index.php?id=1477 EBV verlost Infineon XMC4500 Cortex M4 Starter Kits]
*[http://www.energymicro.com/freekit Energy Micro verschenkt kostenlose Starter Kits]
*[http://www.challenge.toradex.com/ Toradex Wettbewerb, 100'000 USD in Preise]

'''2012'''
*[http://forum.energymicro.com/topic/150-contest-description/ EFM32 Design Contest 2012 von Energy Micro] Anmeldung bis zum 31.10.2012
*[http://dangerousprototypes.com/2012/09/03/announcing-the-open-7400-logic-competition-2012/ Open 7400 Logic Competition 2012] Anmeldung bis 31.10.2012
*[http://beagleboard.org/CapeContest/ beaglebone Cape Contest] Anmeldung bis 31.Dezember 2012
'''2011'''
*[http://www.designspark.com/chipkitchallenge DesignSpark chipKIT Challenge] bis 27.03.2012
*[http://www.555contest.com 555 Contest]
*[http://www.circuitcellar.com/nxpmbeddesignchallenge/ NXP and ARM/mbed challenge]
*[http://www.ebv.com/en/products/stm32-design-contest.html STM32 Design Contest] von EBV Elektronik und STMicroelectronics
* [http://www.renesasrulz.com/community/rx-contest The RX MCU Design Contest] und die Top 3 im [http://www.eevblog.com/2011/06/05/eevblog-174-renesas-rx-design-contest-winners/ Video] bei Dave Jones auf EEVBlog.com
* [http://www.cypress.com/?id=3298 ARM Cortex-M3 PSoC® 5 Design Challenge]
* [http://www.instructables.com/contest/micro/ SparkFun Microcontroller Contest] bis 13.02.2011
* [http://www.elektroniknet.de/bauelemente/news/article/27963/0/Wer_entwickelt_die_beste_Anwendung_mit_dem_EFM32/ EFM32 Design-Wettbewerb] von Elektronik, Avnet-Memec und Energy Micro
* [http://www.freescale.com/webapp/sps/site/overview.jsp?code=KINETIS_MAKEIT_CHALLENGE&tid=vanKINETIS_MAKEIT_CHALLENGE Make It Challenge: Kinetis MCUs] von Freescale

'''2010'''
* [http://www.schmartboard.com/index.asp?page=mcu_2010 SchmartBoard 2010 MCU Challenge]
* [http://www.digilentinc.com/showcase/contests/designcontest.cfm?ContestID=6 Digilent Design Contest 2010]
* [http://www.parallax.com/go/holidaychallenge Parallax & iGen Student LED Holiday Challenge]
* [http://www.embeddedspark.com/upcomingchallenge/ The embeddedSPARK 2010 SUMMER Challenge]
* [http://www.libelium.com/tienda/catalog/contest.php?language=en Libelium Arduino Open Hardware Contest]
* [http://www.circuitcellar.com/designstellaris2010/index.html Texas Instruments DesignStellaris 2010]
* [http://www.wizwiki.net/main/ iMCU Design Contest] (WIZnet)
* [http://www.elo-web.de/elo/entwicklung-und-projekte/ping-pong/elo-programmierwettbewerb-2010 ELO-Programmierwettbewerb 2010] (Atmega8, PingPong-Platine, 31.3.10)
* [http://www.lpc1100challenge.com/ NXP LPC1100 Design Challenge] (Cortex-M0 based LPC1100)

'''2009'''
* [http://arduinofun.com/blog/2009/11/01/fun-with-arduino-contest/ Fun with Arduino Contest]
* [https://www.xmos.com/challenge/ XMOS Challenge]
* [http://www.designmsp430.com/ Design MSP430 Ultra-Low Power Challenge]
* [http://makezine.com/halloweencontest/ Make: Halloween Contest 2009], sponsored by Microchip Technology!
* [http://www.bricogeek.com/contest/let-arduino-play/resultados.php Let Arduino Play Contest]
* [http://www.dlpdesign.com/designcontest/ DLP Design DLP-232PC Design Contest]
* [http://www.libelium.com/tienda/catalog/contest.php Arduino contest by Libelium]
* [http://www.expli.de/wettbewerb/coole-avr-microcontroller-elektronik-ideen/ EXPLI Elektronik Wettbewerb]: Die coolsten Elektronik Projekte & AVR Microcontroller Anleitungen
* [http://www.stm32circle.com/projects/contest.php STM32 Primer2 Design Competition 2009]
* [http://www.parallax.com/Resources/ApplicationsContests/Contests/200910PropellerContest/tabid/846/Default.aspx 2009/2010 Propeller Design Contest]

'''2008'''
* [http://www.parallax.com/tabid/720/Default.aspx Propeller Design Contest]
* [http://www.psocidcindia.com/index.php PSoC Innovator Design Challenge India 2008]
* [http://www.mypic32.com Microchip PIC32 Design Challenge]
* [http://contest.renesasinteractive.com/ HEW Target Server Design Contest 2008]
* [http://www.stm32circle.com/projects/result_contest_2008.php STM32 Primer Design Competition 2008]

'''2007'''
* [http://www.circuitcellar.com/wiznet/index.html WIZnet iEthernet Design Contest 2007]
* [http://www.circuitcellar.com/microchip2007/ Microchip 16-Bit Embedded Control 2007 Design Contest]

'''2006'''
* [http://www.designmsp430.com/View.aspx 2006 MSP430 eZ Design Contest]
* [http://www.luminarymicro.com/DesignStellaris2006 Luminary Micro DesignStellaris2006]
* [http://www.circuitcellar.com/avr2006/ Atmel AVR Design Contest 2006]

'''2005'''
* [http://www.jandspromotions.com/philips2005/index.htm Philips ARM Design Contest 2005] (LPC213x)
* [http://www.circuitcellar.com/renesas2005m16c/index.htm Renesas M16C Design Contest 2005]
* [http://www.edn.com/article/CA516007.html Cornelius van Drebbel's Mad Design Contest] (NEC)

'''2004'''
* [http://www.circuitcellar.com/avr2004/ Atmel AVR 2004 Design Contest]
* [http://www.circuitcellar.com/psoc2004/ PSoC High Integration Challenge 2004]
* [http://www.jandspromotions.com/zilog2004/ Zilog 2004 Flash Nets Cash Design Contest] (eZ80Acclaim!)
* [http://www.jandspromotions.com/wirelesschallenge/index.html 2004 Freescale Wireless Design Challenge] (MC13191/92/93 RF Transceivers, [[Meshnetics Zigbee|ZigBee]])

'''2003'''
* [http://www.circuitcellar.com/fi2003/ MOTOROLA FLASH INNOVATION 2003 DESIGN CONTEST] (Motorola HC08)
* [http://www.circuitcellar.com/renesas/ Renesas H8 Design 2003 Contest]
* [http://www.jandspromotions.com/zilog2003/ ZiLOG Flash for Cash Z8 Encore®! International Design Contest]
* [http://www.jandspromotions.com/efield203/index.htm 2003 Motorola E-Field Sensor Contest] (MC33794)

'''2002'''
* [http://www.circuitcellar.com/flash2002/ Mad Dash for Flash Cash] (Microchip, PIC)

'''2001'''
* [http://www.circuitcellar.com/dl2001/ Atmel 'Design Logic 2001' Design Contest]
* [http://www.circuitcellar.com/msp430/ MSP430 Design Contest]

== Interfaces & Protokolle ==
Siehe auch [[Linksammlung#Schnittstellen]]

=== Infrarot (IR) ===

* [http://www.sbprojects.com/knowledge/ir/index.php Übersicht IR-Protokolle] von San Bergmans (engl.): ITT, JVC, NEC, Nokia NRC17, Sharp, Sony SIRC, Philips RC-5, RC-6, RC-MM, RECS80, RCA, X-Sat
* [http://www.vishay.com/docs/80071/dataform.pdf Data formats for IR controls (PDF)] von Vishay.
* [http://www.ostan.cz/IR_protocol_analyzer/ IR protocol analyzer] (Freeware)

=== Parallelport ===

* [http://www.projects-lab.com/?p=1139 ECPMON] - ECP Parallel Port Monitor ([[M16C]]/62P)

=== iPod ===
* [http://ipodlinux.org/IPod_to_T%26A_remotecontrol_adapter IPod to T&A remotecontrol adapter] ([[PIC]]-Projekt)(Link defect)
* http://jasongarr.wordpress.com/project-pages/ipod-clickwheel-hack/

=== [[RFID]] ===

* [http://www.alexanderguthmann.de/RFIDemulator.html RFIDemulator] - Beschreibung eines RFIDemulators zum klonen von Tags
* [http://www.mwjournal.com/journal/article.asp?HH_ID=AR_905 Radio Frequency Identification: Evolution of Transponder Circuit Design] - Übersichtsartikel aus dem Microwave Journal
* [http://www.foebud.org/rfid Die StopRFID-Seiten des FoeBuD e.V.]
* [http://www.rfzone.org/free-rf-ebooks/ PDF-Bücher (englisch) ]- Bücher über RF, Antennen und elektromagnetische Wellen.

* http://cq.cx/proxmark3.pl Jonathan Westhues RFID Leser/Schreiber/Cloner

http://www.message_bocracco.com/

==== ~ 125 kHz ====

*[http://t4f.org/en/projects/open-rfid-tag Open RFID Tag]

==== 13,56 MHz RFID ====
* [http://www.openpcd.org/ OpenPCD - a free 13.56MHz RFID reader design] for Proximity Coupling Devices (PCD) based on 13,56MHz communication. This device is able to screen informations from Proximity Integrated Circuit Cards (PICC) conforming to vendor-independent standards such as ISO 14443, ISO 15693 as well as proprietary protocols such as Mifare Classic. (AT91SAM7S128 [[ARM]] Projekt)
* [http://www.rf-dump.org/ RFDump] is a backend GPL tool to directly interoperate with any RFID ISO-Reader to make the contents stored on RFID tags accessible. (Linux)

==== 2,4 GHz RFID ====
* [http://www.openbeacon.org/ OpenBeacon] - a free active 2.4GHz beacon design. (Reader: USB oder Ethernet; Tags: RF_Chip: NRF24L01, PIC16F684)

=== [[DMX512]] ===
* [http://www.soundlight.de/techtips/dmx512/dmx512.htm DMX-512 - was ist das?] Eine Übersicht von SOUNDLIGHT.
* [http://dworkin-dmx.de/ USB DMX Interface] Bausatz /Fertiggerät USB DMX Interface
* [http://www.oksidizer.com/electronic/spp2dmx/index_en.html OksiD DMX 3/1 is a Standard Parallel Port DMX 512 interface for IBM compatible PCs]. Drei Output Universe und ein Input Universe (Universe = 512 channels). Open project. All source code and schematics are available for free.
* [http://www.usbdmx.com/usb_dmx_interface.html USB DMX Interface revision 1.3] - opto isolated, bus powered, DMX512 from/to [[USB]]interface with both in and out universes. Cheap and simple to build.
* [http://www.dmx512-online.com/ Ujjal's DMX512 Seite]
* [http://llg.cubic.org/dmx4linux/ DMX4Linux 2.6] - A DMX device driver package for Linux (incl. hardware schematics with TI [[MSP430]])

=== Verschiedenes ===
* [http://www.taelektroakustik.de/deu/index.htm T&A Kommandos] - '''RC''' und '''RCII''' Kommandoset der Philips PRONTO Familie zur Steuerung von Audiogeräten. Dokumentation siehe unter Downloads.
* [http://www.marjorie.de/ps2/ps2_protocol.htm Das PS/2 Maus und PS/2- oder AT-Tastatur-Protokoll] (Original auf [http://www.computer-engineering.org/])
* [http://www.hth.com/snap/ S.N.A.P - Scaleable Node Address Protocol]. S.N.A.P is an free and open network protocol. The protocol was primary developed for PLM-24 based home automation and control systems but it is a generic protocol and not limited to this. S.N.A.P can be used in any type of applications where an easy to learn and light weighted network protocol is needed.
* [http://www.ulrichradig.de/home/index.php/avr/avr_-_rc PPM / PWM Encoder/Decoder für R/C Funkfernsteuerungen] von Ulrich Radig (AVR, C)
* [http://www.national.com/analog/interface/lvds_owners_manual LVDS Owner's Manual - 4th Edition] von National Semiconductor
* [http://www.mictronics.de/?page=becker Becker Unilink]
* [http://users.ntplx.net/~andrew/sony/unilink/ Sony UniLink]
* [http://www.vending.org/technology/MDB_Version_4.pdf Multi-Drop Bus / Internal Communication Protocol (MDB / ICP)]

== Elektronikversender‎ ==

siehe [[Elektronikversender‎]]

== Leiterplattenhersteller ==

siehe [[Platinenhersteller]]

== Schulungen (Online) ==

* [http://www.esacademy.com/myacademy/ www.esacademy.com] (engl.) - C, CAN, I²C, BlueTooth, PWM, USB, 51LPC, ARM (Einführung)
* [http://www.elprak.ch Elektronik in der Praxis] Präsentationen zu verschiedenen Themen der Elektronik in der Praxis. Lötvideo, das den zeitlichen Ablauf beim Löten anschaulich darstellt.
* [http://www.national.com/onlineseminar/ www.national.com] - Amplifiers, Audio, Data Acquisition, Die Products, Displays, Interface, Microcontrollers, Military/Aerospace, Power, Thermal Management, Wireless
* [http://www.circuitrework.com Circuit Technology Center] - Surgeon grade rework and repair, by the book and guaranteed. Deeplink: [http://www.circuitrework.com/guides/guides.shtml Guides]
* [http://www.onlinetutorials.de/index.htm onlinetutorials.de] - Linksammlung zu Tutorials für höhere Programmiersprachen ([[HLL]]) wie C, C++, Java, BASIC, Perl, PHP, ...
* [http://www.awce.com/classroom/ AWCE Interactive Classroom] - Embedded Systems (Using the APP-IV with GCC, Getting Started with the PIC 18F Family), Electronics (CLARC/HBSIG DSP Study Group, Basic Circuits), RoadMap to Programmable Logic
* [http://www.ibiblio.org/kuphaldt/socratic/ Socratic Electronics] (englisch)
* [http://www.embedded.com/design/multicore/201200638;jsessionid=4T1T0OZQW4PFSQSNDLRSKH0CJUNN2JVN?printable=true The basics of programming embedded processors] von Wayne Wolf. Neun Artikel bei embedded.com (englisch)
* [http://webcast.berkeley.edu/course_details.php?seriesid=1906978507 EE 42/EE 100 Introduction to Digital Electronics] - Webcast, Spring 2008 (englisch)
* [http://freevideolectures.com freevideolectures.com] - Webcasts zu naturwissenschaftlichen Theman (englisch)
* [http://www.circuitsage.com/ Circuit Sage], a complete source of information to help you design circuits fast. (Linksammlung zu Software, Artikeln Büchern und Websites)
* [http://www.DieElektronikerseite.de Die Elektronikerseite] Umfangreiche Sammlung von kleinen Lehrgängen und Schaltungen. Ideal für Anfänger aber auch für Fortgeschrittene
* [http://homepages.internet.lu/absolute3/tronic/ 3D Virtual Development] - Sammlung von vielen Grundschaltungen im Bereich Oszillator, Operationsverstärker, Empfangstechnik. Vereinzelt in Englisch.
* [http://cws.gtc.edu/programs/objects/electronics.htm Learning Objects for Electronics] des Engineering Tech Wing of Gateway Technical College (Flash erforderlich)
* [http://ecee.colorado.edu/~bart/book/book/title.htm Principles of Semiconductor Devices] von Bart Van Zeghbroeck
* [http://itp.nyu.edu/physcomp/Intro/HomePage Introduction to Physical Computing] ([[AVR]], Arduino)
* [http://nptel.iitm.ac.in/courses.php?disciplineId=108 NPTEL ELearning Courses Electrical Engineering] (englisch)
*[http://www.energymicro.com/company/university-program-energy-micro University Program], Lernprogramm zum uC programmieren für Einsteiger (von [https://www.energymicro.com Energy Micro], ist jedoch universell anwendbar)

== Skripte ==

* [http://www.janson-soft.de/skripte/index.html Linksammlung von Volker Lange-Janson]
* [http://wwwex.physik.uni-ulm.de/lehre/physikalischeelektronik/phys_elektr/phys_elektr.html Physikalische Elektronik und Messtechnik] von Othmar Marti und Dr. Alfred Plettl, Universität Ulm
* [http://openbookproject.net//electricCircuits/index.htm Lessons in Electric Circuits I-VI] von Tony R. Kuphaldt

== Messequipment ==
* [http://www.filmetrics.com Filmetrics Inc.] (Filmetrics manufactures affordable thin-film measurement instruments capable of measuring thin films from 3nm to 0.5mm in thickness.)
* [http://www.pce-instruments.com PCE Instruments] (Entwicklung und Produktion für Prüfgeräte und Waagen.)
* [http://www.bmcm.de/ger/prgr-products.html BMC Messsysteme] Sensorik, Anschlusstechnik, Messverstärker, Messsysteme und Digital I/O ([http://www.bmcm.de/dld/misc-messkette-a4-04.07.pdf Produkt Uebersicht]) auch erhältlich [http://www.redacom.ch/messtechnik/bmcm/index.html hier]
=== Logikanalyse ===
* [http://www.pctestinstruments.com Intronix LogicPort], Günstiger, aber sehr leistungsfähiger Logikanalysator mit USB-Anschluß an PC (34Ch, 500MHz Timing, 34 x 2kSa mit Kompression, ca. 367 Euro / 459 SFr.- [http://thinkembedded.ch/Measurement-Tools/LogicPort-Logikanalysator::13.html hier] )
* Zeroplus LAP-Cxxxx (Familie von LA's mit unterschiedlichen Daten, 32kBit...2MBit, 16ch oder 32ch, 100MHz..200MHz, Preise von 90,-...1100,- Euro, zu kaufen [http://www.tigal.com/products_category.asp?cid=96 hier])
* [http://www.tech-tools.com/dv_main.htm TechTools DigiView], Günstiger Logikanalysator mit USB-Anschluß an PC (18Ch, 100MHz Timing, 128kSa mit Kompression, [http://elmicro.com/de/digiview.html ca. 430Euro])
* [http://www.tribalmicro.com/logic_an/ Tribalmicro], PC hosted LA (32ch, 40MHz Timing, 128kSa, ca. 1700$)
* [http://www.nci-usa.com/frame_products_overview.htm NCI GoLogic], Logikanalysator mit USB-Anschluß an PC (34 oder 72Ch, 500MHz Timing, 1 oder 2MSa, ca. 3000..5500$)
* [http://www.tek.com/products/logic_analyzers/index.html Tektronix], Verschiedene Geräte, standalone oder modular (ab 34ch, 2GHz Timing, ab 512kSa, gut und teuer)
* [http://www.home.agilent.com/DEger/nav/-536902443.0/pc.html Agilent], Verschiedene Geräte, standalone, modular oder PC-hosted (ab 34ch, ab 800MHz timing, ab 256kSa, gut und teuer)
* [http://www.sump.org/projects/analyzer/ Sumps LA], günstiges Projekt für einen LA basierend auf einem Digilent Spartan Board (32ch, 100MHz Timing, 256kSa, Kosten Digilent Board ca. 100$ + Versand/Zoll)
* [http://www.meilhaus.de/produkte/usb-mobile-messtechnik/?user_produkte%5BPATTR%5D=HPG_3-UPG1_3-UPG2_2&user_produkte%5BPR%5D=8&cHash=2c8edb93e2 Meilhaus Electronic - MEphisto Scope UM203] Robustes, mobiles 16 bit Kombi-Instrument 7 Mess-Geräte in einem! (ab 348€)
* [http://www.hacker-messtechnik.de/13722/59001.html TravelLogic TL2x36], Logikanalysator zum Anschluß an PC über USB, (36ch, 4GHz timing, 200MHz state, Speicher bis 72MBit, Preis ab ca. 500,- netto)
* [http://www.inovaflex.de/index.html Bus und Logic Analyzer] 100MHz Samplerate und integrierten SPI, I²C, CAN Interpreter, erweiterbar als Oszilloskop
* [http://www.saleae.com/logic/ logic] - Logik-Analyzer mit 8 Kanälen, mit Software zur Analyse von SPI, I2C, UART, etc... (ca 150$ + Versand/Zoll)
* [http://www.deditec.de/de/logikanalysatoren/prod/usb-logi-500.html DEDITEC USB-LOGI-500], kostengünstiges Einsteigermodell mit USB-Anschluß und dazugehöriger Software Logi+ (36Ch, Abtastrate 500MHz, 4096 Samples Speichertiefe/Kanal, ca. 236 Euro)
* [http://basic.io/index.php/component/virtuemart/alogic-analyzer-detail Alogic Analyzer]: Verfügt über USB-, I2C-, UART- und SPI-Protokoll-Dekoder. Vier oder zwei Kanäle mit bis zu 24 MHz Abtastrate. USB-High-Speed-Transfer zur kontinuierlichen Datenspeicherung. Aufzeichnung über Tage hinweg (nur durch Festplatte begrenzt). Preis 99,- Euro incl. MwSt.

* Eine Übersicht über verschiedene Selbstbauprojekte: [[Logic_Analyzer]]

* [http://www.timing-diagrams.com TimingAnalyzer] can be used to easily draw timing diagrams and perform timing analysis to find faults in digital logic systems. Written in Java, it runs on any platform that supports the Java Run-time Environment, JRE1.6.0 or Java Development Kit JDK1.6.0 or newer.

=== Oszilloskope ===

siehe die separate [http://www.mikrocontroller.net/articles/Oszilloskop Seite] zum Thema

=== Generatoren ===
[http://www.meilhaus.de/produkte/mess-und-steuer-karten/?user_produkte%5BPR%5D=23&cHash=64a269a3c6 Meilhaus Electronic - ME-6x00] Waveform-Generator - potentialfrei isolierte 16 bit Analog-Ausgabe-Karte (ab EUR 1138,00)

=== Handbücher für Messgeräte ===
Für ältere kommerzielle Messgeräte sind viele Handbücher im Web als PDF verfügbar. Hier eine Linkliste für den kostenlosen Download:
* [http://www.ko4bb.com/cgi-bin/manuals.pl KO4BB Didier Juges]
* [http://bama.edebris.com/manuals/ BAMA-Edebris (mirror)]
* [http://www2.faculty.sbc.edu/kgrimm/boatanchor/index.htm BAMA Originalseite K4XL]
* [http://www.to-way.com/teqman.html to-way.com (K7MLR)]
* [ftp://ftp.bluefeathertech.com/pub/electronics/testgear/ Bluefeathertech FTP-Server]
* [http://www.bitsavers.org/ Bitsavers, vor allem Computermanuals und Software]
* [https://www.logsa.army.mil/etms/online.cfm Handbücher der US-Army (->"i accept" -> "Enter the site" -> Suchbegriff z.B "Analyzer" in "Pub Title Text" eingeben -> search)]
* [http://www.eserviceinfo.com/browse.php eserviceinfo.com]
* [http://www.one-electron.com/FC_TestEquipment.html one-electron.com]
* [http://manoman.sqhill.com/ manoman]
* [http://www.nostalgiaair.org/ Nostalgia Air schematics, manuals, tube data]
* [http://pages.cthome.net/fwc/ Freds sehr alte (vor allem Militärelektronik-) Geräteliteratur, Röhrentechnik] und hier [http://pages.cthome.net/fwc/TO-DOC.HTM Übersicht zur Nummerierung der Militärhandbücher]
* [http://www.hpmemory.org/ressources/resrc_home.htm HP-Memory.org, alte Applications und HP-Journals]
* [http://www.ebaman.com/index.php/home Ebaman Registrierung per e-Mail erforderlich]

Eine [http://www.slack.com/elec.html Linksammlung zu Messgeräten], sehr ausführlich

== Vermischtes ==

=== Foren ===
* [http://forum.sparkfun.com/ Spark Fun Electronics] MicroController Ideas and Support (Englisch) ([[AVR]], [[PIC]], [[MSP]], [[ARM]], OpenOCD)
* [http://www.edaboard.com/ EDAboard.com] International Electronics Forum Center (Englisch)
* [http://stsboard.de STS Reparatur Forum] Forum für Radio und Fernsehtechniker
* [http://formu.iwenzo.de Elektronik Reparatur Forum] Informationselektroniker Reparatur Forum
* [http://www.elektrikforum.de Elektrik-Forum] Forum zum Thema Elektroinstallationen
* [http://www.eeweb.com/electronics-forum/ Electronics Forum] Electrical Engineering Community Forum (Englisch)
* [http://www.digikey.com/techxchange/community/microcontroller Digi-Key TechXchange Communities > Microcontroller Solutions Community]
* [http://forum.energymicro.com Forum von Energy Micro]

=== Videocasts und Podcasts ===

* [http://www.eevblog.com/ EEVblog] Electronics Engineering Video Blog von David L. Jones (englisch). ''Anm.: David ist Australier und das hört man. An die Sprechweise kann man sich aber gewöhnen. Und nicht erschrecken, wenn öfter mal ein drastisches Fourletterword auftaucht!''
* [http://www.theamphour.com/ The Amp Hour] Podcast mit Chris Gammell und David Jones (englisch)

=== Projektsammlungen ===
Meist in Englisch.
* [http://circuitscout.com/ Circuit Scout] - Online Suchmaschine
* [http://www.epanorama.net ePanorama.net]

* [http://www.discovercircuits.com Discover Circuits] a collection of 25000+ electronic circuits or schematics
* [http://www.next.gr/ Next] Electronic Circuit Database
* [http://www.beyondlogic.org/ BeyondLogic.org] Diverse Mikrocontroller und Interfacing Projekte
* [http://www.uoguelph.ca/~antoon/circ/circuits.htm Circuits for the Hobbyist] by VA3AVR
* [http://www.stefpro.de/ StefPro.de] Diverse Projekte und Datenblattsammlung nach Kategorien, Microcontroller, Digital und Analog... Sowie Tutorial "Grundlagen der Bestückung von Platinen" und anderes Wissen
* [http://www.schaltplaene-online.net/ www.schaltplaene-online.de] Umfangreiche Linksammlung zu Schaltplänen aller Art
* [http://www.halloweenmonsterlist.info/ MoNsTeRlIsT of Halloween Projects]
* [http://www.open-innovation-projects.org Open Innovation Projects] - Sammlung von offenen Projekten zu physischen Produkten, darunter etliche Mikrocontroller-Projekte. Man kann selber Projekte hinzufügen.

=== Referenzen, Beschreibungen, Standards ===
* Extraseite: [[Datenblätter]]
* [http://www.technick.net Technik.Net] Pinouts, Circuits and Guides
* [http://pinouts.ru/ pinout.ru] und [http://www.hardwarebook.info/ hardwarebook.info] - Online handbooks of hardware pinouts, cables schemes and connectors layouts
* [http://www.networktechinc.com/technote.html Keyboard, Monitor & Mouse Pinouts] for PC, SUN, MAC, USB, FireWire, RS232, Digital Flat Panel and EVC configurations
* [http://www.q1.fcen.uba.ar/materias/iqi/joygus/tvgames.html Special joysticks used in TV games]
* [http://microsym.com/editor/assets/intelhex.pdf Intel-Hex-Format (PDF)]
* [http://home.teleport.com/~brainy/fat32.htm FAT32 Structure Information] - Written by Jack Dobiash
* [http://www.pjrc.com/tech/8051/ide/fat32.html Understanding FAT32 Filesystems] mit Beispielen (engl.)
* [http://www.rev-ed.co.uk/docs/picaxe_manual3.pdf Microcontroller Interfacing Circuits] - Revolution Education Ltd.
* [http://www.digchip.com/application-notes/ Datenbank für ''Application Notes''] bei www.digchip.com
* [http://www.pavouk.org/hw/lamp/en_index.html#bigluz20w Compact Fluorescent Lamp (CFL)], Schaltungen von Energiesparlampen

=== Online-Bücher ===
* [http://www.allaboutcircuits.com/ All About Circuits] - Series of online textbooks covering electricity and electronics. The information provided is great for both students and hobbyists who are looking to expand their knowledge in this field. (Englisch)
* http://www.computer-books.us/ - überwiegend zu höheren Programmiersprachen. Englisch.
* [http://www.vias.org/feee/index.html FEEE - Fundamentals of Electrical Engineering and Electronics]
* [http://www.nrbook.com/a/bookcpdf.php Numerical Recipes in C, Second Edition (1992)]
* [http://www.specamotor.de/freebook.php Electrical drives for precision engineering designs] Prof.dr.ir. Compter
* [http://www.joretronik.de/Web_NT_Buch/Vorwort/Vorwort.html Das neue InterNetzteil- und Konverter-Handbuch] Dipl.-Ing. Jörg Rehrmann

=== Bedienungsanleitungen / Manuals ===
* [http://bama.edebris.com/manuals/ BAMA Archiv]
* [http://www.big-list.com/ Big-List.com] - This is a directory of over 600 dealers in used high technology equipment. Most deal in used electronic test equipment or semiconductor production equipment. Included are dealers in related high technology items, rental companies, equipment auction sites, test equipment manual dealers, foreign (non-U.S.) used equipment dealers, cal labs, and repair services.
* [http://ko4bb.com/manuals/ KO4BB's Manuals Repository]

=== Ungewöhnliche Basteleien (Hacks) ===
Auf eigene Gefahr und nicht immer ganz ernst... Meist in Englisch.

* Metablogs (tägliche News)
** [http://www.makezine.com/ Makezine]
** [http://www.hackaday.com/ Hack a Day]
** [http://www.hackedgadgets.com/ HackedGadgets]
** [http://www.hacknmod.com/ Hack N' Mod]
** [http://zedomax.com/blog/category/diy/ Zedomax DIY]
** [http://digital-diy.com Digital-DIY]
** [http://dangerousprototypes.com Dangerous Prototypes]
** [http://www.heise.de/hardware-hacks/ Heise Hardware Hacks]

* Foren
** [http://www.fingers-welt.de/home.htm Fingers elektrische Welt]
** [http://forum.hackedgadgets.com/ HackedGadgets Forum]
** [http://stsboard.de Reparatur Forum]


* Projektsammlungen
** Final Projects der Kurse [http://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/ ECE4760] (Designing with Microcontrollers) und [http://people.ece.cornell.edu/land/courses/ece5760/FinalProjects/ ECE5760] (Advanced Microcontrollers) an der Cornell University
** [http://www.coolcircuit.com/gadgets/ Cool Circuit]
** [http://www.electronics-lab.com/blog/ Electronics-Lab.com Blog]
** [http://blog.energymicro.com/category/hack-a-gecko/ Hack a Gecko Blog] Energy Micro Hacks

* DIY-Anleitungen
** [http://www.instructables.com/ instructables]
** [http://www.scitoys.com/ Scitoys] You Can Make With Your Kids

* Mix
** [http://www.evilmadscientist.com Evil Mad Scientist Laboratories] - u.a. The Flying Spaghetti Monster, on toast ;-)
** [http://home.earthlink.net/~lenyr/index.html Spark, Bang, Buzz and Other Good Stuff] ([http://www.sparkbangbuzz.com Neue Sachen])
** [http://www.electricstuff.co.uk/ Mike's Electric Stuff] - Antique Glass, Tesla coils and high-voltage stuff, Lasers
** [http://electricity.pbwiki.com/ DHS electricity]
** [http://www.elephantstaircase.com/wiki/index.php?title=Main_Page Elephant Staircase]
** [http://mycpu.eu Eine selbstgebaute CPU aus TTL-Gattern]
** [http://www.knollep.de/ Knolles Bauanleitungen]
** [http://www.ikalogic.com/index.php ikalogic.com]
** [http://www.electronicsinfoline.com/ Electronics Infoline]
** [http://www.uchobby.com/ uC Hobby]
** [http://elettrolinux.com elettrolinux] - Elektronik und Linux (engl.)
** [http://electronicfox.at.tf/ electronicfox] - Verschiedene Projekte mit [[AVR]], Fernbedienungen und deren Aufbau sowie Decoder und alten ICs aus dem Recyclinghof
** [http://www.techfocusmedia.net/archives/fresh-bytes/ Fresh Bytes von Techfocusmedia]

=== Zeitschriften über Elektronik und µC ===
* [http://www.elektroniknet.de/ Elektronik - Das Elektronikmagazin für Entwickler]
* [http://www.eue24.net/ E&E Faszination Elektronik] - Magazin für Elektronik-Entwickler und Elektronik-Interessierte
* [http://www.embedded.com embedded.com] - Hauptaugenmerk auf die Philosophie drumherum
* [http://www.siliconchip.com.au/ Silicon Chip] - Freie Artikel unter ''Free Preview''
* [http://www.circuitcellar.com/ Circuit Cellar] - Freie Artikel unter ''Digital Library''
* [http://www.elektronikpraxis.vogel.de/themen/hardwareentwicklung/mikrocontrollerprozessoren/ Elektronikpraxis - Das professionelle Elektronikmagazin]
* [http://www.funkamateur.de/ FUNKAMATEUR] - Elektronik, Amateurfunk, CB-Funk u. v. a. m.
* [http://www.edn.com/ EDN] (etwas schwer zu finden, aber lesenswert: die [http://www.edn.com/channel/Design_Ideas.php Design Ideas] und das [http://www.edn.com/archive/ Archiv der Druckausgaben])
* [http://www.franzis.de/elo-das-magazin ELO - Das Magazin] für Elektronik-Einsteiger
* [http://techonline.com/ TechOnline]
* [http://www.elektor.de/ Elektor]
* [http://www.techbriefs.com/tech-briefs/electronics-techbriefs NASA Tech Briefs] - Electronics & Computers
* [http://et.nmsu.edu/~etti/ Technology Interface Journal]
* [http://dev.emcelettronica.com/ Your Electronics Open Source]
* [http://www.element-14.com element14.com] is an information portal and community specifically built for electronic design engineers.
* [http://www.itwissen.info ITWissen.info] (gutes Lexikon)
* [http://www.nutsvolts.com Nuts'n'Volts] Amerikanisches Elektronikmagazin mit Online Blog
* [http://de.rs-online.com/web/generalDisplay.html?id=eTech eTech] von RS Online
* [http://www.eeweb.com/ EEWeb], a premier electrical engineering community for hardware designers.

[[Kategorie:Listen]]

AVR In System Programmer

2013-08-29T15:26:30Z

M-w: Programmer/Signalwandler

== Einführung ==

In-System-Programming (ISP) bedeutet, einen Mikrocontroller oder anderen programmierbaren Baustein im eingebauten Zustand zu programmieren. Dazu muss der Mikrocontroller entsprechend beschaltet sein. Das bedeutet, die benötigten Anschlüsse am Mikrocontroller müssen zugänglich und nicht ohne weitere Vorkehrungen anderweitig benutzt sein - siehe [http://www.atmel.com/images/atmel-2521-avr-hardware-design-considerations_application-note_avr042.pdf Atmel Application Note AVR042].

Atmel verwendet für ihre 8-Bit RISC Mikrocontroller zum Teil unterschiedliche ISP-Protokolle. Das bekannteste davon wird einfach als ISP bezeichnet. Insgesamt findet man:

;ISP:Der Normalfall. Bei vielen, aber nicht allen AVRs teilen sich [[SPI]]- und ISP-Schnittstelle die Pins. Je nach AVR gibt es leichte Unterschiede im Protokoll. Das Protokoll für einen Typ ist im Datenblatt unter ''Memory Programming -> Serial Downloading'' beschrieben.
;TPI:Tiny Programming Interface. Einige AVRs der Tiny-Serie, besonders die 6-Pin Tinys.
;PDI:Programming and Debugging Interface. Die XMEGAs.
;JTAG:AVRs mit [[JTAG]] Debugging-Schnittstelle lassen sich auch über JTAG in-system-programmieren.
;Bootloader:Einige wenige AVRs kommen bereits mit einem einprogrammierten [[Bootloader]]. Bei diesen kann man ein zum Bootloader passendes Programm nutzen um den AVR über eine im Bootloader definierte Schnittstelle programmieren. Auf Bootloadern basierende Systeme haben ansonsten ein Henne-Ei Problem. Irgendwie muss der Bootloader einmal konventionell in den AVR programmiert werden, zum Beispiel mit ISP.

Atmels [[debugWire]] ist keine Programmierschnittstelle, sondern eine reines Debugging-Interface. Zum Programmieren verwendet man bei AVRs mit debugWire daher normalerweise ISP.

Atmel hat für die AVR 8-Bit RISC Mikrocontroller mehrere Application Notes herausgegeben, auf deren Basis eine Vielzahl von Programmiergeräten (''programmer'') entwickelt wurden.

Natürlich liefert Atmel auch eigene, fertige Programmiergeräte (AVRISP (mk I), AVRISP mk II, [[AVR-Dragon]], ...), Programmiersoftware (AVRProg, AVR Studio) und Entwicklungsboards mit integriertem Programmiergerät (z. B. [[STK500]]).

<big>FAQ/Tipp: '''"Welchen ISP-Adapter sollte man sich zulegen oder bauen?"'''</big>

Man sollte sich einen fertigen, original Atmel (keinen Clone) ISP-Adapter kaufen. Zum Beispiel für ISP (und PDI) Programmierung '''Atmels original [[AVR_In_System_Programmer#Atmel_AVRISP_MKII|AVRISP mkII]] für rund 36,- Euro'''.

Das ist eine Investition, die viel Zeit und Ärger spart, denn es geht nichts über zuverlässiges Werkzeug. Beim Umgang mit µCs ist es sehr frustrierend an drei Fronten gleichzeitig zu kämpfen:
# Bugs in der Software,
# Bugs in der Schaltung und
# Bugs/Probleme beim ISP-Adapter-/PC-Gespann.

Wenigstens Probleme mit dem ISP-Adapter lassen sich durch den Kauf eines zuverlässigen ISP-Adapters eliminieren. Siehe auch diverse Forenbeiträge u.a. [http://www.mikrocontroller.net/topic/91042#778908] und [http://www.mikrocontroller.net/topic/153841#1447882].

Sehr unzuverlässig sind häufig billige oder selbstgebaute Programmierkabel mit nichts außer ein paar Widerständen. Unzuverlässig sind häufig auch billige oder selbstgebaute Programmierkabel mit einem einfachen Bustreiber. Nur weil sie bei manchen funktionieren heißt das nicht, dass sie überall problemlos funktionieren.

Parallelport- (Druckerport-) ISP-Adapter funktionieren gar nicht, wenn man sie mit einem USB <-> Druckerport Adapter an einen USB-Port am PC anschließt. Einfach (unintelligente) ISP-Adapter für die serielle Schnittstelle funktionieren gar nicht oder extrem langsam, wenn man sie mit einem USB <-> Seriell Adapter am PC anschließt. Gute intelligente serielle Programmieradapter, wie der in Atmels STK500 eingebaute, funktionieren normalerweise mit einem USB-Adapter.

Bei allen Programmieradaptern mit eigener Firmware, einschließlich der Original-Adapter von Atmel, ist man darauf angewiesen, dass der Hersteller wenn nötig Firmware-Updates bereitstellt. Bei Clones ist die Versorgung mit Firmware manchmal fraglich.

Oftmals funktionieren auch die Treiber der Clones unter 64-Bit Betriebssystem nicht richtig oder nur mit Tricks, die leider wichtige Sicherheitsfunktionen des Betriebssystem abschalten. Der [[AVR_In_System_Programmer#Atmel_AVRISP_MKII|AVRISP mkII]] funktioniert dagegen auch unter Windows 7 (64-Bit).

== Application Notes ==
* [http://www.atmel.com/dyn/resources/prod_documents/DOC0943.PDF AVR910] (PDF) "''Low-cost''" ''In-system programming'' ('''AVRISP''') beschreibt einen einfachen, kostengünstigen Programmieradapter zur Übertragung von Programmen in den Mikrocontroller. Auf dem Programmer befindet sich ein Mikrocontroller (natürlich von Atmel ;-), der serielle Steuerkommandos und Daten vom PC in Programmiersignale für den Mikrocontroller umsetzt.

* [http://www.atmel.com/dyn/resources/prod_documents/doc2568.pdf AVR911] (PDF) ''Open source serial programmer'' ('''AVROSP''') beschreibt eine ''open source'' Programmiersoftware zur Übertragung von Programmen in den Mikrocontroller.

* [http://www.atmel.com/dyn/resources/prod_documents/doc1644.pdf AVR109] (PDF) ''Self-Programming'' mit Hilfe eines [[Bootloader|Bootloaders]]. Hier wird im Mikrocontroller zunächst ein mikrocontroller-spezifisches Bootloader-Programm abgelegt. Dieses Programm empfängt das eigentliche Benutzerprogramm oder Daten z. B. über einen seriellen Anschluss ([[UART]]), legt es ggf. im Speicher (Flash-ROM, EEPROM) ab und führt ggf. anschliessend das Benutzerprogramm aus.

== Pinbelegung ==
===ISP===
Die Standard-Pinbelegung des ISP-Steckers zum Anschluss des Mikrocontrollers sieht nach obigen Application Notes und der [http://www.atmel.com/dyn/resources/prod_documents/doc2521.pdf AVR042] (PDF) folgendermaßen aus (Anschluss auf der Platine, Ansicht von oben). Atmel bevorzugt dabei bereits seit Jahren den 6-poligen Anschluss.

[[Bild:avr-isp-pinout.png|right]]

10-poliger 6-poliger
Anschluss Anschluss

1 MOSI 1 MISO
2 VCC 2 VCC
3 - (*) 3 SCK
4,6,8,10 GND 4 MOSI
5 RESET 5 RESET
7 SCK 6 GND
9 MISO

Pin 1 ist am Pfostenstecker mit einem kleinen Pfeil gekennzeichnet.

Um Verwechslungen zu vermeiden, empfiehlt es sich, für die einzelnen Leitungen unterschiedliche Farben zu verwenden. Atmel hat dafür keine Festlegung getroffen, so dass es keinen festen Standard gibt. Üblich ist jedoch eine Farbzuordnung wie beim [https://guloshop.de/shop/Mikrocontroller-Programmierung/guloboard-G6::5.html guloboard]:

1 MISO weiß
2 VCC rot
3 SCK blau
4 MOSI grün
5 RESET gelb
6 GND schwarz

(*) Einige Programmieradapter (Ponyprog-Adapter nach Lancos-Schaltplan) unterstützen an Pin 3 des 10-poligen Steckers eine LED (Kathode an Pin), die "Programmierzugriff" signalisieren soll. Dies ist aber kaum nützlich, daher wird der Pin auch von Atmel als N/C (not connected) definiert und beim original Atmel AVRISP mit GND verbunden.

Der 10-polige Anschluss wurde von der Firma Kanda beim STK200 verwendet und ist deshalb auch als "Kanda-Standard" bekannt und war zur Zeit der STK200 Programmieradapter relativ weit verbreitet. Die Anschlussbelegung über einen 6-poligen Stecker stammt von Atmel selbst und ist platzsparender auf der Platine.

Am besten kauft oder fertigt man sich einen Adapter 6 <-> 10 (siehe [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?products_id=190], [http://www.watterott.com/de/AVR-ISP-Programmieradapter], [http://www.watterott.com/de/AVR-Programmier-Kabel], [https://guloshop.de/shop/Adapterkabel/Programmieradapterkabel-6-polig-10-polig-lang::9.html]), dann lassen sich praktisch alle Boards mit jedem Programmer programmieren.

[[Datei:Kabeloben.jpg]]
[[Datei:Kabelunten.jpg]]
[[Datei:isp_kab.jpg]]

Zehnpolige Messerleisten (Wannenstecker) zur Montage auf einer µC Platine zum verpolungssicheren Anschluss des Programmieradapters sind fast "überall" verfügbar, nach den sechspoligen muss man häufig etwas suchen. Mittlerweile sind sie endlich bei Reichelt erhältlich (WSL 6G). 
Alternativ bleibt nur der Griff zu den nicht verpolungssicheren 2xN Stiftleisten (z. B. 2x40), wobei man eine Stiftleiste auf 2x3 Pole kürzt.

Sechspolige Federleisten (Pfostenbuchsen) zum Anquetschen an ein Programmierkabel sind dagegen zumindest bei den großen Versendern und Distributoren erhältlich (z. B. von Bürklin Art.53F3500; Conrad Art.701980-62; Farnell Art.1097021; Reichelt PFL 6). Kleine lokale Elektronikläden führen diese jedoch häufig nicht. Zu den sechpoligen Pfostenbuchsen gibt es keine Alternative, wenn man ein sechpoliges Programmierkabel bauen möchte. Zehnpolige Pfostenbuchsen lassen sich nicht auf sechs Pole kürzen. Korrektur: Man kann die äußeren pins ( 2 rechts, 2 links) einfach rausdrücken, dann passt der 6pol in die Buchse. Verpolungsschutz besteht weiterhin.

Je nach Programmieradapter hat der VCC-Anschluss unterschiedliche Funktionen:

1. Versorgung des Programmieradapters mit Strom aus der Schaltung, wie es bei vielen Parallelport-Adaptern der Fall ist.

2. Versorgung der Schaltung mit Strom aus dem Programmieradapter. Dies ist insbesondere beim STK500 möglich und dank dessen programmierbarer Versorgungsspannung manchmal ganz praktisch.

3. Messung der Betriebsspannung der Schaltung, so dass der Programmieradapter sich auf diese Spannung einstellen kann und so ein 3,3 V Board mit 3,3 V und ein 5 V Board mit 5 V programmiert. So wie zum Beispiel beim AVRISP mkII. Daher wird VCC auf neueren Schaltbildern auch als Vtg oder VTref bezeichnet (Atmel kann sich da nicht auf eine Bezeichnung einigen).

'''Je nach verwendetem Programmer muss man daher sorgfältig auf die Beschaltung von VCC/Vtg/VTref und auf die Stromversorgung von Board und Programmer achten.'''

===TPI===

Die TPI-Programmierung setzt sich aus mehreren Schichten zusammen: Hardware (Ansteuerung der IO-Pins), Speicher-Management (stellt Funktionen zum Flashen bereit) und der Speicher selbst.

Data 1 2 VCC
Clock 3 4 N.C.
Reset 5 6 GND

Standard TPI connector used on e.g. STK600 and AVRISP mkII.

===PDI===
====Atmel Board-Schnittstelle & AVRISP MkII ====
Für Mikrocontroller-Boards schlägt Atmel einen 6-Pin Header, 2,54 mm Raster, mit folgender Pinbelegung vor (Ansicht von Oben):

DATA 1 2 VCC
N.C. 3 4 N.C.
CLK 5 6 GND

(N.C.: Not Connected, nicht verbunden). Diese Belegung wird auch von Atmels AVRISP MkII im PDI-Modus verwendet.

Bei Atmels eigenem XPlain Eval-Kit und anderen Programmieradaptern geht es zur Zeit jedoch noch fröhlich durcheinander. Folgenden Pinbelegungen lassen sich finden.

====Atmel XPlain Eval-Board====

Hier hat Atmel die Xmega PDI- und JTAG-Schnittstelle gemeinsam auf den Header J100 gelegt. Die PDI-Belegung ist wie folgt:

1 2 GND
3 4 VCC
5 6 CLK
VCC 7 '''8 DATA'''
9 10 GND

Nur jeweils ein VCC- und ein GND-Anschluss muss verwendet werden. Es bieten sich die Pins 2 und 4 an.

Man beachte die Position von DATA auf Pin 8 bei dieser Belegung von PDI auf dem XPlain JTAG-Header.

====Atmel JTAGICE MkII====

Einige sehr alte JTAGICE MkII unterstützen kein PDI. Alle neueren, in den letzten Jahren hergestellte tun es. Eventuell ist ein Firmware-Upgrade über AVR-Studio nötig.

Laut [http://support.atmel.no/knowledgebase/avrstudiohelp/mergedProjects/JTAGICEmkII/mkII/Html/Connecting_to_target_through_the_PDI_interface.htm] und der eingebauten Hilfe von [[AVR Studio]] 4.18 SP 1 verwendet ein JTAGICE MkII im PDI-Modus folgende Pinbelegung:

1 2 GND
3 4 VTref
5 6 CLK
7 8
'''DATA 9''' 10 GND

Man beachte, dass DATA hier angeblich auf Pin 9 liegt. (VTref dürfte VCC entsprechen). In der Hilfe zu AVR Studio 4.18 SP 1 ist der Pin CLK mit PDI_CLK, und der Pin DATA mit PDI_DATA bezeichnet.

====Atmel AVR Dragon====

Erst mit der Dragon-Firmware im SP 1 für AVR Studio 4.18 soll der PDI-Support des [[AVR Dragon]] funktionieren. Angekündigt war PDI-Support bereits für AVR Studio 4.18.

Leider hat Atmel es versäumt in der Dragon-Dokumentation die Pinbelegung für PDI auf der Seite des Dragon anzugeben. In der Studio-Dokumentation ist von einem ominösen Dragon PDI Adapter die Rede, der Teil des "Dragon Kit" sein soll. Allerdings wird der Dragon 'nackt' ausgeliefert und bisher gibt es keine Berichte darüber, dass jemand diesen ominösen Adapter gesehen hat. Von neueren Versionen des JTAGICE mkII ist hingegen bekannt, dass sie mit einem ''XMEGA PDI adapter kit'' geliefert werden.

Angeblich ist es nötig, beim Dragon jeweils einen 330Ω Widerstand in die CLK und DATA Leitung zu legen, um Probleme mit dem Überschwingen der Signale zu vermeiden.

== Programmer-Varianten ==

Mittlerweile existiert eine fast unüberschaubare Zahl von Programmer-Varianten und Untervarianten. Hier sollen nur die wichtigsten Varianten mit Bauanleitungen aufgelistet werden, geordnet nach der Art des Anschlusses an den PC.

Zur Zeit (März 2012) gibt es vermehrt Probleme, mit den neuen Varianten 5.x des AVR Studios, kompatible Programmer, die nicht von Atmel selbst hergestellt wurden, anzusteuern. Es sollte beim Erwerb/Nachbau auf die Zusicherung der Komptibilität zum gewünschen AVR Studio geachtet werden.

=== Parallelport ===

==== STK200-kompatibel ====

Fast alle erhältlichen Parallelport-Programmieradapter, u.a. auch der hier im [http://shop.mikrocontroller.net/ Shop] angebotene, sind kompatibel zum Programmer des [[STK200]] / STK300.

* [http://www.mikrocontroller.net/articles/STK200 Schaltbilder für STK200 und kompatible]
* Bauanleitung für einen [http://rumil.de/hardware/avrisp.html STK200-kompatiblen Programmieradapter] von Rolf Milde
* Universelles Programmiergerät mit 74HC244 und Schutzwiderständen http://www.aplomb.nl/TechStuff/PPPD/PPPD%20English.html

==== Paralleles Interface für AVR und PonyProg ====

Schaltplan und Erläuterungen bei [http://s-huehn.de/elektronik/avr-prog/avr-prog-alt.htm Scott-Falk Hühn]

==== SP12 Programmer ====

Schaltplan, Erläuterungen und Software für mehrere Plattformen, darunter auch MSDOS, gibt es bei [http://www.xs4all.nl/~sbolt/e-spider_prog.html#programmer Steven Bolt]. [http://www.xs4all.nl/~sbolt/e-spider_prog.html#programmer Ken's Dongle] ist ein spezieller Kabeladapter für SP12 zur Verbesserung der Signalqualität. Anpassung an neue Typen erfolgt durch leicht selbst erstellbare Beschreibungsdateien.

=== Serieller Port ([[RS-232]]) ===

==== Atmel AVRISP, STK500, AVR910 ====

Der original AVRISP von Atmel, das [[STK500]] und der Programmer aus der Application Note AVR910 enthalten einen Mikrocontroller, der die Umsetzung der seriellen Daten auf das ISP- und TPI-Programmierinterface vornimmt. Sie lassen sich direkt mit dem AVR-Studio programmieren und sind auch problemlos mit einem USB-seriell-Adapter verwendbar.

Ein Layout mit Schaltplan und erweitertem Sourcecode findet sich in diesem Thread in der Codesammlung [http://www.mikrocontroller.net/topic/88295#749553 AVR910 Programmer, Schaltplan, Layout, Firmware].

Das AVR910 Design ist u.a. auf der Seite von [http://www.serasidis.gr/circuits/avr_isp/avr_isp.htm Serasidis Vasilis] im Detail beschrieben.

Eine weitere, auführliche Anleitung zum AVR910 gibt es in deutsch auf der Seite von [http://www.klaus-leidinger.de/mp/Mikrocontroller/AVR-Prog/AVR-Programmer.html Klaus Leidinger].
* [https://www.ssl-id.de/b-redemann.de AVR910-USB-Prog: Bausatz incl. USB-seriell Wandler]
* [http://www.avr-projekte.de/isp.htm AVR910-USB: Bauanleitung incl. USB-seriell Wandler]

Einen AVR-ISP STK500 Protokoll Programmmer und JTAGICE kompatiblen Programmer/Debugger können Sie auf folgender Homepage bestellen: [http://www.myevertool.de myevertool]

==== SI-Prog ====

Daneben gibt es noch weitere Programmieradapter für den seriellen Port, die auf den eigenen Mikrocontroller im Programmieradapter verzichten und das ISP-Programmierprotokoll über die Steuerleitungen des RS-232-Port nachbilden. Das Programmierprogramm auf dem PC sendet jetzt keine Steuerkommandos und Daten mehr, sondern gibt direkt die Programmiersignale an der seriellen Schnittstelle aus ("Pinwackeln an den Statuspins"). Der Nachteil dieser Adapter ist, dass sie meistens relativ langsam sind und nur unter wenigen Betriebssystemen funktionieren. Ein Beispiel dafür ist SI-Prog.

* [http://www.lancos.com/siprogsch.html SI-Prog Originalversion]
* [http://s-huehn.de/elektronik/avr-prog/avr-prog.htm Schaltplan und Erläuterungen]

==== Sercon2 ====

Mit einer etwas anderen Steckerbelegung als der SI-Prog arbeitet die Sercon Familie an Adaptern. Nähere Unterlagen dazu finden sich
[http://www.speedy-bl.com/adapter.htm hier]

==== Selbstbau-Programmer, basierend auf dem FTDI chip (via avrdude) ====
http://irq5.wordpress.com/2010/07/15/programming-the-attiny10/

=== USB ===

Die meisten USB-Programmieradapter verwenden einen USB-seriell-Wandler und ein STK500/AVRPROG-kompatibles Protokoll und können damit direkt aus dem AVR-Studio programmiert werden.

Eine Quick-and-Dirty Programmierlösung bietet der [[#USB-Hub-ISP]], der außer einem USB-Hub nur Standard-Bauteile voraussetzt.

==== Atmel AVRISP MKII ====

Nachfolger des Atmel AVRISP "MKI". Mit USB-Schnittstelle, leistungsfähigerem Programmiercontroller und erweitertem Hardwareschutz. Programmiersoftware: [[AVR-Studio]] und [[AVRDUDE]]. Herstellerinformation bei [http://www.atmel.com/dyn/products/tools_card.asp?family_id=607&family_name=AVR+8%2DBit+RISC+&tool_id=3808 atmel.com]

Dave Jones hat im EEVblog #158 ein [http://www.eevblog.com/2011/03/25/eevblog-158-avr-isp-mk2-lm317-regulator-tutorial/ Videotutorial] erstellt, wie man beim Atmel AVRISP "MKI" mit dem LM317 Spannungsregler 3.3V oder 5V Versorgungsspannungen für das Targetboard nachrüstet. Im Video schlägt Dave als bessere Lösung die Verwendung eines Low-Drop-Spannungsreglers vor. Dafür eignet sich z.B. der [http://www.mikrocontroller.net/part/LM1117 LM1117]

Weiter unten auf dieser Seite wird auch ein einfacher, kompatibler Nachbau namens [http://www.mikrocontroller.net/articles/AVR_In_System_Programmer#usbprog usbprog] vorgestellt.

==== Atmel AT90USBKEY ====
Mit hilfe des [http://www.fourwalledcubicle.com/AVRISP.php AVRISP-MKII Clone] Projekts aus dem [http://www.fourwalledcubicle.com/LUFA.php LUFA] Paket wird aus dem [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=3879 AT90USBKEY] recht einfach ein Programmer, der mit [[AVR-Studio]] und [[AVRDUDE]] genutzt werden kann.

==== AVRISP mkII Klon mit dem dem Teensy-Board und der Lufa-Bibliothek ====
Mit der [http://www.fourwalledcubicle.com/LUFA.php LUFA-Bibliothek] und dem [http://www.pjrc.com/teensy TEENSY 2.0 Board] kann schnell ein AVRISP mk2 Klon gebaut werden, der auch mit [[AVR-Studio]] in Windows einwandfrei zusammenarbeitet. Weitere Infos auf [http://www.weigu.lu/b/avrispmk2 weigu.lu].

==== AVRISP mkII Klon mit dem Atmega32U2-Breakout-Board und der Lufa-Bibliothek ====
Mit der [http://www.fourwalledcubicle.com/LUFA.php LUFA-Bibliothek] ([http://dokuwiki.ehajo.de/artikel:atmega_u-howto:avrisp-mkii Eine Anleitung gibt es hier]) und dem [http://www.ehajo.de/Bausaetze/Atmega32u2-Breakout-Board Atmega32U2-Breakout-Board] kann problemlos ein AVRISP mkII-Klon programmiert werden. Um praktisch auf die Programmierpins zugreifen zu können gibt es [http://www.ehajo.de/Bausaetze/ISP-Addon-Atmega%2AU2-Breakout dieses Addon-Board] für das Breakout-Board. Der Programmer läuft problemlos mit [[AVR-Studio]] unter Windows.

==== Bascom USB ISP ====
Beliebter USB programmer der speziell für den Bascom Compiler entwickelt wurde.
Unterstützt Bascom einen neuen AVR-Controller, so kann dies automatisch auch dieser USB Programmer, eine neue Firmware ist nicht erforderlich. Ein weiterer Vorteil ist, dass er speziell für Bascom entwickelt wurde und in der IDE unterstützt wird. Er unterstützt alle Features von Bascom, auch die automatische Fusebit-Einstellung per Direktive im Quellcode.

Angenehm ist auch, dass er keine 5V benötigt. Im Gegenteil, er kann sogar Boards über das übliche ISP-Programmierkabel mit 5V versorgen, so dass viele Boards auch ohne weitere Spannungsquelle programmiert werden können.
Ein wirklich empfehlenswerter Qualitätsprogrammer für alle Programmierer, die ausschließlich mit Bascom arbeiten wollen
* [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=73&products_id=161 Vertrieb in Deutschland bei robotikhardware.de]

Im Online- / Auktionshandel werden auch Alternativen angeboten, teils recht schick im Plexiglasgehäuse für ca. 20 Euro. Angeboten z. B. als "USB 2.0 Full Speed low cost Programmer für ATMEGA Chips" oder "AVR USB ISP Programmer ATMEL ATMEGA STK500". Die Adapter funktionieren auch mit BasCom (aber auch mit AVR Studio), z. B. mit der Einstellung "STK500 native driver".

Man kann die Targetspannungsversorgung per USB zwischen 3,3 und 5V umschalten oder ganz abschalten (per DIP-Schalter). Sie sind per USB an den PC angeschlossen und arbeiten über einen virtuellen COM-Port. Achtung: In BasCom funktioniert das nur bis COM9. Wenn sich das Gerät z. B. auf COM15 installiert, wird es im BasCom evtl. nicht gefunden. Dann in der Systemsteuerung entsprechend umstellen.

==== Atmel AVR Dragon ====

''Hauptartikel [[AVR-Dragon]]''

Der [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=3891 AVR Dragon] ist ein preiswerter ISP (und ICE) von Atmel, der aufgrund Preis/Leistungs-Verhältnisses schnell populär wurde. Atmel wurde von dieser Popularität überrascht, da der Dragon wohl ursprünglich nur als ein "Gimmick" zur Verbreitung von AVRs in Asien gedacht war.

Die großen Vorteile des Dragons sind, dass er alle Programmiermodi beherrscht, inklusive High-Voltage Parallel Programming ("verfuste" AVRs retten), dass er ein natives USB-Interface hat, von AVR-Studio unterstützt wird, und sogar [[JTAG]] und [[debugWIRE]] ICE / Debugging unterstützt (bei den AVRs die dies können).

Zu den größten bekannten Nachteilen gehören, dass der Dragon völlig "nackt" kommt. Kein USB-Kabel, kein Gehäuse, nicht einmal Abstandsbolzen unter der Platine, keine Patchkabel und nicht einmal die Fassungen zum Einstecken von AVRs sind bestückt. Eine gedruckte Anleitung gibt es auch nicht. Daneben wird aufgrund des Stromverbrauchs des Dragon ein USB-Hub mit Netzteil benötigt.

Weiter ist der Dragon dafür bekannt, empfindlich auf statische Aufladungen zu reagieren. Ein Spannungsregler und ein Ausgangstreiber gehen dabei besonders gerne kaputt. Ein gerne von Anfängern gemachter Fehler ist es, den Dragon im Betrieb auf dem mitgelieferten "Schaumstoff" aus der Verpackung liegen zu lassen. Das ist jedoch kein Schaumstoff, sondern leitendes Moosgummi.

Weitere Schutzmaßnahmen für gefährdete AVR Dragons findet man auf der Dragonlair-Seite von [http://www.aplomb.nl/TechStuff/Dragon/Dragon.html Nard Awater].

Der Dragon wird unter Linux z. B. von der avrdude-Programmiersoftware unterstützt. Unerklärlicherweise stellt Atmel die Dokumentation und Beschreibung des Dragon nur als Teil der Online-Hilfe der AVR-Studio Software unter Windows zur Verfügung. Weiterhin lassen sich Firmware-Updates auch nur mittels eine proprietären Atmel-Software unter Windows einspielen. Daher ist der Dragon für Linux-Benutzer nur dann zu empfehlen, wenn man zusätzlich noch Zugriff auf eine Windows-Installation hat.

==== USBisp ====

AVR Programmierdongle mit USB Anschluss und kompatibel zum STK500-Protokoll. Unter anderem programmierbar mit [[AVR-Studio]], [[AVRDUDE]] und [[uisp]]. Schaltplan (PDF), Layout (PDF), Erläuterungen und Firmware gibt es vom Entwickler [http://www.matwei.de Matthias Weißer].

==== USB avrisp ====

USB AVR Programmer auf Basis des AVR 910 Designs. Den Schaltplan, Layout und Erläuterungen (englisch) gibt es von [http://www.e.kth.se/~joakimar/hardware.html Joakim Arfvidsson].

==== Evertool ====

Mit USB-seriell-Wandler. Getestet mit Adapterkabeln/ICs von FTDI, SiLabs und Prolific (Adapterkabel z. B. für ca. 10EUR bei Reichelt).

* [http://www.siwawi.arubi.uni-kl.de/avr_projects/evertool/ Evertool-"Homepage"]

==== USBasp ====

Thomas Fischls [http://www.fischl.de/usbasp/ USBasp] ist ein
Openhardware-/Openfirmware-USB-ISP-Adapter. Er basiert auf einem
ATmega8, ATmega8L, ATmega88 oder ATtiny85, der mittels einer rein auf Firmware
basierenden USB-Implementierung von
[http://www.obdev.at/products/avrusb/index.html Objective Development]
arbeitet.

Bezugsquellen:
* Ein [http://www.FundF.net/usbasp/ offizieller USBasp Bausatz] ist erhältlich.
* Alternative Bausätze inkl. Dokumentation gibt es bei [http://www.b-redemann.de/produkte-programmer.shtml www.b-redemann.de], [http://shop.ulrichradig.de/Bausaetze/USB-ASP-Bausatz.html shop.ulrichradig.de] und [https://guloshop.de/shop/index.php guloshop.de].
* Eine MacOS X Anpassung stammt von [http://www.macsven.de/usbasp.html Sven Schwiecker]. Man kann aber auch das Komplettpaket Crosspack-AVR, in dem AVRDUDE für Mac OS X bereits enthalten ist, von [http://www.obdev.at/products/crosspack/index-de.html obdev.at] benutzen

Zum Ansteuern des USBasp wird [[AVRDUDE]] in einem speziellen Modus benötigt, der ab Version 5.2 standardmäßig vorhanden ist (vorher waren
Patches nötig).

Zum Programmieren von neuen ATtinys muss der Jumper Slow SCK gesetzt werden.
Alternativ ist es möglich mit der zusätzlichen Option von avrdude "-B100" die Periodendauer von SCK auf etwa 100 µs oder noch länger zu vergrößern (funktioniert nur, wenn die Firmware des USBasp vom Mai 2011 oder neuer ist).

Der originale USBasp hat den Nachteil, dass er nicht die Targetspannung zum Programmieren benutzt, sondern immer seine 5V. Deshalb kann es Probleme geben, wenn das Target mit einer niedrigen Spannung versorgt wird, da der USBasp die Target-Highpegel eventuell nicht mehr als High erkennt. Abhilfe kann ein kleiner Hack schaffen, mit dem der µC wahlweise mit 5V oder mit ~3.6V betrieben wird:
http://www.mikrocontroller.net/topic/109648?goto=2031524#2031524

Der [http://diy.elektroda.eu/usbasp-z-optoizolacja-do-25kv-18v-6v/?lang=en Optoisolated USBASP 1.8V to 6V] ist eine Hardwareänderung ebenfalls mit breitem Targetspannungsbereich und zusätzlich galvanischer Isolation über die [[Optokoppler]] 6N317 (schnelle Datenleitungen) und PC817 (langsame Resetleitung).

Manche USBasp sind umschaltbar zwischen 5 V und 3,3 V. Falls man später darüber eine Schaltung mit 3,3 Volt betreiben will – etwa zum direkten Ansprechen einer SD-Karte – lohnt gezieltes Nachfragen vor dem Kauf.

==== AvrUsb500 ====

* [http://www.tuxgraphics.org/electronics/200510/article05101.shtml AvrUsb500] - an open source Atmel AVR Programmer, stk500 V2 compatible, with USB interface
* [http://www.mechaos.de/avr_progusb.php meCHAOS] - Nachbau mit neuem Platinenlayout und weiteren Funktionen.

==== usbprog ====

[http://www.usbprog.org/ usbprog] von Benedikt Sauter ist ein USB Programmieradapter, der fast alle Atmel-Mikrocontroller unterstützt (ATiny, ATMega, AT89, AT90, ...) und daneben auch für ARM7/9 und MSP universell einsetzbar ist. Unterstützung für Xmega gibt es nicht.

Der Programmer wurde so entwickelt, dass man die Firmware auf dem Adapter über die USB-Verbindung austauschen kann. Dadurch sollte der Adapter lange attraktiv bleiben, da alles rund um das Projekt als open Source veröffentlicht ist und daher neue Controller einfach in die usbprog-Firmware integriert werden können.
Es ensteht gerade eine Firmware für einen einfachen JTAG-Adapter. Damit kann man dann ganz einfach debuggen (voraussichtlich auch aus dem AVR Studio aus).

Man kann den Adapter auch als 1:1 AVRISP-mkII-kompatibles Gerät betreiben. Dafür muss man eine andere Firmware einspielen, die ebenfalls Teil des Projektes ist. Der Vorteil ist der, dass man so auf jede bestehende Programmiersoftware zurückgreifen kann, die das originale AVRISP mkII unterstützt. Getestet wurde usbprog bis jetzt mit avrdude (Linux und Windows) und dem AVR Studio 4 (Windows).

'''Hinweis:''' Damit der Programmer mit AVR Studio 5.x zusammen arbeitet, muss die Firmware aktualisiert werden: http://www.usbprog.org/index.php/Firmwares (siehe Update-Hinweis)

Derzeit kann man bei der embedded projects GmbH die Versionen 3.3 und 4.0 bestellen. Näheres im [http://www.usbprog.org/index.php/Hardware Projekt-Wiki].

==== AVR-Doper ====

[http://www.obdev.at/products/avrusb/avrdoper.html AVR-Doper] kann neben ISP auch im High-Voltage Serial Mode als [[AVR HV-Programmer]] programmieren. Rein auf Firmware basierende USB-Implementierung. BUS-Powered. Einseitige Platine und damit auch für Selbstbauer geeignet. Verwendet einen Mega8 zur Steuerung des Programmers. Ist kompatibel zu AVR-Studio durch STK500-Protokoll.

==== USB AVR-Lab ====

[http://www.ullihome.de/index.php/Hauptseite#USB_AVR-Lab USB AVR-Lab] besteht aus einer sehr einfachen Hardware, usb wird in Software gemacht. Mit einem Bootloader nebst Applikation kann die Funktion des Lab´s zwischen

*AVRISPmkII kompatiblem Programmer (AVR Studio, Linux, MacOS)
*JTAGICEmkII kompatibler AVR Programmer (AVR Studio, Linux, MacOS) (keine AVR32, kein Xmega)
*OpenOCD Interface (sehr viel ARM Controller, PLD´s, FPGA´s)
*STK500v2 kompatiblem Programmer (AVR Studio)
*USBasp kompatiblem Programmer (Linux, MacOS)
*JTAG Boundary Scan Interface + Software
*RS232/RS485 Wandler
*I2C Logger
*I2C Interface (zur benutzung aus eigenen Programmen)
*Oszi
*6-Kanal Logik Analyzer (in Entwicklung)
*Labornetzteil (in Entwicklung)

getauscht werden. Mit der STK500v2 kompatiblen Firmware kann der Programmer direkt aus dem AVR Studio heraus voll kompatibel zum AVR-ISP mkII arbeiten.
Zusätzlich bietet der Programmer den virtuellen Com Port als Debug Port an solange nicht geflasht wird. Man kann also direkt mit dem Terminalprogramm auf seinen AVR zugreifen über den ISP Adapter.
Dieser Modus wird von jeder ISP Firmware unterstützt.
Statusanzeige des Targets (angeschlossen, falsch angeschlossen, nicht angeschlossen), max. 3 Mhz ISP Freq. Das Ganze ist sehr günstig in der Beschaffung (10 Eur Bauteile bei Reichelt + 3,5 Eur Platine von ullihome.de, oder 15 Eur bestückt von ullihome.de)

==== USBtinyISP ====

[http://www.ladyada.net/make/usbtinyisp/ USBtinyISP] ist ein preiswerter (ca. 16$ für die Bauteile) AVR ISP Programmer und SPI Interface auf open-source Basis. Als Software kann z.B. AVRDUDE oder AVRStudio verwendet werden. Der Programmer wurde auf Windows, MacOS X und Ubuntu (ab 9.04) getestet. Bei Adafruit sind auch Selbstbaukits erhältlich.
Eine miniaturisierte Version findet sich hier [http://www.mikrocontroller.net/articles/AVR-ISP-Stick www.mikrocontroller.net/articles/AVR-ISP-Stick]. Diese ist ab 6,90€ als Bausatz bei [http://www.ehajo.de/Bausaetze/AVR-ISP-Stick eHaJo.de] erhältlich.

==== UCOM-IR ====
Der [http://www.nibo-roboter.de/wiki/UCOM-IR UCOM-IR] Programmieradapter ist ein kommerzieller Bausatz (ca. 25 €), der auf einem AT90USB162 basiert. Durch die Verwendung des STK500v2 Protokolls kann zur Programmierung sowohl das [[AVR-Studio]] wie auch [[AVRDUDE]] verwendet werden. Zusätzlich hat der Adapter einen IR-Empfänger und zwei Sendedioden, die zur Kommunikation und zur Fernsteuerung verwendet werden können.

==== Selbstbau-Programmer, basierend auf dem vUSB stack ====
http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=90498

==== USB-Hub-ISP ====
HUB ISP - Solving the USB-Only "Chicken or Egg" Problem: 
HUB ISP can write an AVR chip using only a USB hub, one cheap/common logic chip, and a few resistors. 
http://www.pjrc.com/hub_isp/

==== Launchprog ====
Der [[Launchprog]] ist ein AVR-ISP-Programmer nach der Atmel AVR910-Appnote, der auf einem [http://processors.wiki.ti.com/index.php?title=MSP430_LaunchPad_%28MSP-EXP430G2%29 TI Launchpad 1.4] mit dem beiliegenden [http://www.ti.com/product/msp430g2211 MSP430G2211] und dem beiliegenden Uhrenquarz läuft. Nach außen hin ist der [[Launchprog]] wie ein AVR910 zu verwenden. Allerdings muss die Geschwindigkeit der seriellen Schnittstelle auf 9600 Baud eingestelllt werden. 
Beispiel der avrdude-Kommandozeile: 
''avrdude -c avr910 -b 9600 -P <PORT> -p <PART> -U <KOMMANDO>''

==== mySmartUSB ====
Der mySmartUSB Programmer von myAVR ist ein kompakter ISP Programmer mit USB Anschluss (der Preis liegt bei 28€). Lt. Hersteller kann er auch für die Kommunikation via UART, TWI, SPI verwendet werden (hab ich noch nicht probiert).

ich aber: Beim Schreiben der Fuse Bits musste ich das Tool myAVR_ProgTool.exe verwenden

Mit avrdude ist das Schreiben der Fuse-Bits mit dem AVR910-Modus möglich.

avrdude-Kommandozeile :
''avrdude -c avr910 -P PORT -p PART -U lfuse:w:0xFF:m -U hfuse:w:0xD9:m''

'''Achtung:''' Die neuere Version (mySmartUSB MK3) scheint mit der aktuellen Firmwareversion noch große Probleme mit ISP zu haben (siehe Postings im Supportforum: http://myavr.info/myForum/viewforum.php?f=8). Solange diese Probleme nicht ausgemerzt sind, sollte man auf die ältere Version (mySmartUSB MK2) oder ein anderes Produkt ausweichen.

==== mySmartUSB light ====

Preiswerter (ca. 15 €) Programmer im USB-Stick Design von myAVR. Der mySmartUSB light verfügt über eine Auto-Speed Funktion die die Frequenz des Programmers automatisch an die Taktfrequenz des Controllers anpasst.
Der Programmer kann 5V und 3.3V Systeme programmieren, Treiber gibt es für Windows, Linux und MacOS X und unterstützt wird je nach Firmware-Version das STK500v2 oder AVR910/911 Protokoll.

==== Amadeus-USB ====

[http://home.arcor.de/bernhard.michelis Amadeus-USB] ist ein ISP-Programmer zum Selberbauen. Er unterstützt eine Vielzahl von AVRs und verfügt über ein eigenes User-Interface. Der Programmer enthält einen einfach zu bedienenden Fuse-Editor. Sollte man einmal die falschen Clock-Einstellungen vorgenommen haben, ist das kein Problem, da der Programmer über eine Takterzeugung verfügt, mit der man den AVR wiederbeleben kann.
Auch wer mit niedrigen Taktraten arbeitet (z. B. 32kHz), kann einen ATmega64 in ca. 4,8 Sekunden programmieren und vergleichen. Darüber hinaus kann mit geeigneten Makros die Programmausführung getracet werden. Die maximale Programmierdauer beträgt bei einem ATmega64 mit 16MHz Quarz 3,1 Sekunden, wenn der gesamte Speicher geschrieben und verglichen werden muss. Ist das Programm kleiner, geht es natürlich schneller ;-) Für einen ATTiny2313 oder ATTiny24 braucht er weniger als eine Sekunde.

==== AVR-ISP-Stick ====

Der [http://www.ehajo.de/Bausaetze/AVR-ISP-Stick AVR-ISP-Stick] ist ein OpenSource/CC-Projekt und eine sehr günstige (6,90€!) Alternative zu den restlichen Programmieradaptern auf dem Markt. Er ist als Bausatz erhältlich und bereits über 100 mal im produktiven Einsatz.

==== µISP-Stick ====

Der [http://www.ehajo.de/Bausaetze/µISP-Stick µISP-Stick] ist die Weiterentwicklung des AVR-ISP-Sticks. Für 9,90€ bekommt man hier einen vorbestückten Bausatz an dem nur noch die bedrahteten Stecker angelötet werden müssen.

==== Arduino ISP Shield ====

Ein Arduino-Board kann mit dem entsprechenden Sketch und einfachen Jumperwires oder einem komfortablen Shield benutzt werden, um AVRs ohne [[Bootloader]] zu flashen. Eine Anleitung dazu wird bei [http://www.open-electronics.org/arduino-isp-in-system-programming-and-stand-alone-circuits/ www.open-electronics.org] und [http://hlt.media.mit.edu/?p=1229 hlt.media.mit.edu] (via [http://www.mikrocontroller.net/topic/252620#2598960]) gegeben.

==== aTeVaL-Board ====

Das [http://www.ehajo.de/Bausaetze/aTeVaL aTeVaL-Board] ist die Weiterentwicklung des Atmel Evalboards von Pollin. Damit lassen sich problemlos alle bedrahteten AVR-Controller programmieren. Der Programmer ist ein AVR-ISP-mkii-Clon und somit 100% kompatibel mit dem Atmelstudio. Für eigene Platinen ist ein 6- und 10-poliger ISP-Stecker vorhanden.

==== USP-Stick ====

Der [http://www.ehajo.de/Bausaetze/USP-Stick USP-Stick] ist ein sehr kleiner Programmieradapter, der in ein USB-A-Gehäuse passt. Er beruht auf der bewährten Hardware des AVR-ISP-Sticks (attiny2313 + quarz) und ist für 4,90€ erhältlich.

==== guloprog USB-Programmer und Signalwandler ====

Unter dem Namen [https://guloshop.de/shop/Mikrocontroller-Programmierung/guloprog-der-Programmer-von-guloshop-de::70.html guloprog] wird eine kleine Platine angeboten, die einen USB-Programmer und einen [https://guloshop.de/shop/USB-TTL-ADC-PWM-Signalwandler:::10.html Signalwandler] vereint. Der Programmer wird per USB angeschlossen und meldet sich als Fischl-kompatibler usbasp.

Die Signalwandlerfunktion bietet voneinander unabhängige einfache Schalt- und Abfragemöglichkeiten für die vier sonst zum Programmieren verwendeten Anschlüsse. Jede Leitung kann per Tastatur-Kommando einen Ausgang auf 0 Volt oder auf 5 Volt setzen oder "dimmen" (PWM in Schritten von 0 bis 100%). Alle Anschlüsse können als Digital-Eingang verwendet werden, drei davon wahlweise als Analog-Eingang. Die gemessenen Werte lassen sich ebenfalls per Kommandozeile abfragen und auf diese Weise leicht in andere PC-Programme einbinden (Linux, Mac, Windows).

Herzstück ist ein ATtiny85, der im Gegensatz zu allen ATmegas und fast allen ATtinys auch über den internen RC-Oszillator mit 16 MHz betrieben werden kann. Ein Quarz ist daher nicht erforderlich. Die für V-USB erforderliche Genauigkeit erreicht der Programmer über einen Synchronisationsschritt, der bei jedem Start automatischen durchlaufen wird. Die Firmware steht unter einer freien Lizenz, es werden nur sehr wenige Bauteile benötigt, so dass sich dieser Programmer auch recht gut für den Nachbau eignet. Schaltungs- und softwaretechnisch besteht praktisch Baugleichheit zum [[Bierdeckel-Programmer]].

=== Standalone ===

Die folgenden Geräte verfügen über interne Speicher, auf denen der zu programmierende Maschinencode abgelegt werden kann. Zum "flashen" selbst ist keine Verbindung zwischen Arbeitsplatzrechner bzw. Notebook und Programmiergerät erforderlich.

==== roloFlash (kommerziell) ====
[http://www.halec.de/roloFlash/?ref=wiki_isp.mikrocontroller.net roloFlash] wird mit einer microSD-Karte bestückt, die die zu flashenden Daten enthält. Dadurch können unabhängig von einem PC an jedem beliebigen Ort AVR-Controller geflasht werden.

In einem ersten Schritt wird die microSD-Karte vorbereitet. Durch die auf dem roloFlash eingebaute Scriptsprache roloBasic lässt sich der gewünschte Ablauf sehr flexibel festlegen.

Nun kann roloFlash irgendwo anders ohne PC AVR-Controller flashen. Dabei geben 5 zweifarbigen LEDs Auskunft über den Fortschritt bzw. das Ergebnis des Flash-Prozesses. Fehlbedienungen sind unmöglich, da es keine Bedienelemente gibt.

Einsatzgebiete:
* Produktion
* Fehlbedienungssichere Updates beim Kunden

==== TheCableAVR-SD (kommerziell) ====
[http://www.priio.com/productcart/pc/viewPrd.asp?idcategory=6&idproduct=88 TheCableAVR-SD] works by saving the "ISP", "HEX" and "EEP" files required for part programming from the PC application onto an SD-Card and inserting it into TheCableAVR-SD. This programmer is stand alone, making it very handy for field software updates and production programming.

Wird 4/2012 scheinbar nicht mehr verkauft ([http://www.mikrocontroller.net/topic/257278#2657606 Forumsbeitrag Priio AVR Programmer?]).

==== ButtLoad ====
[http://www.fourwalledcubicle.com/ButtLoad.php ButtLoad] is based on the Atmel [[AVR Butterfly]] development board. ButtLoad is specially written firmware which converts a low-cost official Atmel Butterfly evaluation board into a smart ISP programmer for other members of the Atmel AVR family. It supports the entire AVR range, and allows for a complete program (including EEP, HEX, Fuse and Lock Bytes) to be stored and later programmed into a device from the Butterfly's on board non-volatile memory.

[http://www.fourwalledcubicle.com/ButtLoad.php ButtLoad] basiert auf dem Atmel-[[AVR Butterfly]]-development board und ist eine spezielle Firmware, die ein (billiges) Atmel-Butterfly-Board in einen vollwertigen ISP-Programmierer für andere Controller der Atmel-AVR-Familie verwandelt. Es unterstützt den gesamten AVR-Bereich und erlaubt, ein Programm komplett mit EEP, HEX, Sicherungs- und Lock-Bytes im nichtflüchtigen on-board-Speicher des Butterflys abzulegen und dann von dort heraus die Controller zu programmieren.

==== PalmAVR ====
* siehe [http://www.mikrocontroller.net/topic/77870#648376 Forenbeitrag]

==== AVR-ISP500, AVR-ISP500 tiny ====
von Olimex, siehe
* [http://www.olimex.com/dev/avr-isp500-iso.html Herstellerseite zum ISP500]
* [http://www.olimex.com/dev/avr-isp500-tiny.html Herstellerseite zum ISP500-TINY]

=== Geschwindigkeitsvergleich ===

Im Rahmen einer Forendiskussion entstand die folgende Messung, die
einige der möglichen Programmer in ihrer Geschwindigkeit vergleicht.
Mit einbezogen in den Vergleich wurde neben originalen
Atmel-ISP-Werkzeugen noch Werkzeuge für [[JTAG#AVR_JTAG|JTAG]].

Die Testdatei war 29704 Bytes groß. Target ist ein ATmega6490, der
mit 8 MHz vom RC-Oszillator getaktet wird. Das alles wurde mit einem
AVRDUDE 5.5 getestet.

<pre>
Programmer Parameter Zeit fürs
Schreiben Lesen
-----------------------------------------------
JTAG ICE mkII default 2,58 s 3,27 s
JTAG (4 MHz)
-----------------------------------------------
JTAG ICE mkII 1 MHz 8,34 s 8,51 s (**)
ISP
-----------------------------------------------
AVRISP mkII 250 kHz 5,37 s 5,46 s
1 MHz 2,45 s 2,45 s
2 MHz 1,89 s 1,99 s
-----------------------------------------------
STK500 900 kHz 5,84 s 3,49 s
(schnellstes)
-----------------------------------------------
AVR Dragon default 2,81 s 3,49 s
JTAG (4 MHz)
-----------------------------------------------
AVR Dragon 1 MHz 8,34 s 8,64 s
ISP 2 MHz - - (*)
-----------------------------------------------
Parallelport- keine Delay 13,20 s 12,45 s (**)
Dongle "alf" CPU 900 MHz
-----------------------------------------------
</pre>

(*) Benutzung unmöglich, weder Fuses noch Signature zuverlässig
lesbar.

(**) Fuses und Signature OK, aber das programmierte Ergebnis ist
fehlerhaft (verify errors)

== Software ==

* [http://www.myplace.nu/avr/yaap/ yaap] (Windows, diverse Parallelport-Programmer, GUI)
* [[Pony-Prog Tutorial|PonyProg]] (Linux, Windows, diverse Programmer für den parallelen und seriellen Port, GUI, am seriellen Port nur "Statuspinwackler" nach dem Schaltplan auf der lancos-Seite)
* [http://www.soft-land.de/index.php?page=avrburner AVRBurner] Ponyprog ähnliche Oberfläche für AVRDUDE.
* [http://www.nongnu.org/avrdude AVRDUDE] (Unix, Linux, Windows, praktisch alle Programmer, leicht erweiterbar auf andere Parallelportadapter-Anschlussbelegungen, Kommandozeile, auch für AVR Butterfly über dessen vorinstallierten Bootloader/Firmware-Uploader) siehe im Wiki [[AVRDUDE]]
* [http://savannah.nongnu.org/projects/uisp uisp] (Unix, Linux, Windows, praktisch alle Programmer, Kommandozeile, nicht mehr gepflegt).
* AVR-Studio (nur Programmieradapter mit integriertem Controller für den seriellen Port, z. B. AVR910, ATMEL AVRISP und STK500)
* [http://www.mcselec.com Eingebauter Programmer im Bascom-Basic Compiler]
* [http://esnips.com/web/AtmelAVR AvrOspII] - GUI Open Source programmer based on Atmels Application note AVR911.
* [http://www.mikrocontroller.net/topic/60817 Forumsbeitrag] - Wie man Ponyprog aus dem AVR-Studio heraus nutzt
* [http://www.cadmaniac.org/projectMain.php?projectName=kontrollerlab Kontrollerlab] - (Linux), Grafische Oberfläche zu avr-gcc, uisp, avrdude und kate mit built-in debugger und serial terminal. Einfach verständlich und aufgeräumt (im KDE-Stil)
* [http://shop.myavr.de/index.php?sp=download.sp.php&suchwort=dl112 myAVRProgTool] - Freies Programmiertool und zusätzlich auch als DUDE-GUI geeignet, einfach zu bedienen
* [http://dybkowski.net/isp ISP Programmer] von Adam Dybkowski (Opensource, Windows 95, 98, Me, NT 4.0, 2000, XP, 2003, Vista and Windows 7 (32-bit and 64-bit versions))

== ISP-Pins am AVR auch für andere Zwecke nutzen ==

Bei einem Programmer mit eingebautem [[Ausgangsstufen_Logik-ICs#Tristate|Tristate]]-Treiber (z. B. 74HC(T)244) werden die Leitungen MISO, MOSI und SCK hochohmig geschaltet wenn die Programmierung beendet ist, d.h. sie beeinflussen die Schaltung nicht. Man kann die betreffenden Pins am AVR also relativ problemlos als Ausgänge verwenden, wenn man darauf achtet, dass die daran angeschlossene Peripherie durch die Programmierimpulse keinen Schaden nehmen kann. Als Eingänge sollte man die Pins allerdings nicht verwenden, da ein angeschlossener Taster zum Beispiel die Programmierimpulse kurzschließen würde, wenn er gedrückt ist.

Atmel empfiehlt in der Application Note [http://www.atmel.com/dyn/resources/prod_documents/doc2521.pdf AVR042: AVR Hardware Design Considerations (PDF)] Peripherie an der SPI-Schnittstelle, bei gleichzeitiger Verwendung der Schnittstelle als In-System-Programmieranschluss, über Widerstände anzuschliessen.

Ein Widerstand in SCK ist in diesem Zusammenhang aber nur dann sinnvoll, wenn am AVR ein externer SPI-Master hängt, denn nur dann kann ein Konflikt zwischen diesem SCK treibenden Master und dem ebenfalls SCK treibenden ISP auftreten. Ist der AVR hingegen wie üblich selbst der Master, dann ist ein Konflikt ausgeschlossen. Das gleiche gilt für MOSI.

Bei MISO kann ein Konflikt nur auftreten, wenn diese Leitung vom Slave in der ISP-Phase aktiv treibend sein kann. Das ist beispielsweise bei Porterweiterungen (Inputs) mit Schieberegistern der Fall, wenn der
Datenausgang des Schieberegisters nicht passivierbar ist (tristate, Z-state). Dann ist ein Serienwiderstand in MISO sinnvoll.

Normale SPI-Slaves mit CS-Leitung, wie ADCs, passivieren jedoch ihren Datenausgang wenn CS inaktiv ist. In diesem Fall ist ein Serienwiderstand in MISO unnötig, es muss nur über schwache Pullup-Widerstände an allen relevanten CS Leitungen sichergestellt sein, dass sie während Reset hochgezogen werden. Manche SPI-Slaves haben die bereits an Bord. Die internen Pullups im AVR sind keine Hilfe, da sie während Reset abgeschaltet sind.

siehe auch [http://www.mikrocontroller.net/articles/AVR_HV-Programmer AVR HV-Programmer]

[[Kategorie:AVR-Programmer und -Bootloader| ]]

Bierdeckel-Programmer

2013-08-26T14:57:52Z

M-w: MISO-Widerstand darf entfallen.

[[Bild:bierdeckel_programmer.jpg|right|thumb|306px|Bierdeckel-Programmer]]

Nein, es werden hier keine Bierdeckel programmiert, sondern gezeigt, dass AVR-Programmer für die USB-Schnittstelle so einfach sind, dass man sie mit Hilfe weniger Teile auch auf einem Bierdeckel aufbauen kann.

Ursprünglich war der Schaltplan auf einem Bierdeckel nur als Werbegag gedacht, aber es lässt sich tatsächlich auf diese Art ein Programmer bauen: Die aufgedruckten kleinen Kreise werden jeweils mit einer Pinnwand-Nadel durchstochen. Auf die so entstandene "Platine" setzt man die Bauteile des Programmers. Verlötet werden sie auf der Unterseite. Dabei stehen die durchgezogenen Linien für Anschlussdrähte, die auf der Oberseite sichtbar sind, und die gestrichelten Linien für Drähte, die auf der Unterseite verlaufen.

; Stückliste
* 1 Mikrocontroller ATtiny85, evtl. mit Fassung
* 1 USB-Anschlussleitung oder eine USB-B-Buchse
* 2 Zener-Dioden (3,6 V)
* 7 Widerstände (2 x 100, 4 x 470, 1 x 2200 Ohm)

; Verdrahtungsplan
[[Bild:bierdeckel_verdrahtung.png|Verdrahtungsplan des Bierdeckel-Programmers]]

Tipp: Falls der Programmer trotz korrektem Aufbau nicht zuverlässig läuft (Abbrüche etc.), empfiehlt es sich, zur Glättung der Versorgungsspannung einen Kondensator von 100 nF zwischen die Anschlüsse VCC (Pin 8) und GND (Pin 4) des ATtiny85 zu löten. Auf der Bierdeckel-Unterseite ist dafür genügend Platz. Wer will, kann den 470-Ohm-Widerstand am MISO-Anschluss weglassen und stattdessen eine Drahtbrücke einlöten. Auf die übrigen 470-Ohm-Widerstände sollte jedoch nicht verzichtet werden, sie schützen den Programmer bei falscher Verdrahtung.

== Software ==

Da es sich beim Bierdeckel-Programmer um eine Weiterentwicklung des Standard-USBasp von Thomas Fischl handelt, kann man als Software [[avrdude]] verwenden. Damit lässt sich der Programmer auch unter AVR Studio einbinden.

== Firmware ==

Für den Aufbau wird ein Mikrocontroller des Typs ATtiny85 im DIP-Gehäuse benötigt. Diesen kann man selbst mit der Firmware versehen, sie ist quelloffen und zum Beispiel [http://guloshop.de/f/sources/ ''hier''] downloadbar. Oder man besorgt sich den Mikrocontroller in der bereits programmierten Variante.

[[Kategorie:AVR-Programmer und -Bootloader]]

AVR Typen

2013-07-26T20:42:36Z

M-w: /* ATtiny - Reihe */ Tabellensortierung

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 bzw. ATmega8A statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man eine andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny4313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz].

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny und die Mega. Die ATTiny haben kleinere Gehäuse als die ATMega, mit weniger Pins. Dies führt bei ähnlicher Funktionalität wie die Megas zu extremen Mehrfachbelegungen der Pins und auch eher zu Überschneidungen der Pinfunktionalität. Die Tiny sind daher eher für sehr hohe Stückzahlen geeignet, wo die Einsparung über die Stückzahl kommt. Anfänger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in Kibibyte an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/Images/doc8127.pdf ATtiny10]
|1
| --
|32
|4
|12
|1.8-5.5
|4 8-bit
|Ja
|1
| --
|Nein
|Ja
|2
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|SOT23
| 0.83-0.99
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.60-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/Images/Atmel-2586-AVR-8-bit-Microcontroller-ATtiny25-ATtiny45-ATtiny85_Datasheet.pdf ATtiny45]
|4
|256
|256
|6
|20
|2.7-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|2
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.90-2.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.90-2.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.00-2.00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|2.7-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1.45
|-
|[http://www.atmel.com/Images/doc8183.pdf ATtiny84A]
|8
|512
|512
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1,00-4,00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8] [http://www.atmel.com/Images/Atmel-8159-8-bit-AVR-microcontroller-ATmega8A_datasheet.pdf ATmega8A]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.50-4.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega48A]
|4
|256
|512
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega88A]
|8
|512
|1K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8011.pdf ATmega164]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|PDIP40 TQFP44 QFN/MLF44
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8271.pdf ATmega168A]
|16
|512
|1K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-

|[http://www.atmel.com/Images/doc8271.pdf ATmega328]
|32
|1K
|2K
|23
|20
|1.8-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/Images/doc8272.pdf ATmega324A]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2
|Ja
|PDIP40 TQFP44 VQFN44 QFN/MLF44 DRQFN44 VFBGA49
| 3.50-4.50
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|5.00-7.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8.00-15.00
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

Hinweis: Die angegebenen Preise sind Richtwerte. Es empfiehlt sich die Verwendung einer Preissuchmaschine, z.B. [http://www.google.de/shopping google.de/shopping].

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==
Vergleichstabellen zum Downloaden gibt es unter Anderem
* [http://www.mikrocontroller.net/topic/242328 von Andreas], Stand 19.12.2011; vollständig,
* [http://www.mikrocontroller.net/topic/232939 von Sven], Stand 22.09.2011; weiter eingedampft.

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Anzahl Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Kategorie:AVR]]
[[Kategorie:Liste mit Bauteilen]]

Entscheidung Mikrocontroller

2013-07-26T20:35:59Z

M-w: /* Programmiersprachen */ http://store.kagi.com/cgi-bin/store.cgi?storeID=6FFKK_LIVE&&

Die meisten Anfänger stellen sich die Frage, welchen [[Mikrocontroller]] sie verwenden sollen. Es gibt Dutzende Hersteller, und jeder davon hat unzählige Varianten im Angebot. Stellt man die Frage in einem Diskussionsforum, dann bekommt man viele verschiedene (sich teilweise widersprechende) Antworten. Bei der Entscheidung sollten u.a. die unten stehenden Kriterien beachtet werden. Dieser Artikel ist primär für Hobbyisten gedacht, da im professionellen Einsatz oftmals völlig andere Kriterien beachtet werden müssen. Weitere vergleichende Informationen über verschiedene Controllerfamilien gibt der Artikel: [[Mikrocontroller_Vergleich]]

== Verfügbarkeit ==
* Während man manche Mikrocontroller an jeder Straßenecke bekommt, sind andere nur in großen Stückzahlen und mit Gewerbenachweis erhältlich. Dazu einfach mal in die Kataloge der einschlägigen Privatkundenhändler schauen. Dabei auch darauf achten, dass der gewünschte Controller auch in der richtigen Bauform erhältlich ist (DIP, TQFP, MLF usw.), s.u.
* Ab und zu kündigen Hersteller ein neues Modell an (und veröffentlichen das Datenblatt dazu), können aber erst ein Jahr später nennenswerte Stückzahlen liefern. Also den Controller nicht einfach anhand der Übersichten beim Hersteller aussuchen, sondern überprüfen, was die Händler auch wirklich liefern können.
* Lebenszyklus: Kein Modell wird ewig hergestellt. Deswegen sollte man überprüfen, ob der Hersteller vielleicht schon angekündigt hat, dass er ein bestimmtes Modell nicht mehr herstellen will. Die Hersteller schreiben dann z. B. "Mature Product (Not Recommended for New Designs)". Für Neuentwicklungen oder den Einstieg sollte man folgende Modelle nicht verwenden:
** AVR AT90-Reihe,
** AVR ATMega 103(L), 161(L), 163(L), 323(L).
* Für alle abgekündigten AVR-Controller gibt es jedoch pin- und funktionskompatible Nachfolger. Daher kommt es nur in den seltensten Fällen zu Problemen. Probleme können nur entstehen, wenn ein Programm nur in kompilierter Version zur Verfügung steht.
* Dagegen sind Mikrocontroller der [[8051|MCS51-Familie]] von Intel eher für langfristige Investitionen geeignet. Der 8051 wurde 1979 (!) als erstes Mitglied dieser Familie vorgestellt. Heute gibt es bereits hunderte von 8051-Derivaten von dutzenden von Halbleiterherstellern, zum Teil auch mit weiterentwickelten Prozessorkernen. Wird ein Derivat tatsächlich mal abgekündigt, findet man bei dieser Riesenauswahl meist leicht adäquaten Ersatz.

== Preis ==
Einerseits kann es lästig sein, wenn man durch die Verwendung eines kleineren Modells 2 Euro gespart hat und dann mit dessen Unzulänglichkeiten kämpft, andererseits ist ein versehentlich zerstörter Chip für 30 Euro ziemlich ärgerlich. Auch ist es oft ganz praktisch, wenn man einige Controller auf Vorrat hat.

Zum Preis eines einzelnen Mikrocontrollers kommen noch die Kosten für die Entwicklungswerkzeuge, wie [[Compiler]], Programmübertragung und Debugging hinzu (s.u. Programmiersprache und Programmübertragung).

== Dokumentation ==
Die wichtigste Informationsquelle zu einem Mikrocontroller ist das Datenblatt. Diese gibt es heutzutage aber fast ausschließlich in Englisch. Wer damit nicht zurecht kommt, muss vorher schauen, ob es irgendwelche Tutorials oder Bücher in seiner Lieblingssprache gibt.

Je mehr Funktionen ein Mikrocontroller beherrscht, desto umfangreicher wird auch das Datenblatt. Das führt dazu, dass bei manchen Mikrocontrollern das Datenblatt über 1000 Seiten hat. Da ist die Gefahr groß, dass ein Anfänger den Überblick verliert.

== Unterstützung/Community ==
Gerade als Anfänger ist man oft auf die Hilfe anderer angewiesen. Da empfiehlt es sich, der Masse hinterherzulaufen und keine exotischen Typen zu verwenden. Im Bastlerbereich populäre Mikrocontroller-Familien sind die AVRs von Atmel und die PICs von Microchip. Für diese Architekturen gibt es z. B. im Forum dieser Internet-Seite gute und meist auch schnelle Hilfestellung bei Problemen.

== Bauformen ==
Neben den klassischen (bedrahteten) Bauformen setzt sich heutzutage [[SMD]] immer mehr durch. Manche Mikrocontroller sind nur noch in SMD-Bauformen erhältlich. Für SMD benutzt man üblicherweise geätzte Platinen oder Adapter/Sockel (die aber wieder extra kosten). Will man mit Lochrasterplatinen oder [[Breadboard]]s arbeiten, dann braucht man die klassischen Bauformen, z. B. PDIP. Zu beachten ist dabei, dass es PDIP oft nur bis DIP40 (also mit 40 Pins) gibt, d.h. einen Mikrocontroller mit 50 I/O-Pins kann es dann nur als SMD geben.

Viele Mikrocontroller sind in verschiedenen Bauformen verfügbar. Nur in SMD verfügbar sind:
* MSP430 (Die kleinen sind mittlerweile auch als DIP erhältlich)
* AVR ATMega 169

In der klassischen (wenn auch in der Anzahl der verfügbaren IO-Pins limitiert) PDIP Bauform gibt es unter anderem:
* AVR ATMega 88A, 164A, 324A, 644A
* AVR ATTiny: Praktisch alle, z. B. ATTiny 13A, 24A, 25, 26, 2313A
* viele 8051-Derivate, z. B. Atmel 89S8252

== Spannung ==
Während früher die meisten Mikrocontroller und die gesamte Peripherie mit 5V liefen, so gibt es heute auch alle möglichen anderen Varianten. Zu beachten ist:
* Controller und Peripherie müssen zusammenpassen. Man kann nicht einfach (ohne weitere Vorkehrungen) ein 3,3V-RAM an einen 5V-Controller anschließen und umgekehrt.
* Manche Controller besitzen, obwohl sie intern mit einer anderen Spannung arbeiten, 5V-kompatible IO-Pins (Beispiel: [[LPC2000 Philips ARM7TDMI-Familie|LPC2100]]).
* Manche Controller brauchen zwei verschiedene Spannungen. Dies ist aber relativ selten, z. B. bei den [[LPC2000 Philips ARM7TDMI-Familie|LPC2100]].

* Billig-Netzteile liefern im Leerlauf manchmal deutlich mehr Spannung als angegeben, ein [[Standardbauelemente|Spannungsregler]] (z. B. 78xx) ist also Pflicht!
* Bei Batterien und Akkus sinkt die Spannung ab, wenn sie leerer werden. Braucht der Controller z. B. mindestens 2,7V, dann wird man mit zwei 1,5V-Batterien nicht lange Freude haben (außer man benutzt spezielle Schaltregler).

== Stromverbrauch ==
Im Vergleich zu PC-Prozessoren (Pentium, Athlon usw.) brauchen Mikrocontroller relativ wenig Strom. Will man sie allerdings mit Batterien betreiben, dann wird der Stromverbrauch plötzlich doch wichtig. Die meisten Mikrocontroller besitzen hierfür Stromsparmodi, mit denen man den Controller teilweise abschalten kann. Für einen extrem geringen Stromverbrauch sind z. B. die [[MSP430]]-Controller oder [[EFM32]]-Controller optimiert.

Der Stromverbrauch hängt auch stark vom Takt und der Versorgungsspannung ab.

{| border=1 cellspacing=0
! Frequenz !! ATMega8 (2.7V) !! ATMega8 (5.0V) !! PIC16LF84A(2.0V) !! PIC16F84A (5.5V) !! MSP430F2618 (3V) !! Einheit
|-
! 32KHz
|62||80||45||-
|title="Keine Angabe"|k.A.||µA
|-
! 100KHz
|0,3||0,5||-||-||0,084
|rowspan=4|mA
|-
!1MHz, 2MHz*
|1,5||2,3||4||-||0,5
|-
!8MHz, 4MHz*
|5||7/15**
|rowspan=2|-||4,5||4,2
|-
!16MHz, 20MHz*
| -||20||20||9,5 (3,3V)
|}

[*] Abweichende Taktangabe für PIC16*F84A, da hier keine entsprechenden Werte für die Frequenzen des ATmega8 im Datenblatt (PIC16F84A Data Sheet, Microchip 2001, 35007b.pdf) vorliegen.

[**] Angaben sind in der Folge Idle/Active (Quelle: Atmel, ATmega8/L, doc2486.pdf).

== Takt/Geschwindigkeit ==
Einerseits wünscht man sich oft einen möglichst schnellen Controller, insbesondere als Anfänger, wenn man effiziente Lösungen noch nicht so kennt, andererseits schlägt sich ein hoher Takt auch im Stromverbrauch und im Preis nieder. Man sollte sich dabei nicht von den hohen Taktraten der PC-Prozessoren irritieren lassen. Für viele Anwendungen reicht 1-MHz-Takt völlig aus.

Bei einem Geschwindigkeitsvergleich sollte man beachten, dass man nicht einfach den Takt vergleichen kann:
* Während manche Controller 12 Takte für einen Befehl brauchen (z. B. die Original-[[8051]]), kommen andere mit einem Takt pro Befehl aus (z. B. [[AVR]]).
* Manche Controller unterstützen gewisse Operationen hardwareseitig, die auf anderen Controllern in Software nachgebildet werden muss. Beispiele sind z. B. Multiplikation und Division. Wer in einer Hochsprache programmiert, merkt davon nicht viel, da es dort die Befehle sowieso zur Verfügung stehen, aber sie brauchen auf einem Controller ohne Hardwareunterstützung eben deutlich länger.
* Die Datenbus- bzw. Registerbreite spielt eine wichtige Rolle, weil man z. B. für eine 16-Bit-Addition auf einer 8-Bit-CPU zwei Befehle und auf einer 16-Bit-CPU nur einen Befehl braucht.

== Speicher ==
Während früher oft nur die [[Register]] im Mikrocontroller waren, und der gesamte restliche Speicher extern angebunden werden musste, so sind heute die Speicher oft komplett im Mikrocontroller integriert. Das bedeutet aber teilweise auch, dass man sie nicht erweitern kann. Wichtig ist dabei u.a. die Größe des Programmspeichers (meist ein [[Flash-ROM]]) und das [[RAM#SRAM|SRAM]]. Fehlt letzteres, dann kann es mit der Compilerunterstützung schwierig werden.

Zu unterscheiden sind hier außerdem Controller in [[Von Neumann-Architektur|Von-Neumann-Architektur]] und [[Harvard-Architektur]]. Bei letzterer liegen Programmspeicher (ROM) und Datenspeicher (RAM) in getrennten Speicherbereichen; dies hat den Nachteil, dass für den Zugriff auf den Programmspeicher spezielle Befehle notwendig sind (was die Verwendung von im ROM abgelegten Daten in C-Compilern ziemlich umständlich macht), und dass man keine Programmteile direkt aus dem Datenspeicher ausführen kann.

== Onboard-Peripherie ==
Mikrocontroller haben meist eine ganze Menge Funktionen integriert, z. B. [[AD-Wandler]], [[I²C]]-Bus, [[SPI]], [[PWM]], [[RS-232]] usw. usf. Der Vorteil liegt darin, dass der Controller damit mehrere Dinge gleichzeitig machen kann. Dadurch steigt zum einen die Gesamtleistung des Controllers, zum anderen sind viele Dinge zeitkritisch, und die Programmierung ist deutlich einfacher, wenn man zehn zeitkritische Dinge gleichzeitig erledigen muss.

== Störfestigkeit ==
Eigentlich ein wichtiges Thema, andererseits findet man dazu nur sehr wenig Informationen. Bekannt ist beispielsweise, dass bei der [[AVR]]-Familie die ATmegas deutlich störfester sind als die alten AT90S.

== Programmiersprachen ==
Den direktesten Zugriff auf die "Innereien" eines Prozessors hat man mit [[Assembler]]. Dies ist jedoch gleichzeitig - zumindest auf den ersten Blick - die "abschreckendste" Sprache, denn sie erfordert einen hohen Lernaufwand. Aufgrund stark unterschiedlicher Befehlssätze verschiedener Controllerfamilien ist das Gelernte nie 1-zu-1 übertragbar und meist nur direkt auf einen einzigen Prozessor oder allenfalls auf eine Familie "verwandter" Produkte anwendbar. Dennoch kann man sich mit einiger Erfahrung recht schnell in einen anderen Befehlssatz einarbeiten. In bestimmten Bereichen oder Teilen eines Projekts wird die Verwendung von Assembler dennoch unabdingbar sein. (Diese Teile mögen projektabhängig zwischen 100% oder auch nur deutlich unter 1% umfassen.)

Die Auswahl der richtigen Programmiersprache hängt auch stark vom geplanten Einsatzzweck ab. Ein Elektrotechnik-Student, der sich für sein späteres Berufsleben vorbereiten möchte, sollte sich mit C und Assembler befassen. Wer dagegen gar nicht vorhat sich allzu tief einzuarbeiten und sowieso schon Basic oder Pascal kann, der sollte zu diesen Sprachen greifen.

Für einige Controllerfamilien (z. B. AVR, ARM, MSP430) gibt es eine Portierung des kostenlosen [[GCC|GNU-C-Compilers]], wodurch C auch im Hobby-Bereich stark vertreten ist und es auch viele Programmierbeispiele dafür gibt.

Für die LPC Prozessorfamilie ist eine größenlimitierte kostenlose Entwicklungsumgebung erhältlich. Informationen unter '''[http://www.code-red-tech.com/lpcxpresso.php code-red]''': Die auf Eclipse basierende Entwicklungsumgebung ist nach der Installation bis 8k freigeschaltet und nach einer einfachen und kostenlosen Registrierung für 128kB. Eine in der Projektgröße nicht beschränkte Version kann für ca. 800 Euro erworben werden. Die IDE ist auch für '''[http://support.code-red-tech.com/CodeRedWiki/redlib_v2_notes Linux]''' verfügbar. Hier die '''[http://www.mikrocontroller.net/articles/Installationsanleitung_C-Entwicklungsumgebung_f%C3%BCr_LPC1xxx_von_Code_Red Installationsanleitung]'''

== Debugging ==
Bei der Fehlerbeseitigung trennen sich Profi von Amateur, und es kann richtig teuer werden. Genau hier haben die Hersteller von Mikrocontrollern und/oder Compilern eine Möglichkeit gefunden, den Gelegenheitsprogrammierer abzuweisen und nur den zahlenden Profi vorzulassen.

Die preisgünstigste, aber auch unkomfortabelste Art des Debuggings ist der Einbau von Testcode in das Programm. Dieser Testcode informiert den Programmierer über erreichte Programmpunkte und dabei aufgetretene Datenwerte. Die Ausgabe erfolgt per optisch/akustischer Anzeige oder serieller Schnittstelle. Der Nachteil dieser Methode liegt in ihrem Zeitaufwand. Für jedes Problem muss ein kurzes Stück Testcode erdacht und in das Programm eingefügt werden. Danach wird das Programm kompiliert/assembliert und in den Flashspeicher des Mikrocontrollers gebrannt. Zuguterletzt muss das Programm von Beginn an durchlaufen und mit etwas Glück liefert der Testcode Informationen über das Problem.

Deutlich effektiver ist die Fehlersuche mittels einer in die PC-Entwicklungsumgebung integrierten Debugger-Software. Üblicherweise besteht diese Software aus mehreren Fenstern zur Anzeige folgender Informationen:

* Programm- und Datenspeicher des Mikrocontrollers.
* Arbeits- und Konfigurationsregister des Mikrocontrollers.
* Programmquellcode in Hochsprache (z. B. C) und/oder Assembler.
* Werte von Programm-Variablen.

Ausgehend vom Quellcode/Assembler-Fenster kann man den Programmcode auf das Zielsystem laden, den Programmlauf starten und an beliebigen Stellen stoppen, das Programm zeilenweise oder wiederholend abarbeiten, Variablen/Speicher/Register anzeigen und auch verändern. Diese Vorgänge werden bei modernen Debuggern mit wenigen Funktionstasten und Kontextmenü gesteuert. Angemerkt sei, Debugging einer Hochsprache wie C funktioniert nur richtig, wenn die Codeoptimierung des Compilers deaktiviert ist. Diese Bedingung bringt es mit sich, dass für die Entwicklungsphase bis zu 30% mehr Programmspeicher benötigt werden.

Der Programmlauf kann in einem Software-Simulator oder direkt auf dem Mikrocontroller erfolgen. Leider können Simulatoren weder die Signale der Controllerumgebung, noch Interrupts realistisch nachahmen. Hier hilft nur In-System-Debugging direkt auf dem Zielsystem.

Für das In-System-Debugging wird der Ziel-Mikrocontroller mit seiner In-Circuit-Debugging-Hardware benutzt. Diese integrierte Hardware kommuniziert über teils genormte Schnittstellen mit der Debuggersoftware auf dem PC. Als Verbindungsglied dient ein Kabel mit mehr oder weniger komplexer Elektronik. Diese Elektronik, das fehlende Wissen um ihre Funktion und die teils eingebaute Donglefunktion verhindern preisgünstigen Nachbau und machen ihren Hersteller sicher vor unautorisierter Benutzung der Entwicklungsumgebung.

Bei der Vielzahl von Controller- und Compiler-Herstellen ist es kaum möglich, einen Überblick über die Debugger-Hardware/Software zu geben. Hier nur einige Beispiele:

=== [http://www.atmel.com/ Atmel] ===

{| border="1"
|-
!System
!Preis
|-
| [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2737 AVR JTAG ICE] Clone (wenige ATmega Typen)
| ~ 35€
|-
| [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=3891 AVR Dragon]
| ~ 55€
|-
| [http://www.keeelectronics.com/mkii.htm AVR JTAG ICE MKII - CN]
| ~ 85$
|-
| [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=3353 AVR JTAG ICE MKII] / [http://www.sureelectronics.net/goods.php?id=931 Clone]
| ~ 280€/99$
|-
| [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=4279 AVR ONE!]
| ~ 550€
|}

[http://atmel.com/products/avr32/default.asp AVR32 Controller (32-Bit)] können mit Atmels freiem [http://atmel.com/dyn/products/tools_card.asp?tool_id=4116 AVR32 Studio], basierend auf der [http://www.eclipse.org/ Eclipse IDE], programmiert und debugt werden. Die IDE bedient sich dabei der [http://atmel.com/dyn/products/tools_card.asp?tool_id=4118 AVR32 GNU Toolchain].

Der Debugger für [http://atmel.com/products/avr/default.asp AVR 8-Bit] RISC Controller ist in Atmels freie [http://atmel.com/dyn/products/tools_card.asp?tool_id=2725 AVR Studio] IDE integriert. In Verbindung mit dem GNU C++ Compiler für AVR ([http://winavr.sourceforge.net/ WinAVR]) und der integrierten Bibliothek [http://www.nongnu.org/avr-libc/ AVR Libc] ist Hochsprach-Entwicklung und -Debugging möglich.

Der [[JTAG|AVR JTAG]] ICE Clone kann nur nachfolgende ältere ATmega Controller debuggen: ATmega16, ATmega16L, ATmega162, ATmega162L, ATmega162V, ATmega165, ATmega165V, ATmega169, ATmega169L, ATmega169V, ATmega32, ATmega32L, ATmega323, ATmega323L, ATmega64, ATmega64L, ATmega128, ATmega128L, AT90CAN128. Trotzdem ist er ein sehr wertvolles, weil günstiges Werkzeug, wenn man die Typbeschränkung akzeptieren kann.

Atmel [[AVR]] Dragon kann ATtiny, ATmega, XMega, AT32UC3x und AP7xxx programmieren und debuggen. Die drei letzt genanneten MCUs werden seit AVR Studio Version ''4.18 SP1'' unterstützt.

[http://www.mikrocontroller.net/topic/107070 AVR JTAG ICE MKII – CN] ist ein Produkt aus China mit der versprochenen Funktionalität eines originalen AVR JTAG ICE MKII von Atmel. Es besitzt eigenständige Elektronik und auch die aktualisierbare Firmware ist vom Original verschieden. Oftmals ist dieses Produkt beim nicht unbekannten Online-Auktionshaus zu finden.

=== [http://www.microchip.com/ Microchip] ===

{| border="1"
|-
!System
!Preis
|-
| [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en023805 MPLAB PICkit2 / PICkit2 Debug Express]
| ~ 30€/55€
|-
| [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en538340 MPLAB PICkit3 Debug Express]
| ~ 65€
|-
| [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010046&part=DV164005 MPLAB ICD 2] / [http://www.keeelectronics.com/icd25debugger.html Clone ICD2.5] / [http://www.sivava.com/MPLAB_ICD2.html Clone ICD2]
| ~ 90€/40€/40€
|-
| [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en537580 MPLAB ICD 3]
| ~ 190€
|}

Alle Typen von Microchip Debugger Hardware werden von Microchips freier [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002 MPLAB IDE] unterstützt. Diese IDE kann mit C-Compilern verschiedener Hersteller zusammenarbeiten. Das Setup installiert keine Microchip C-Compiler sondern bietet als Option die C-Compiler von CCS und HI-TECH. Der CCS Compiler für PIC18F45k20 ist auf 2kWord Programmcode begrenzt. Die HI-TECH Compiler für PIC10/12/16, PIC18 und PIC32 haben, wenn sie als Freeware im ‚Lite mode’ arbeiten, eingeschränkte Codeoptimierung. Microchips C-Compiler für [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010014 PIC18], [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en535364 PIC24], [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en535363 dsPIC DSCs] und/oder [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2615&dDocName=en532454 PIC32] können zusätzlich installiert werden. In der zum freien Download bereitstehenden ‚Student Edition’ stellen sie nach 60 Tagen einen Teil der Codeoptimierung ein. Das MPLAB Setup bietet optional die Installation der, im nächsten Absatz behandelten, HI-TECH IDE ‚HI-TIDE 3’ an.

Die Debugger Hardware ICD 2 von Microchip wird auch von der freien, auf [http://www.eclipse.org/ Eclipse] basierenden, HI-TECH IDE [http://www.htsoft.com/downloads/demos.php#hitide ‚HI-TIDE 3’] unterstützt. Diese moderne IDE kann zusammen mit Microchips MPLAB oder separat installiert werden. Zusätzlich zu installieren sind HI-TECHs C-Compiler für die Microchip Reihen [http://www.htsoft.com/microchip/products/compilers/piccpro-modes.php PIC10/12/16], [http://www.htsoft.com/microchip/products/compilers/picc18pro-modes.php PIC18] und/oder [http://www.htsoft.com/microchip/products/compilers/pic32-modes.php PIC32]. Ihre im ‚Lite mode’ bestehende Einschränkung wurde bereits erwähnt.

Die beiden für PICs vorhandenen IDEs von Microchip und HI-TECH bilden zusammen mit den freien C-Compilern und den preisgünstigen ICD 2 Clones eine kostengünstige Möglichkeit, PIC-Code zu erstellen und zu debuggen. Die eingeschränkte Codeoptimierung ist für Amateure verschmerzbar. Einige kleine PICs haben leider keine In-Circuit-Debugging-Hardware eingebaut. Diese PICs sind nur mit Hilfe eines kostspieligen [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en538769 Header Boards] debugbar.

=== [http://focus.ti.com/mcu/docs/mcuprodoverview.tsp?sectionId=95&tabId=140&familyId=342 TI MSP430] ===

{| border="1"
|-
!System
!Preis
|-
| Olimex [http://shop.embedded-projects.net/product_info.php/info/p58_MSP430-JTAG-Parallelportkabel--MSP430-JTAG-.html MSP430 JTAG (parallel)]
| ~ 15€
|-
| Olimex [http://shop.embedded-projects.net/product_info.php/info/p63_MSP430-USB-JTAG-Adapter--MSP430-JTAG-TINY-.html MSP430-JTAG-TINY (USB)]
| ~ 65€
|-
| TI-FET [http://focus.ti.com/docs/toolsw/folders/print/msp-fet430uif.html MSP430 USB Debugging Interface]
| ~ 115€
|-
| TI [http://focus.ti.com/docs/toolsw/folders/print/ez430-f2013.html MSP430 USB Stick Development Tool]
| ~ 30€
|}

[http://focus.ti.com/lit/ug/slau265/slau265.pdf Programmierung] und Debugging der MSP430 erfolgt über JTAG-Schnittstelle und in neusten Varianten (MSP430F20xx, F21x2, F22xx) über ‚Spy-Bi-Wire’ (2-wire JTAG). Die ursprüngliche JTAG-Schnittstelle benötigt 4 Signalleitungen plus Reset. Bei ‚Spy-Bi-Wire’ sind die Signalleitungen auf 2 reduziert.

Jeder anwenderprogrammierbare MSP430 enthält einen [[Bootloader]]. Bei den Typenreihen MSP430F1xx, F2xx und F4xx befindet er sich im ROM. Bei den MSP430F6xx im Flash-Speicher.

TI bezeichnet die Programmier- und Debugging-Hardware als Flash Emulation Tool (FET). Es existieren die Varianten ‚Parallel Port’ und USB. Die preisgünstigen parallelen Systeme beherrschen nur JTAG. Bei den USB-Systemen ist zusätzlich ‚Spy-Bi-Wire’ implementiert, und man kann damit die Codeschutzsicherung des Mikrocontrollers auslösen.

Die [http://www.olimex.com/dev/index.html Olimex] Produkte entsprechen in ihrer Funktion weitestgehend den TI-Vorbildern und können mit jeder Software verwendet werden, die TI-Werkzeuge unterstützt. Kleine Abweichungen bestehen bei der [http://www.olimex.com/dev/images/MSP430/SPY-BI-WIRE-CONNECTION.jpg Olimex Implementierung] der ‚Spy-Bi-Wire’ Verbindung des MSP430-JTAG-TINY.

Das ‚MSP430 USB Stick Development Tool’ ist eine eigenständige Debugging-Hardware mit aufgestecktem eZ430-F2013 Zielsystem. Der Stick beherrscht aber nur ‚Spy-Bi-Wire’, wodurch die Anzahl der unterstützten Controller begrenzt ist.

Als Entwicklungsumgebung stellt TI den auf der [http://www.eclipse.org/ Eclipse IDE] aufbauenden ‚Code Compose Essentials’ bereit. In der freien Version [http://focus.ti.com/docs/toolsw/folders/print/msp-cce430.html ‚CCE Core Edition’] ist dieses Paket auf 16kB Code begrenzt.

Mit der freien IDE Eclipse, dem GNU C-Compiler für MSP430, einigen Zutaten und dem Olimex Parallelport-Adapter kann man die wohl preiswerteste, unbeschränkte Entwicklungsumgebung für Mikrocontroller zusammenstellen. Es ist keine perfekte Kombination, und die Installation macht einige Mühe; im Ergebnis hat man aber eine Arbeitsplattform, einschließlich Debugger, ohne unverständliche Skripte oder kryptischen Make-Files. Über diese beiden Links

* [[Eclipse und MSPGCC unter Windows]] (03/2009)
* [http://matthias-hartmann.blogspot.com/ Use Eclipse and mspgcc - the easy way] (Windows 02/2009)

findet man zwei verschiedenartige Lösungen der Installation unter Windows. Obwohl beide Varianten auf teils verschiedene Werkzeuge zurückgreifen, sind sie kombinierbar und ergeben damit Spielraum für persönliche Vorlieben.

=== [http://www.zilog.com/ Zilog] ===

{| border="1"
|-
!System
!Preis
|-
| [http://www.zilog.com/index.php?option=com_product&Itemid=26&mode=showProdDet&businessLine=1&familyId=6&productId=ZUSBSC00100ZACG USB Smart Kabel]
| ~ 30$
|-
| [http://www.zilog.com/index.php?option=com_product&Itemid=26&mode=showProdDet&businessLine=1&familyId=6&productId=ZENETSC0100ZACG Ethernet Smart Kabel]
| ~ 70$
|}

Die [[Zilog]] Entwicklungssysteme [http://www.zilog.com/index.php?option=com_content&task=view&id=40&Itemid=137 ZDS II] (C/ASM) für [http://www.zilog.com/index.php?option=com_product&Itemid=26&mode=showFamilyDetails&familyId=5&parent_id=2 Z8 Encore!®], [http://www.zilog.com/index.php?option=com_product&Itemid=26&mode=showFamilyDetails&familyId=6&parent_id=2 Z8 Encore! XP®], [http://www.zilog.com/index.php?option=com_product&Itemid=26&mode=showFamilyDetails&familyId=7&parent_id=2 Z8 Encore! MC™] sowie [http://www.zilog.com/index.php?option=com_product&Itemid=26&mode=showFamilyDetails&familyId=8&parent_id=2 ZNEO™ Z16F] Controller haben keine Beschränkungen sind aber ganz zu Unrecht in Europa kaum bekannt oder erhältlich.

=== [http://www.nxp.com/products/microcontrollers/ NXP] ===
{| border="1"
|-
!System
!Preis
|-
| [http://www.watterott.com/index.php?page=search&keywords=LPCXpresso&cat=&mnf=&x=0&y=0 Entwicklungskit incl. USB-JTAG/SWD Programmer & Debugger]
| ~ 25€

|}
Die NXP [http://www.mikrocontroller.net/articles/LPC1xxx Entwicklungskits] sind sehr preiswerte Kits aus einem Target und einem USB-JTAG/SWD Programmer & Debugger. Das Target kann sehr einfach vom Programmer/Debugger getrennt, und für eigene Projekte verwendet werden. Siehe dazu auch die Dokumentation von NXP zu den '''[http://www.nxp.com/documents/leaflet/75016842.pdf LPCXpresso-Entwicklungskits (PDF)]''' und diese '''[http://www.mikrocontroller.net/wikisoftware/index.php?title=LPC1xxx_Entwicklungskit_LPCXpresso Beschreibung]'''

== Programmübertragung ==
Im Idealfall stellt sich die Frage, wie das Programm in den Mikrocontroller kommt, für den Programm-Entwickler nicht. Die Debugging-Hardware erledigt diese Aufgabe ganz unauffällig mit. Da die Umstände aber nicht immer ideal sind, muss der Entwickler manchmal auf andere Methoden zurückgreifen.

Früher wurden überwiegend teure und umständlich zu handhabende Programmiergeräte verwendet, mit deren Hilfe der Programmspeicher außerhalb des Zielsystems gefüllt wurde. Heute sind die meisten Mikrocontroller über verschiedene ISP-Schnittstellen oder über das [[UART]] ‚In-System’-programmierbar.

Die ISP-Schnittstelle ist entweder als universelle Debugging- und Programmier-Schnittstelle, z. B. [[JTAG]], oder als dedizierte Programmier-Schnittstelle realisiert. Für den zweiten Fall benötigt man einen speziellen Programmier-Adapter den man, meistens in verschiedenen Ausführungen, kaufen oder selber bauen kann. Dazugehörig ist ein passendes Programmier-Programm für den PC. Spezialisierte Programmier-Adapter und –Programme werden auch gern in der laufenden Produktion eingesetzt.

Mikrocontroller mit integriertem [[Bootloader]] können mit der entsprechenden PC-Software direkt über den seriellen Port programmiert werden.

[[Category:Mikrocontroller| ]]

Bierdeckel-Programmer

2013-06-07T17:26:15Z

M-w: Abblock-Kondensator. Danke an Konrad!

[[Bild:bierdeckel_programmer.jpg|right|thumb|306px|Bierdeckel-Programmer]]

Nein, es werden hier keine Bierdeckel programmiert, sondern gezeigt, dass AVR-Programmer für die USB-Schnittstelle so einfach sind, dass man sie mit Hilfe weniger Teile auch auf einem Bierdeckel aufbauen kann.

Ursprünglich war der Schaltplan auf einem Bierdeckel nur als Werbegag gedacht, aber es lässt sich tatsächlich auf diese Art ein Programmer bauen: Die aufgedruckten kleinen Kreise werden jeweils mit einer Pinnwand-Nadel durchstochen. Auf die so entstandene "Platine" setzt man die Bauteile des Programmers. Verlötet werden sie auf der Unterseite. Dabei stehen die durchgezogenen Linien für Anschlussdrähte, die auf der Oberseite sichtbar sind, und die gestrichelten Linien für Drähte, die auf der Unterseite verlaufen.

; Stückliste
* 1 Mikrocontroller ATtiny85, evtl. mit Fassung
* 1 USB-Anschlussleitung oder eine USB-B-Buchse
* 2 Zener-Dioden (3,6 V)
* 7 Widerstände (2 x 100, 4 x 470, 1 x 2200 Ohm)

; Verdrahtungsplan
[[Bild:bierdeckel_verdrahtung.png|Verdrahtungsplan des Bierdeckel-Programmers]]

Tipp: Falls der Programmer trotz korrektem Aufbau nicht zuverlässig läuft (Abbrüche etc.), empfiehlt es sich, zur Glättung der Versorgungsspannung einen Kondensator von 100 nF zwischen die Anschlüsse VCC (Pin 8) und GND (Pin 4) des ATtiny85 zu löten. Auf der Bierdeckel-Unterseite ist dafür genügend Platz.

== Software ==

Da es sich beim Bierdeckel-Programmer um eine Weiterentwicklung des Standard-USBasp von Thomas Fischl handelt, kann man als Software [[avrdude]] verwenden. Damit lässt sich der Programmer auch unter AVR Studio einbinden.

== Firmware ==

Für den Aufbau wird ein Mikrocontroller des Typs ATtiny85 im DIP-Gehäuse benötigt. Diesen kann man selbst mit der Firmware versehen, sie ist quelloffen und zum Beispiel [http://guloshop.de/f/sources/ ''hier''] downloadbar. Oder man besorgt sich den Mikrocontroller in der bereits programmierten Variante.

[[Kategorie:AVR-Programmer und -Bootloader]]

Bierdeckel-Programmer

2013-05-04T18:05:35Z

M-w: Bierdeckel-Programmer

[[Bild:bierdeckel_programmer.jpg|right|thumb|306px|Bierdeckel-Programmer]]

Nein, es werden hier keine Bierdeckel programmiert, sondern gezeigt, dass AVR-Programmer für die USB-Schnittstelle so einfach sind, dass man sie mit Hilfe weniger Teile auch auf einem Bierdeckel aufbauen kann.

Ursprünglich war der Schaltplan auf einem Bierdeckel nur als Werbegag gedacht, aber es lässt sich tatsächlich auf diese Art ein Programmer bauen: Die aufgedruckten kleinen Kreise werden jeweils mit einer Pinnwand-Nadel durchstochen. Auf die so entstandene "Platine" setzt man die Bauteile des Programmers. Verlötet werden sie auf der Unterseite. Dabei stehen die durchgezogenen Linien für Anschlussdrähte, die auf der Oberseite sichtbar sind, und die gestrichelten Linien für Drähte, die auf der Unterseite verlaufen.

; Stückliste
* 1 Mikrocontroller ATtiny85, evtl. mit Fassung
* 1 USB-Anschlussleitung oder eine USB-B-Buchse
* 2 Zener-Dioden (3,6 V)
* 7 Widerstände (2 x 100, 4 x 470, 1 x 2200 Ohm)

; Verdrahtungsplan
[[Bild:bierdeckel_verdrahtung.png|Verdrahtungsplan des Bierdeckel-Programmers]]

== Software ==

Da es sich beim Bierdeckel-Programmer um eine Weiterentwicklung des Standard-USBasp von Thomas Fischl handelt, kann man als Software [[avrdude]] verwenden. Damit lässt sich der Programmer auch unter AVR Studio einbinden.

== Firmware ==

Für den Aufbau wird ein Mikrocontroller des Typs ATtiny85 im DIP-Gehäuse benötigt. Diesen kann man selbst mit der Firmware versehen, sie ist quelloffen und zum Beispiel [http://guloshop.de/f/sources/ ''hier''] downloadbar. Oder man besorgt sich den Mikrocontroller in der bereits programmierten Variante.

[[Kategorie:AVR-Programmer und -Bootloader]]

Datei:Bierdeckel programmer.jpg

2013-05-04T17:58:56Z

M-w: AVR-Programmer auf einem Bierdeckel aufgebaut

AVR-Programmer auf einem Bierdeckel aufgebaut

Datei:Bierdeckel verdrahtung.png

2013-05-04T17:55:16Z

M-w: Verdrahtungsplan für den Bierdeckel-Programmer

Verdrahtungsplan für den Bierdeckel-Programmer

AVR HV-Programmer

2013-04-18T17:13:36Z

M-w:

Ein "Hochspannungs"-Programmierer für AVR legt eine Spannung von +12V an den Reset-Eingang. Damit lassen sich auch Fusebits programmieren, die mit dem normalen ISP-Programmer nicht zugänglich sind.

Zu unterscheiden sind das High Voltage Serial Programming ([http://support.atmel.no/knowledgebase/avrstudiohelp/mergedProjects/AVRDragon/AVRDragon_HVSP_Description.htm HVSP]) und das Parallel Programming ([http://support.atmel.no/knowledgebase/avrstudiohelp/mergedProjects/AVRDragon/AVRDragon_PP_Description.htm PP]). Welche Methode(n) ein AVR unterstützt, steht im jeweiligen Datenblatt des AVRs.

Bekannte HV Programmer sind:
* [[STK500]] (HVSP, PP)
* [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=3891 AVR Dragon] (HVSP, PP)
* [http://www.der-hammer.info/hvprog/ HVProg von Tobias Hammer] (PP, HVSP)
* [http://www.b-redemann.de/produkte-programmer.shtml Bausatz und Anleitung von Bernhard Redemann] (PP)
* [http://www.obdev.at/products/avrusb/avrdoper.html AVR-Doper] High Voltage '''Serial''' Programmer (HVSP)
* [http://mightyohm.com/blog/2008/09/arduino-based-avr-high-voltage-programmer/ Arduino-based AVR High Voltage Programmer] (PP)
* [http://elm-chan.org/works/avrx/report_e.html '''Parallel''' HV-Programmer von ElmChan (ChaN)] (PP)
* [http://diy.elektroda.eu/atmega-fusebit-doctor-hvpp/?lang=en Atmega fusebit doctor] (HVSP, PP)
* [https://guloshop.de/shop/Mikrocontroller-Programmierung/HVSP-Fusebit-Programmer::63.html HVSP Fusebit Programmer] (HVSP, auch stand-alone ohne PC nutzbar)

=== Ein Platinenlayout für ElmChans HV(PP)-Programmer ===

Schaltplan im Eagle-Format, Bestückungspläne und Platinenlayout: [[Benutzer:Christoph kessler|Christoph kessler]]

ElmChans Konzept ist eine ausgesprochene "Billiglösung", dem scheint eine einseitige Platine mit Drahtbrücken im Eagle-Light-Format 80*100mm angemessen.

Das Foto (unten) zeigt schon die "Luxusversion", Teilbestückung ist ja denkbar.

[[Media:AVR_HV_Programmer_Eagle.zip | Eagle board / schematic files]]

[[Bild:Schematic.png|600px]]

[[Bild:Components.png|600px]]

[[Bild:AVR_HV_Programmer_Layout.png|600px]]

[[Bild:AVR_HV_Programmer_Foto.jpg]]

===siehe auch===
[http://xray37.de/?Bastelbuch:Lima-SDR:RX Miniatur-Version von ElmChans HV-Programmer]

[[AVR In System Programmer]]

[[Kategorie:AVR-Programmer und -Bootloader]]
[[Kategorie:AVR-Boards]]

AVR Typen

2012-05-22T16:54:48Z

M-w: /* ATmega - Reihe */ +ATmega324

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man ein andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny4313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz].

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny und die Mega. Die ATTiny haben kleinere Gehaeuse als die ATMega, mit weniger Pins. Dies fuehrt bei aehnlicher Funktionalitaet wie die Megas zu extremerer Mehrfachbelegungen der Pins und auch eher zu Ueberschneidungen der Pinfunktionalitaet. Die Tiny sind daher eher fuer sehr hohe Stueckzahlen geeignet, wo die Einsparung ueber die Stueckzahl kommt. Anfaenger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in Kibibyte an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.70-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.00-2.00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|2.7-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1.45
|-
|[http://www.atmel.com/Images/doc8183.pdf ATtiny84A]
|8
|512
|512
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1,00-4,00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.30-2.00
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.25-4.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega328]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/Images/doc8272.pdf ATmega324A]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2
|Ja
|PDIP40 TQFP44 VQFN44 QFN/MLF44 DRQFN44 VFBGA49
| 3.50-4.50
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|5.50-7.00
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8.00-15.00
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP20 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==
Vergleichstabellen zum Downloaden gibt es unter Anderem
* [http://www.mikrocontroller.net/topic/242328 von Andreas], Stand 19.12.2011; vollständig,
* [http://www.mikrocontroller.net/topic/232939 von Sven], Stand 22.09.2011; weiter eingedampft.

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Category:AVR]]

AVR Typen

2012-05-07T10:48:35Z

M-w: /* ATtiny - Reihe */

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man ein andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny4313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz].

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny und die Mega. Die ATTiny haben kleinere Gehaeuse als die ATMega, mit weniger Pins. Dies fuehrt bei aehnlicher Funktionalitaet wie die Megas zu extremerer Mehrfachbelegungen der Pins und auch eher zu Ueberschneidungen der Pinfunktionalitaet. Die Tiny sind daher eher fuer sehr hohe Stueckzahlen geeignet, wo die Einsparung ueber die Stueckzahl kommt. Anfaenger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in Kibibyte an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.70-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.00-2.00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|2.7-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1.45
|-
|[http://www.atmel.com/Images/doc8183.pdf ATtiny84A]
|8
|512
|512
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1,00-4,00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.30-2.00
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.70-1.90
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega328]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|(5.25-8 EUR)
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8-15
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP20 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==
Vergleichstabellen zum Downloaden gibt es unter Anderem
* [http://www.mikrocontroller.net/topic/242328 von Andreas], Stand 19.12.2011; vollständig,
* [http://www.mikrocontroller.net/topic/232939 von Sven], Stand 22.09.2011; weiter eingedampft.

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Category:AVR]]

Diskussion:AVR-Tutorial

2012-04-19T17:47:29Z

M-w: veralteter ATmega8, + Seite formatiert

== Assembler, Basic oder C? ==

'''Assembler, Basic oder C?''' habe ich wieder restauriert. Es ist eine IMHO berechtigte und fundamentale Anmerkung zum Sinn des kompletten Tutorials. Wieso/warum jemand das kommentarlos wegzulöscht, verstehe ich nicht. [[Benutzer:Stefan|Stefan]] 20:57, 14. Okt 2007 (CEST)

== ATmega8 veraltet ==

'''Mega 8?''' - Der Mega 8 steht bei Atmel auf Not for New Design. Der wird durch den MEGA8A ersetzt.
Sollte ev. im Tutorial erwähnt werden bzw. das Tutorial auf den Mega8A umgestellt werden??
Ich muss aber gestehen, dass ich mir das Datenblatt des Mega8A noch nicht angeschaut habe und des da ohnehin keinen relevanten Unterschied gibt.
[[Benutzer:Aim|Aim]] 15:20, 09. Okt 2009 (CEST)

:2 1/2 Jahre später: Der Einwand von [[Benutzer:Aim|Aim]] ist meines Erachtens immer noch berechtigt. Inzwischen gibt es den ATmega88 als Weiterentwicklung des ATmega8. In aller Regel ist er sogar um einiges billiger als die veraltete Version. Funktionieren alle Teile des Tutorials auch mit dem neueren Mikrocontroller? Falls ja, sollte das vielleicht erwähnt werden. --[[Benutzer:M-w|M-w]] 17:47, 19. Apr. 2012 (UTC)

AVR Typen

2012-04-13T19:52:03Z

M-w: /* ATtiny - Reihe */

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man ein andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny2313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz].

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny und die Mega. Die ATTiny haben kleinere Gehaeuse als die ATMega, mit weniger Pins. Dies fuehrt bei aehnlicher Funktionalitaet wie die Megas zu extremerer Mehrfachbelegungen der Pins und auch eher zu Ueberschneidungen der Pinfunktionalitaet. Die Tiny sind daher eher fuer sehr hohe Stueckzahlen geeignet, wo die Einsparung ueber die Stueckzahl kommt. Anfaenger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in Kibibyte an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.70-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.00-2.00
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1.45
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.30-2.00
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.70-1.90
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega328]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|(5.25-8 EUR)
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8-15
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP20 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Category:AVR]]

AVR Typen

2012-04-13T19:48:42Z

M-w: /* ATmega - Reihe */

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man ein andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny2313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz].

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny und die Mega. Die ATTiny haben kleinere Gehaeuse als die ATMega, mit weniger Pins. Dies fuehrt bei aehnlicher Funktionalitaet wie die Megas zu extremerer Mehrfachbelegungen der Pins und auch eher zu Ueberschneidungen der Pinfunktionalitaet. Die Tiny sind daher eher fuer sehr hohe Stueckzahlen geeignet, wo die Einsparung ueber die Stueckzahl kommt. Anfaenger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in Kibibyte an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 2
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1.45
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 2
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.70-1.90
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/Images/doc8271.pdf ATmega328]
|32
|1K
|2K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 2.00-4.50
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|(5.25-8 EUR)
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8-15
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP20 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Category:AVR]]

AVR Typen

2012-04-10T19:19:09Z

M-w: /* ATtiny - Reihe */ korrigiert/aktualisiert

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man ein andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny2313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz].

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny und die Mega. Die ATTiny haben kleinere Gehaeuse als die ATMega, mit weniger Pins. Dies fuehrt bei aehnlicher Funktionalitaet wie die Megas zu extremerer Mehrfachbelegungen der Pins und auch eher zu Ueberschneidungen der Pinfunktionalitaet. Die Tiny sind daher eher fuer sehr hohe Stueckzahlen geeignet, wo die Einsparung ueber die Stueckzahl kommt. Anfaenger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in Kibibyte an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|-
| X || TSSOP-Gehäuse
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/Images/doc8126.pdf ATtiny13A]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|18
|20
|2.7-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://www.atmel.com/Images/doc8246.pdf ATtiny4313]
|4
|256
|256
|18
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 2
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1.45
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20 (TSSOP20 bei Tiny261A)
|1,15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 2
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.70-1.90
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|(6-8 EUR)
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8-15
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP20 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Category:AVR]]

AVR Typen

2012-03-23T23:51:17Z

M-w: /* ATtiny - Reihe */ ATtiny13 laut Datenblatt nur bis 20 MHz

== AT90S ==
Die "Basic Line" der Atmel [[AVR]]-Reihe. Sie beinhaltet die ersten [[AVR|AVRs]] die produziert wurden und deren Bezeichnung mit "AT90S" beginnt. Alle Typen wurden mit der Zeit von den beiden Nachfolgereihen ersetzt: ATmega bzw. ATtiny.

Einige neue AVR-Controller tragen eine mit AT90-''ohne S'' beginnende Bezeichnung, haben aber einen "moderneren" Kern. Z.B. sind die Typen AT90PWM2/3 und AT90CAN128 vom Funktionsumfang (interner RC, USART etc.) den ATmegas zuzuordnen.

== ATmega ==
Die ATmega-[[Mikrocontroller]] sind ein Teil der AVR-Controllerfamilie. Zusammen mit den ATtiny lösen die ATmega die AT90S-Serie schrittweise ab, wobei es in den meisten Fällen weitgehend pin- und funktionskompatiblen Ersatz für abgekündigte Controller gibt (ATmega8 statt AT90S4433, ATmega8515 statt AT90S8515 usw.).

Atmel ATmega AVRs werden mit aktiviertem internem Taktgeber ausgeliefert. Schließt man ein andere externe Taktquelle an (Quarz, Quarzoszillator o.ä), wird diese nicht automatisch genutzt. Zum Aktivieren müssen die Fuse-Bits des Controllers entsprechend eingestellt werden (siehe Datenblatt).

ATmegas mit integriertem [[JTAG]]-Interface (z.Zt. solche ab 16kB Flash-Speicher und mehr als 28 Pins) werden ab Werk mit aktiviertem JTAG-Interface ausgeliefert. Dieses Interface belegt vier Port-Pins (z. B. am PORTC bei ATmega16/32), die nicht für eigene Anwendungen genutzt werden können, solange das JTAG-Interface aktiviert ist. Das Interface lässt sich über ein Fuse-Bit (JTAGEN) dauerhaft und über ein Bit (JTD) in dem (oder einem der) MC-Kontroll-Register (Datenblatt nach JTD durchsuchen) per Software zur Laufzeit an- und abschalten. Weiteres im Datenblatt des jeweiligen Controllers in den Abschnitten Memory-Programming (Fuse) und JTAG/ICE (JTD).

Beim ATmega128 ist ab Werk die Mega103-Kompatibilitäts-fuse gesetzt. Um alle Erweiterungen des Mega128 gegenüber dem Mega103 zu nutzen muss diese deaktivert werden. Diese Fuse sorgt außerdem dafür, dass das SRAM in einem anderen Adressbereich liegt. Dadurch funktionieren C-Programme nur bis zum ersten Funktionsaufruf. Siehe auch [[AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Gehäuse | AVR Checkliste: Besonderheiten bei ATmega64 / ATmega128]]

== ATtiny ==

Die ATtiny stellen das untere Ende der neuen AVR Linie von Atmel dar und waren zunächst durch das Fehlen von internem [[RAM#SRAM|SRAM]] gekennzeichnet. Mittlerweile gibt es aber so bemerkenswerte Controller wie den ATtiny2313, deren Möglichkeiten und Funktionen den ATmegas in nichts nachstehen.

Ein weiterer Unterschied zu den ATmegas ist der fehlende Hardwaremultiplizierer. Jede Multiplikation muss also in Software ausgeführt werden. Eine Übersicht über die Verfügbarkeit verschiedener Befehle bietet die [[AVR_Assembler_-_Vergleichstabelle|AVR-Assembler Befehlsvergleichstabelle]].

== ATxmega ==
Neueste Generation von AVR-Controllern mit neuem internen Aufbau, hoher Taktrate (32 MHz), niedriger Spannung (1,6 - 3,6V), vielen Schnittstellen, in 44 - 100 poligen SMD-Gehäusen. Besonderheiten: ADC mit 2 Megasample/12 Bit, vierpoliges Programm- und Debug- Interface PDI (VTref, CLK, DATA, GND) erfordert z.B. einen AVR_JTAGICE-mkII Programmer. PDI (Flash und Debug) funktioniert mit C-Code z.B. mit AVR Studio 4.19.

Leider ist die Xmega-Reihe zu den AVR-Prozessoren der Mega- oder Tiny-Serien nicht kompatibel (viel komplizierter, anderer Aufbau der IO-Baugruppen, der Interrupts, der C-Funktionen etc.). Prozessor-Manuals zeigen weder Assembler noch C-Beispiele für Ansteuerung der IO-Baugruppen. C-Programmbeispiele (geeignet für AVR-Studio) findet man erst in Xmega Application Notes. Einen Überblick gibt [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial Florian Grotz].

== Sonstiges ==

Die AT89-Familie gehört nicht zu den AVR-Typen mit dem AVR-RISC-Befehlssatz, sondern ist eine [[8051|Intel-8051]]-kompatible 8-Bit µC-Serie.

=== Tiny vs Mega ===
Die modernen Typen sind die Tiny und die Mega. Die ATTiny haben kleinere Gehaeuse als die ATMega, mit weniger Pins. Dies fuehrt bei aehnlicher Funktionalitaet wie die Megas zu extremerer Mehrfachbelegungen der Pins und auch eher zu Ueberschneidungen der Pinfunktionalitaet. Die Tiny sind daher eher fuer sehr hohe Stueckzahlen geeignet, wo die Einsparung ueber die Stueckzahl kommt. Anfaenger und Bastler sind mit den ATMega besser bedient, da die weniger Limitationen besitzen.

==Nomenklatur==
===ATmega===
Auch wenn die Namensgebung auf den ersten Blick bedingt durch die vielen verfügbaren Modelle kompliziert aussieht, so folgt sie doch immer (von wenigen Ausnahmen abgesehen) einem einfachen Schema.

Nehmen wir einen aktuellen Baustein als Beispiel: *ATmega48PA-AU*. Der Name besteht aus 5 Teilen:
# Der Baureihe (hier: "ATmega")
# Einer Nummer, immer eine Zweierpotenz (hier: 4). Diese Zahl gibt die Größe des Flashspeichers in Kibibyte an.
# Bis zu zwei weiteren Ziffern (hier: 8). Sie definieren die Zusatzfunktionen sowie Zahl der I/O-Ports.
# Bis zu zwei Buchstaben (hier: PA), die für die Revision sowie spezielle stromsparende Architekturen stehen.
# Einem Bindestrich und zwei weiteren Buchstaben, die die Bauform angeben (hier: AU).

====Baureihe====

Hier gibt es nur zwei Reihen: Den kleinen ATtiny mit reduziertem Funktionsumfang und den großen ATmega.

====Speichergröße====

Während die Größe des Flashspeichers (Programmspeicher) direkt im Namen angegeben ist, ergibt sich die Größe von RAM und EEPROM nur indirekt aus dieser Nummer, wobei natürlich die Bausteine mit großem Flash auch mehr RAM und EEPROM haben als kleinere. Grob gilt diese Zuordnung:

{| class="wikitable"
|-
! Flash (kB) !! EEPROM (B) !! RAM (B)
|-
| 2 || tiny: 128 || tiny: 128
|-
| 4 || tiny: var., mega: 256 || tiny: 256, mega: 512
|-
| 8 || tiny: var., mega: 512 || tiny: 512, mega: 1024
|-
| 16 || 512 || 1024
|-
| 32 || 1024 || 2048
|-
| 64 || 2048*) || 4096*)
|-
| 128 - 256 || 4096 || 4K - 16K
|}
*)Atmega640 verfügt über den doppelten Speicher

====Zusatzfunktionen / Größe====
Die Ziffer(n) nach der Flashgröße geben die Ausstattungsmerkmale des Bausteins an. Die folgende Tabelle gilt für die Atmega-Reihe:
{| class="wikitable"
|-
! Ziffer !! Beschreibung
|-
| - || Keine Ziffer markiert die Bausteine der ersten Generation. Sie verfügen in der Regel über eine niedrigere maximale Taktrate (8/16 MHz anstatt 10/20 MHz), eine höhere Minimal-Spannung (2,7 anstatt 1,8 Volt), weniger Interrupt-Quellen und PWM-Kanäle
|-
| 0 || Reihe von 32 - 256 kB in einem größeren Gehäuse mit höherer Anzahl an I/O-Pins. Etwas älter als die aktuellen Reihen 4 und 8.
|-
| 1 || Kennzeichnet eine verbesserte Version des Atmega128 / 256, aber älter als aktuelle 4er Reihe
|-
| 4 || Reihe von 16 bis 128 kB Flash, alle pinkompatibel in 40-44 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART...
|-
| 5 || Reihe von 16 bis 64 kB
|-
| 8 || Reihe von 4 bis 32 kB, alle pinkompatibel in 28-32 poligem Gehäuse. Neueste Baureihe, alle in pico-power-Technologie mit vielen verbesserten Funktionen wie externen Interrupts, Timern, USART.... (auch in der Attiny-Reihe vorhanden)
|-
| 9 || Reihe von 16 bis 64 kB mit integriertem Controller für LC-Displays, folglich in großen Gehäusen (64-/100-polig)
|}
Aus dieser Liste stechen einige Bausteine als Außenseiter hervor:
* Atmega8515 / Atmega8535
* Atmega640: Im Prinzip ein Atmega64 mit deutlich mehr Hardware-Ressourcen (4 UARTs, 16 ADC-Kanäle...) und doppelt soviel EEPROM / SRAM.

====Revision / Architektur====
Die (optionalen) Buchstaben vor dem Bindestrich geben Auskunft über den Stromverbrauch und Spannungsbereich
{| class="wikitable"
|-
! Buchstabe !! Beschreibung
|-
| A || Zweite Revision - meist nur eine Umstellung der internen Strukturen ohne Auswirkung für den Benutzer
|-
| L / V || "Low-Voltage": Speziell für niedrigere Taktraten (8 bzw. 10 MHz) sowie niedrigere Eingangsspannungen (1,8 bzw. 2,7V) selektierte Bausteine
|-
| P/PA || "Pico-Power": Reduzierter Stromaufnahme, besonders in tiefen Sleep-Modes (< 1uA); Manche Bausteine (z.B. Mega48) gibt es als P und PA
|}

==== Bauform====
Die beiden Buchstaben nach dem Bindestrich geben Auskunft über die Bauform. Die Zahl der Pins des jeweiligen Gehäusetyps hängt vom Baustein ab.
{| class="wikitable"
|-
! Buchstaben !! Beschreibung
|-
| A || TQFP-Gehäuse
|-
| C || BGA-Gehäuse
|-
| I || Bleihaltig - nicht mehr erhältlich
|-
| J || PLCC-Gehäuse
|-
| M || (V)QFN- / MLF- Gehäuse
|-
| P || DIP-Gehäuse (bastlerfreundlich!)
|-
| S || SOIC-Gehäuse
|-
| U || Bleifrei, RoHS-kompatibel
|}

===ATtiny===
Bei den ATtiny-Bausteinen ist die Nummerierung deutlich unübersichtlicher als in der ATmega-Reihe. Die erste Ziffer gibt wie auch bei ATmega die Größe des Flash-Speichers an. Die obenstehenden Tabellen für Baureihe, Bauform, Revision und Speichergröße gelten ebenfalls (Ausnahmen: ATtiny5 mit 0,5 Kilobytes Flash sowie ATtiny4 und ATtiny9 mit 0,5 bzw. 1 kB Flash). Die Zusatzfunktionen und Baugröße sind aber nicht deutlich

== Vergleichstabelle(n) / Ausstattung ==
=== AT90S - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_AT90S"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform
|- 
|[http://www.atmel.com/dyn/resources/prod_documents/doc0839.pdf AT90S2313]<ref>veraltet → ATtiny2313</ref>
|2
|128
|128
|15
|10
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP20 SOIC20
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2323]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|3
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Nein
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc1004.pdf AT90S2343]<ref>veraltet → ATtiny25/45/85</ref>
|2
|128
|128
|5
|10
|2.7-6.0
|Nein
|0
|1
|Nein
|Ja
|0
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
|- 
|[http://www.atmel.com/atmel/acrobat/doc0841.pdf AT90S8515]<ref>veraltet → ATmega16/162/32/644</ref>
|8
|512
|512
|32
|8
|2.7-6.0
|Ja
|1
|1
|Nein
|Nein
|1 (16-Bit)
|Nein
|Nein
|Nein
|Ja
|Nein
|Ja
|Ja
|PDIP40 PLCC44 TQFP44


|}

=== ATtiny - Reihe ===
{| class="wikitable sortable" style="font-size:10px;" id="AVR_Features_ATtiny"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform(en)||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny11]
|1
| --
| --
|6
|6
|2.7-5.5
| --
|Ja
| --
|1
|Nein
|Nein
| --
|Nein
|Nein
|Nein
|Nein
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 0.58-0.87
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1006.pdf ATtiny12]
|1
|64
| --
|6
|8
|1.8-5.5
| --
|Ja
| --
|1
|Ja
|Ja
| --
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.00-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2535.pdf ATtiny13]
|1
|64
|64
|6
|20
|1.8-5.5
|4 10bit
|Ja
| --
|1
|Ja
|Ja
|1<ref>Timer-PWM</ref>
|Nein
|Ja
|Ja
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15-1.20
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc1187.pdf ATtiny15]
|1
|64
| --
|6
|1.6
|2.7-5.5
|4 10bit
|Ja
| --
|2
|Ja
|ONLY
|1<ref>150kHz 8bit</ref>
|Nein
|Nein
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 1.15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2543.pdf ATtiny2313]
|2
|128
|128
|15
|20
|1.8-5.5
| --
|Ja
|1
|1
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Ja<ref name="usart">USART</ref>
|Ja
|PDIP20 SOIC20 QFN20 MLF20
| 1.30
|-
|[http://atmel.com/dyn/resources/prod_documents/doc8006.pdf ATtiny24]
|2
|128
|128
|12
|20
|1.8-5.5
|8 10bit
|Ja
|Ja
|Ja
|Ja
|Ja
|4
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP14 SOIC14 QFN20/MLF20
|1.45
|-
|[http://atmel.com/dyn/resources/prod_documents/doc2588.pdf ATtiny261]
|2
|128
|128
|16
|20
|1,8-5,5
|11
|1
|1
|1
|Ja
|Ja
|2
|Nein
|Ja
|Ja
|Ja<ref name="usip">+USI</ref>
|Ja<ref name="usi">USI</ref>
|Nein
|Ja
|PDIP20 SOIC20 MLF20
|1,15
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf ATtiny85]
|8
|512
|512
|6
|20
|1.8-5.5
|4
|Ja
| --
|2
|Ja
|Ja
|4
|Nein
|Ja
|Nein
|Ja
|Nein
|Nein
|Ja
|PDIP8 SOIC8
| 2
|}

=== ATmega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATMega"
|-
!Typ||Flash (Kbytes)||EEPROM (Bytes)||SRAM (Bytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||A/D Channels||Analog Comparator||16-bit Timer||8-bit Timer||Brown Out Detector||On Chip Oscillator||PWM Channels||RTC||Self Program Memory||Boot Code||SPI||TWI (I2C)||UART||Watchdog||Bauform||Preis<ref name="preis"/>
|-
|[http://www.atmel.com/dyn/resources/prod_documents/2486S.pdf ATmega8]
|8
|512
|1K
|23
|16
|2.7-5.5
|6 10bit PDIP 8 10bit TQFP QFN/MLF
|Ja
|1
|2
|Ja
|Ja
|3
|Ja
|Ja
|Ja
|Ja
|Ja
|Ja USART
|Ja
|PDIP28 TQFP32 QFN/MLF32
| 1.70-1.90
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf ATmega16]
|16
|512
|1K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.60-2.85
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2513.pdf ATmega162]
|16
|512
|1K
|35
|16
|2.7-5.5
|Keine
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 2.70-3.80
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2503.pdf ATmega32]
|32
|1K
|2K
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|4
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 3.20-4.60
|-
|[http://www.atmel.com/atmel/acrobat/doc2490.pdf ATmega64]<ref>Geliefert im ATmega103-Modus. Fuse ändern!</ref>
|64
|2K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit, 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
| TQFP64 QFN/MLF64
| 7.50-9.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2593.pdf ATmega644]
|64
|2K
|4K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref> 2<ref>beim 644P</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
| 6.80-7.50
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2467.pdf ATmega128]
|128
|4K
|4K
|53
|16
|2.7-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|2 8bit 6 2-16bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|TQFP64 QFN/MLF64
|8.05-8.40
|-
|[http://www.atmel.com/dyn/products/product_card.asp?part_id=4331 ATmega1284P]
|128
|4K
|16K
|32
|20
|1.8-5.5
|8 10bit
|Ja
|2
|2
|Ja
|Ja
|6
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|2<ref name="usart">USART</ref>
|Ja
|PDIP40 TQFP44 QFN/MLF44
|(6-8 EUR)
|-
|[http://www.atmel.com/dyn/resources/prod_documents/doc2549.pdf ATmega2560]
|256
|4K
|8K
|86
|16
|2.7-5.5
|16 10bit
|Ja
|4
|2
|Ja
|Ja
|16
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|4<ref name="usart">USART</ref>
|Ja
|TQFP100
|8-15
|-
|[http://www.atmel.com/atmel/acrobat/doc2512.pdf ATmega8515]
|8
|512
|512
|35
|16
|2.7-5.5
|Keine
|Ja
|1
|1
|Ja
|Ja
|1 8-bit, 1 16-bit
|Nein
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Nein
|1<ref name="usart">USART</ref>
|Ja
|PDIP20 TQFP44 PLCC44 QFN/MLF44
|3.20-3.90
|-
|[http://www.atmel.com/atmel/acrobat/doc2502.pdf ATmega8535]
|8
|512
|512
|32
|16
|2.7-5.5
|8 10bit
|Ja
|1
|2
|Ja
|Ja
|2 8-bit, 2 16-bit
|Ja
|Ja
|Ja
|Ja<ref name="ms">Master/Slave</ref>
|Ja
|1<ref name="usart">USART</ref>
|Ja
|PDIP44 PLCC44 QFN/MLF44
|3.15-3.75



|}

=== ATXMega - Reihe ===
{| class="wikitable sortable" style="font-size: 10px;" id="AVR_Features_ATXMega"
|-
!Typ||Flash (Kbytes)||EEPROM (KBytes)||SRAM (KBytes)||Boot (Kbytes)||Max I/O Pins||F.max (MHz)||Vcc (V)||ADC||DAC||PWM Channels||16-Bit Timer||SPI||TWI (I2C)||UART||Bauformen
|-
|ATxmega16a4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega32a4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega128a4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|2-CH @ 12-Bit
|16
|5
|2
|2
|5
|TQFP44
|-
|ATxmega64a3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega128a3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega192a3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega256a3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2-CH @ 12-Bit
|22
|7
|3
|2
|7
|TQFP64
|-
|ATxmega64a1
|64
|2
|4
|4
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega128a1
|128
|2
|8
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega192a1
|192
|2
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega256a1
|256
|4
|16
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega384a1
|384
|4
|32
|8
|78
|32
|1,6 - 3,6
|2x 8-CH @ 12-Bit
|2x 2-CH @ 12-Bit
|24
|8
|4
|4
|8
|TQFP100
|-
|ATxmega16d4
|16
|1
|2
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega32d4
|32
|1
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d4
|64
|2
|4
|4
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega128d4
|128
|2
|8
|8
|34
|32
|1,6 - 3,6
|12-CH @ 12-Bit
|0
|16
|4
|2
|2
|2
|TQFP44
|-
|ATxmega64d3
|64
|2
|4
|4
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega128d3
|128
|2
|8
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega192d3
|192
|2
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|-
|ATxmega256d3
|256
|4
|16
|8
|50
|32
|1,6 - 3,6
|16-CH @ 12-Bit
|0
|18
|5
|2
|2
|3
|TQFP64
|}

== Weitere Vergleichstabellen ==

=== ATtiny ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Hardware Qtouch
! Max I/O Pins
! Ext Interrupts
! SPI
! TWI
! UART
! LIN
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATtiny28L''' || 2 || 28 || 4 || — || — || 11 || 10 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 0 || 0 || 0 || — || '''ATtiny28L'''
|-
| '''ATtiny26''' || 2 || 20 || 16 || — || — || 16 || 11 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || — || 0.12 || 128 || — || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 0 || 4 || — || '''ATtiny26'''
|-
| '''ATtiny13''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13'''
|-
| '''ATtiny2313''' || 2 || 20 || 20 || 4 || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313'''
|-
| '''ATtiny25''' || 2 || 8 || 20 || 4 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny25'''
|-
| '''ATtiny85''' || 8 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny85'''
|-
| '''ATtiny45''' || 4 || 8 || 20 || 3 || — || 6 || 6 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 5 || 0 || 6 || — || '''ATtiny45'''
|-
| '''ATtiny24''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24'''
|-
| '''ATtiny44''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44'''
|-
| '''ATtiny84''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84'''
|-
| '''ATtiny261''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261'''
|-
| '''ATtiny461''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461'''
|-
| '''ATtiny861''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861'''
|-
| '''ATtiny13A''' || 1 || 8 || 20 || — || — || 6 || 6 || 0 || 0 || 0 || 0 || 4 || 10 || 15 || — || 0.06 || 64 || √ || √ || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 0 || 2 || — || '''ATtiny13A'''
|-
| '''ATtiny48''' || 4 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny48'''
|-
| '''ATtiny88''' || 8 || 32 || 12 || 12 || — || 28 || 28 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 64 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny88'''
|-
| '''ATtiny24A''' || 2 || 14 || 20 || 4 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny24A'''
|-
| '''ATtiny44A''' || 4 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny44A'''
|-
| '''ATtiny43U''' || 4 || 20 || 8 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 4 || 10 || 15 || √ || 0.25 || 64 || √ || √ || −40 – 85 || 0.7 – 5.5 || 0.7 – 5.5 || 2 || 4 || 0 || 4 || — || '''ATtiny43U'''
|-
| '''ATtiny10''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny10'''
|-
| '''ATtiny4''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny4'''
|-
| '''ATtiny5''' || 0.5 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 4 || 8 || 15 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny5'''
|-
| '''ATtiny9''' || 1 || 6 || 12 || 1 || — || 4 || 4 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.03 || 0 || — || — || −40 – 125 || 1.8 – 5.5 || 1.8 – 5.5 || 1 || 2 || 1 || 2 || — || '''ATtiny9'''
|-
| '''ATtiny261A''' || 2 || 20 || 20 || 4 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.12 || 128 || √ || √ || −40 – 105 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny261A'''
|-
| '''ATtiny461A''' || 4 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny461A'''
|-
| '''ATtiny861A''' || 8 || 20 || 20 || 8 || — || 16 || 16 || 1 || 1 || 0 || 0 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 6 || 1 || 6 || — || '''ATtiny861A'''
|-
| '''ATtiny2313A''' || 2 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.12 || 128 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny2313A'''
|-
| '''ATtiny4313''' || 4 || 20 || 20 || — || — || 18 || 18 || 2 || 1 || 1 || 0 || 0 || 0 || 15 || — || 0.25 || 256 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny4313'''
|-
| '''ATtiny167''' || 16 || 20 || 16 || 8 || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny167'''
|-
| '''ATtiny87''' || 8 || 20 || 16 || — || — || 16 || 16 || 2 || 1 || 1 || 1 || 11 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 3 || 1 || 9 || √ || '''ATtiny87'''
|-
| '''ATtiny20''' || 2 || 14 || 12 || 5 || √ || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.12 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 3 || — || '''ATtiny20'''
|-
| '''ATtiny40''' || 4 || 20 || 12 || 12 || √ || 18 || 18 || 1 || 1 || 0 || 0 || 12 || 10 || 15 || √ || 0.25 || 0 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 2 || — || '''ATtiny40'''
|-
| '''ATtiny84A''' || 8 || 14 || 20 || 6 || — || 12 || 12 || 1 || 1 || 0 || 0 || 8 || 10 || 15 || √ || 0.5 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 2 || 4 || 1 || 4 || — || '''ATtiny84A'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''USB Transceiver''' || 0
|-
| '''USB Speed''' || nein
|-
| '''USB Interface''' || nein
|-
| '''CAN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Segment LCD''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Analog Comparators''' || 1
|-
| '''Resistive Touch Screen''' || nein
|-
| '''DAC Kanäle''' || 0
|-
| '''DAC Auflösung [bits]''' || 0
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! Max. &fnof;CPU [MHz]
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! CAN
! LIN
! Segment LCD
! ADC Kanäle
! ADC Auflösung [bits]
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! Temp. Sensor
! SRAM [KiB]
! EEPROM [Bytes]
! Self Program Memory
! picoPower
! Temp. Bereich [°C]
! I/O Supply Class [V]
! Operating Voltage [VCC]
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! 32kHz RTC
! Device
|-
| '''ATmega8''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 3 || 1 || 3 || √ || '''ATmega8'''
|-
| '''ATmega8515''' || 8 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 3 || 1 || 3 || — || '''ATmega8515'''
|-
| '''ATmega8535''' || 8 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega8535'''
|-
| '''ATmega16''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16'''
|-
| '''ATmega32''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32'''
|-
| '''ATmega64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64'''
|-
| '''ATmega128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128'''
|-
| '''ATmega162''' || 16 || 44 || 16 || 16 || 35 || 3 || 0 || — || — || 1 || 0 || 2 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 4 || 6 || 2 || 6 || √ || '''ATmega162'''
|-
| '''ATmega48''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48'''
|-
| '''ATmega88''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88'''
|-
| '''ATmega168''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168'''
|-
| '''AT90CAN128''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN128'''
|-
| '''ATmega325''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325'''
|-
| '''ATmega3250''' || 32 || 100 || 16 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250'''
|-
| '''ATmega6450''' || 64 || 100 || 16 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450'''
|-
| '''ATmega645''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645'''
|-
| '''ATmega329''' || 32 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329'''
|-
| '''ATmega3290''' || 32 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290'''
|-
| '''ATmega649''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649'''
|-
| '''ATmega6490''' || 64 || 100 || 16 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490'''
|-
| '''ATmega640''' || 64 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega640'''
|-
| '''ATmega1281''' || 128 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega1281'''
|-
| '''ATmega2561''' || 256 || 64 || 16 || — || 54 || 17 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 2 || 8 || √ || '''ATmega2561'''
|-
| '''ATmega2560''' || 256 || 100 || 16 || — || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega2560'''
|-
| '''ATmega1280''' || 128 || 100 || 16 || 16 || 86 || 32 || 0 || — || — || 5 || 1 || 4 || 0 || 0 || 0 || 16 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 6 || 16 || 4 || 15 || √ || '''ATmega1280'''
|-
| '''ATmega644''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644'''
|-
| '''AT90CAN32''' || 32 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN32'''
|-
| '''AT90CAN64''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 1 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''AT90CAN64'''
|-
| '''AT90USB1286''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1286'''
|-
| '''AT90USB1287''' || 128 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 8 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB1287'''
|-
| '''AT90USB647''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbo">Device + OTG</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB647'''
|-
| '''AT90USB646''' || 64 || 64 || 16 || 16 || 48 || 16 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 10 || 1 || 9 || √ || '''AT90USB646'''
|-
| '''ATmega164P''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164P'''
|-
| '''ATmega324P''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324P'''
|-
| '''ATmega165P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165P'''
|-
| '''ATmega169P''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169P'''
|-
| '''ATmega644P''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644P'''
|-
| '''AT90PWM1''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM1'''
|-
| '''ATmega329P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329P'''
|-
| '''ATmega3290P''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290P'''
|-
| '''ATmega325P''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325P'''
|-
| '''ATmega3250P''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250P'''
|-
| '''AT90USB82''' || 8 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB82'''
|-
| '''AT90USB162''' || 16 || 32 || 16 || — || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''AT90USB162'''
|-
| '''AT90PWM216''' || 16 || 24 || 16 || 12 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM216'''
|-
| '''AT90PWM316''' || 16 || 32 || 16 || 12 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 1 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM316'''
|-
| '''ATmega48P''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48P'''
|-
| '''ATmega88P''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88P'''
|-
| '''ATmega168P''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168P'''
|-
| '''ATmega328P''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328P'''
|-
| '''AT90PWM3B''' || 8 || 32 || 16 || 8 || 27 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 5 || 16 || 1 || 12 || — || '''AT90PWM3B'''
|-
| '''AT90PWM2B''' || 8 || 24 || 16 || 8 || 19 || 4 || 0 || — || — || 1 || 0 || 1 || 0 || 0 || 0 || 8 || 10 || 125 || 2 || 1 || 10 || — || 0.5 || 512 || √ || — || −40 – 105 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 1 || 7 || — || '''AT90PWM2B'''
|-
| '''ATmega32U4''' || 32 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 2.5 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega32U4'''
|-
| '''ATmega1284P''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284P'''
|-
| '''ATmega16U4''' || 16 || 44 || 16 || 14 || 26 || 13 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 0 || 0 || 0 || 12 || 10 || 15 || 1 || 0 || 0 || √ || 1.25 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 12 || 2 || 8 || — || '''ATmega16U4'''
|-
| '''ATmega16A''' || 16 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega16A'''
|-
| '''ATmega32A''' || 32 || 44 || 16 || 16 || 32 || 3 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega32A'''
|-
| '''ATmega88PA''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88PA'''
|-
| '''ATmega324PA''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324PA'''
|-
| '''ATmega48PA''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48PA'''
|-
| '''ATmega164PA''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164PA'''
|-
| '''ATmega64A''' || 64 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega64A'''
|-
| '''ATmega128A''' || 128 || 64 || 16 || 16 || 53 || 8 || 0 || — || — || 1 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 4096 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 4 || 8 || 2 || 7 || √ || '''ATmega128A'''
|-
| '''ATmega8A''' || 8 || 32 || 16 || 12 || 23 || 2 || 0 || — || — || 1 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 3 || — || — || 3 || √ || '''ATmega8A'''
|-
| '''ATmega168PA''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168PA'''
|-
| '''ATmega8U2''' || 8 || 32 || 16 || — || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega8U2'''
|-
| '''ATmega16U2''' || 16 || 32 || 16 || 12 || 22 || 21 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 0.5 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega16U2'''
|-
| '''ATmega32U2''' || 32 || 32 || 16 || 12 || 22 || 20 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || — || 1 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 5 || 1 || 4 || — || '''ATmega32U2'''
|-
| '''ATmega644PA''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644PA'''
|-
| '''ATmega16M1''' || 16 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 1 || 512 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega16M1'''
|-
| '''ATmega32M1''' || 32 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 2 || 1024 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega32M1'''
|-
| '''ATmega64M1''' || 64 || 32 || 16 || 12 || 27 || 27 || 0 || — || — || 1 || 0 || 1 || 1 || 1 || 0 || 11 || 10 || 125 || 4 || 1 || 10 || √ || 4 || 2048 || √ || — || −40 – 85 || 2.7 – 5.5 || 2.7 – 5.5 || 2 || 14 || 1 || 10 || — || '''ATmega64M1'''
|-
| '''ATmega169PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169PA'''
|-
| '''ATmega48A''' || 4 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 0.5 || 256 || — || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega48A'''
|-
| '''ATmega88A''' || 8 || 32 || 20 || 12 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega88A'''
|-
| '''ATmega168A''' || 16 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega168A'''
|-
| '''ATmega328''' || 32 || 32 || 20 || 16 || 23 || 24 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || √ || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega328'''
|-
| '''ATmega164A''' || 16 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega164A'''
|-
| '''ATmega324A''' || 32 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega324A'''
|-
| '''ATmega644A''' || 64 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega644A'''
|-
| '''ATmega1284''' || 128 || 44 || 20 || 16 || 32 || 32 || 0 || — || — || 3 || 1 || 2 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 16 || 4096 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 6 || 1 || 6 || √ || '''ATmega1284'''
|-
| '''AT90PWM81''' || 8 || 20 || 16 || — || 20 || 3 || 0 || — || — || 1 || 0 || 0 || 0 || 0 || 0 || 11 || 10 || 125 || 3 || 1 || 10 || √ || 0.25 || 512 || √ || — || −40 – 125 || 2.7 – 5.5 || 2.7 – 5.5 || 1 || 8 || 1 || 6 || — || '''AT90PWM81'''
|-
| '''ATmega165PA''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega165PA'''
|-
| '''ATmega325A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega325A'''
|-
| '''ATmega3250A''' || 32 || 100 || 20 || 16 || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3250A'''
|-
| '''ATmega645A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645A'''
|-
| '''ATmega645P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega645P'''
|-
| '''ATmega6450P''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450P'''
|-
| '''ATmega6450A''' || 64 || 100 || 20 || — || 69 || 25 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 0 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6450A'''
|-
| '''ATmega169A''' || 16 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 1 || 512 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega169A'''
|-
| '''ATmega329A''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329A'''
|-
| '''ATmega649A''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649A'''
|-
| '''ATmega3290A''' || 32 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega3290A'''
|-
| '''ATmega649P''' || 64 || 64 || 16 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega649P'''
|-
| '''ATmega6490A''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || — || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490A'''
|-
| '''ATmega6490P''' || 64 || 100 || 20 || 16 || 69 || 32 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 160 || 8 || 10 || 15 || 1 || 0 || 0 || — || 4 || 2048 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega6490P'''
|-
| '''ATmega329PA''' || 32 || 64 || 20 || 16 || 54 || 17 || 0 || — || — || 2 || 1 || 1 || 0 || 0 || 100 || 8 || 10 || 15 || 1 || 0 || 0 || — || 2 || 1024 || √ || √ || −40 – 85 || 1.8 – 5.5 || 1.8 – 5.5 || 3 || 4 || 1 || 4 || √ || '''ATmega329PA'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''Resistive Touch Screen''' || nein
|-
| '''External Bus Interface''' || 0
|-
| '''DRAM Memory''' || nein
|-
| '''NAND Interface''' || nein
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''Crypto Engine''' || nein
|-
| '''Calibrated RC Oscillator''' || ja
|}

=== ATxmega ===

{| class="wikitable"
|+ '''Device-specific Features'''  
|- valign="top"
! Device
! Flash [KiB]
! Pin Anzahl
! of Touch Kanäle
! Max I/O Pins
! Ext Interrupts
! USB Transceiver
! USB Speed
! USB Interface
! SPI
! TWI
! UART
! Segment LCD
! ADC Kanäle
! ADC Speed [ksps]
! Analog Comparators
! DAC Kanäle
! DAC Auflösung [bits]
! SRAM [KiB]
! EEPROM [Bytes]
! External Bus Interface
! DRAM Memory
! Crypto Engine
! Timers
! Output Compare Kanäle
! Input Capture Kanäle
! PWM Kanäle
! Device
|-
| '''ATxmega64A1''' || 64 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 4 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega64A1'''
|-
| '''ATxmega128A1''' || 128 || 100 || 16 || 78 || 78 || 0 || — || — || 12 || 4 || 8 || 0 || 16 || 2000 || 4 || 4 || 12 || 8 || 2048 || 1 || ja<ref name="sdram">SDRAM</ref> || ja<ref name="cry">AES/DES</ref> || 8 || 24 || 24 || 24 || '''ATxmega128A1'''
|-
| '''ATxmega64A3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3'''
|-
| '''ATxmega128A3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3'''
|-
| '''ATxmega192A3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3'''
|-
| '''ATxmega256A3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3'''
|-
| '''ATxmega16A4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4'''
|-
| '''ATxmega32A4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4'''
|-
| '''ATxmega64A4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega64A4'''
|-
| '''ATxmega128A4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega128A4'''
|-
| '''ATxmega256A3B''' || 256 || 64 || 16 || 47 || 49 || 0 || — || — || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3B'''
|-
| '''ATxmega256D3''' || 256 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 4096 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega256D3'''
|-
| '''ATxmega192D3''' || 192 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 16 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega192D3'''
|-
| '''ATxmega128D3''' || 128 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega128D3'''
|-
| '''ATxmega64D3''' || 64 || 64 || 16 || 50 || 50 || 0 || — || — || 5 || 2 || 3 || 0 || 16 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 5 || 18 || 18 || 18 || '''ATxmega64D3'''
|-
| '''ATxmega128D4''' || 128 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 8 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega128D4'''
|-
| '''ATxmega64D4''' || 64 || 44 || — || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 2048 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega64D4'''
|-
| '''ATxmega32D4''' || 32 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 4 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega32D4'''
|-
| '''ATxmega16D4''' || 16 || 44 || 16 || 34 || 34 || 0 || — || — || 4 || 2 || 2 || 0 || 12 || 200 || 2 || 0 || 0 || 2 || 1024 || 0 || — || — || 4 || 14 || 14 || 14 || '''ATxmega16D4'''
|-
| '''ATxmega16A4U''' || 16 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 3.3 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega16A4U'''
|-
| '''ATxmega32A4U''' || 32 || 44 || 16 || 34 || 34 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 7 || 2 || 5 || 0 || 12 || 2000 || 2 || 2 || 12 || 4 || 1024 || 0 || — || ja<ref name="cry">AES/DES</ref> || 5 || 16 || 16 || 16 || '''ATxmega32A4U'''
|-
| '''ATxmega64A3U''' || 64 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega64A3U'''
|-
| '''ATxmega128A3U''' || 128 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega128A3U'''
|-
| '''ATxmega192A3U''' || 192 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega192A3U'''
|-
| '''ATxmega256A3U''' || 256 || 64 || 16 || 50 || 50 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 10 || 2 || 7 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3U'''
|-
| '''ATxmega256A3BU''' || 256 || 64 || 16 || 47 || 49 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 8 || 2 || 6 || 0 || 16 || 2000 || 4 || 2 || 12 || 16 || 4096 || 0 || — || ja<ref name="cry">AES/DES</ref> || 7 || 22 || 22 || 22 || '''ATxmega256A3BU'''
|-
| '''ATxmega64B3''' || 64 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega64B3'''
|-
| '''ATxmega128B3''' || 128 || 64 || 16 || 36 || 36 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 2 || 1 || 1 || 100 || 8 || 2000 || 2 || 0 || 0 || 4 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 2 || 6 || 6 || 6 || '''ATxmega128B3'''
|-
| '''ATxmega128B1''' || 128 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega128B1'''
|-
| '''ATxmega64B1''' || 64 || 100 || 16 || 53 || 53 || 1 || ja<ref name="usbs">Full Speed</ref> || ja<ref name="usbd">Device</ref> || 3 || 1 || 2 || 160 || 16 || 2000 || 4 || 0 || 0 || 8 || 2048 || 0 || — || ja<ref name="cry">AES/DES</ref> || 3 || 10 || 10 || 10 || '''ATxmega64B1'''
|}

{| class="wikitable"
|+ '''General Features'''  
|-
| '''Max. &fnof;CPU [MHz]''' || 32
|-
| '''CPU''' || 8-bit AVR
|-
| '''Hardware Qtouch''' || nein
|-
| '''Quadrature Decoder Kanäle''' || 0
|-
| '''CAN''' || 0
|-
| '''LIN''' || 0
|-
| '''SSC''' || 0
|-
| '''Ethernet''' || 0
|-
| '''SD / eMMC''' || 0
|-
| '''Grafik LCD''' || nein
|-
| '''Video Decoder''' || nein
|-
| '''Kamera Interface''' || nein
|-
| '''ADC Auflösung [bits]''' || 12
|-
| '''Resistive Touch Screen''' || nein
|-
| '''Temp. Sensor''' || ja
|-
| '''Self Program Memory''' || ja
|-
| '''NAND Interface''' || nein
|-
| '''picoPower''' || ja
|-
| '''Temp. Bereich [°C]''' || −40 – 85
|-
| '''I/O Supply Class [V]''' || 1.6 – 3.6
|-
| '''Operating Voltage [VCC]''' || 1.6 – 3.6
|-
| '''FPU''' || nein
|-
| '''MPU / MMU''' || nein / nein
|-
| '''32kHz RTC''' || ja
|-
| '''Calibrated RC Oscillator''' || ja
|}

== Referenzen ==
<references/>

== Weblinks ==

* [http://www.avrfreaks.net/index.php?module=Freaks%20Devices&func=devCompare Vergleichstabelle] von AVRFreaks
* [http://www.atmel.com/dyn/products/param_table.asp?family_id=607&OrderBy=part_no&Direction=ASC#760 Vergleichstabelle aller aktuellen AVR Controller bei Atmel]

[[Category:AVR]]