ATtiny

Der ATtiny wird oft als alternativer Mikrocontroller zum ATMega (z.B. Arduino UNO) oder ESP32 verwendet, wenn Platz bzw. Stromkapazität limitiert sind (z.B. batteriebetriebene Projekte). Die ATtiny-Familie besitzt etliche Typen an Controllern, die beliebtesten sind der ATtiny84A und der ATtiny85. Sie unterscheiden sich nur durch die Anzahl ihrer Pins und damit durch die Anzahl ihrer Ein- und Ausgänge.

Atmel ATtiny85 DIP-8
Abb.: Der Atmel ATtiny85 als DIP8-Version

ATtiny84A und ATtiny85 laufen im Auslieferungszustand mit 1 MHz. Der Takt kann auf bis zu 16 MHz (mehr als 3,3V) erhöht werden, mit einem externen Taktgeber sind auch 20 MHz möglich. Bei einem Takt von 1 MHz -ausreichend für die meisten Anwendungen- arbeiten die Chips in einem Spannungsbereich von 1,8V bis 5,5V. Laut Datenblatt kommen sie mit 300µA im Betrieb aus, im Tiefschlaf (Sleep-Mode) sogar nur mit 0,1µA (bei 1,8V). Dies sind theoretisch erreichbare Werte, die bisher nicht messen konnte.

Der ATtiny85 hat 8 Pins, wobei Pin 8 (als VCC), Pin 4 (als GND) und Pin 1 (als RESET) reserviert sind. Damit bleiben 5 GPIO-Pins für eigene Anwendungen übrig, wobei 3 davon als Analog-Digitalwandler genutzt werden können.
Mehr Auswahlmöglichkeiten für die Pinbelegung bringt der große ATtiny84 mit. Er hat 14 Pins, abzüglich GND, VCC und RESET, womit 11 GPIOs zur freien Verfügung stehen. 8 davon dienen auch als Analog-Digitalwandler.

Etlichen der ICs aus der ATtiny-Familie fehlt -im Gegensatz zu dem ATmega- ein Hardwaremultiplizierer, d.h. jede Multiplikation muss also in der Software ausgeführt werden!

Vergleich einiger ATtiny-Typen

In der Bezeichnung der ATtiny-Typen kann man anhand der Zahlen zwei Spezifikationen herauslesen: die erste Zahl nach dem "ATtiny" steht für die Anzahl Kilobytes (also 1, 2, 4 und 8), die zweite Zahl gibt die Anzahl der Pins an (x4 = 14Pin, x5 = 8Pin).

MCU-Typ Spannungsversorgung Taktfrequenz Flash EEPROM SRAM GPIO-Pins
ATtiny13A 1,8V - 5,5V 0–4MHz bei 1,8V – 5,5V
0–10MHz bei 2,7V – 5,5V
0–20MHz bei 4,5V – 5,5V
1kB 64Bytes 64Bytes 5
ATtiny84A 1,8V - 5,5V 0–4MHz bei 1,8V – 5,5V
0–10MHz bei 2,7V – 5,5V
0–20MHz bei 4,5V – 5,5V
8kB 512Bytes 512Bytes 11
ATtiny85 2,7V - 5,5V 0–10MHz bei 2,7V - 5,5V
0-20MHz bei 4,5V - 5,5V
8kB 512Bytes 512Bytes 5
ATtiny85V 1,8V - 5,5V 0–4MHz bei 1,8V - 5,5V
0-10MHz bei 2,7V - 5,5V
8kB 512Bytes 512Bytes 5

Verwendbare Klassen/Funktionen

Will man nicht nur in reinem C programmieren, sondern mit den Arduino-Funktionen arbeiten, so kann man die folgenden Klassen/Funktionen auch auf dem ATtiny weiterhin benutzen.
Hinweis: Nicht alle zeitabhängigen Funktionen, wie z.B. delayMicroseconds() arbeiten mit allen Taktfrequenzen des ATtiny korrekt!

Taktfrequenzen

Die meisten ATTiny-Typen können in verschiedenen Taktfrequenzen arbeiten 1MHz (Auslieferungszustand), 8MHz oder 16MHz. Mit einem externen Oszillator (Quarz) bis zu 20MHz (Diese Option wird hier nicht besprochen). Höhere Frequenzraten verbrauchen zwar entsprechend mehr Strom sind aber für manche Anwendungen sinnvoll oder sogar unerläßlich. Um den ATtiny beispielsweise für 8MHz zu konfigurieren, wählt man in der Arduino IDE die Option Werkzeuge » Clock » Internal 8 MHz aus. Nun wählt man Werkzeuge » Bootloader brennen und wartet, bis der Vorgang beendet wurde. Hierbei wird kein Bootloader auf den ATtiny geschrieben, sondern lediglich die sog. Fuses gesetzt, die in diesem Fall die Taktfrequenz auf 8MHz ändern. Nun kann der gewünschte mit der 8MHz-Option auf den ATtiny geladen werden.

Anschlüsse

Anschlüsse des ATtiny13A
Anschlüsse des ATtiny24/44/84
Anschlüsse des ATtiny25/45/85

Verwendete Bauteile

Programmierung

Da der ATtiny nicht Teil eines Entwicklungs-Boards wie der Arduino ist, sondern als blanker IC ausgeliefert wird, so muss bei der Programmierung mit einem ISP ("In-System-Programmer") gearbeitet werden, der über SPI mit dem ATtiny-Mikrocontroller kommuniziert.
Solche ISPs gibt es günstig zu kaufen (Suchbegriff "ISP AVR"). Eine andere Möglichkeit ist es, einen Arduino Uno (oder einen kompatiblen Clone) als ISP zu verwenden. Die letztere Möglichkeit wird im Folgenden vorgestellt:

Arduino Uno als ISP programmieren

Zunächst wird der Arduino Uno von allen Verbindungen an seinen GPIOs gelöst und per USB mit dem PC verbunden. Nun lädt man in der Arduino-IDE über den Menüpunkt Datei » Beispiele » 11.ArduinoISP den Sketch ArduinoISP. Dieser wird kompiliert und auf den Arduino hochgeladen. (Darauf achten, dass im Menüpunkt Werkzeuge » Programmer "AVRISP mkII" ausgwählt ist
Den Sketch gibt es hier auch noch alternativ zum Herunterladen:

ArduinoISP.ino [8 kB]

Arduino als ISP aufbauen

Je nachdem, welcher ATtiny-Typ programmiert werden soll, wird einer der folgenden Schaltungen verwendet:

Aufbau zur Programmierung eines ATtiny84 mit dem Arduino Uno als ISP
Abb.: Aufbau zur Programmierung eines ATtiny84 mit dem Arduino Uno als ISP
Aufbau zur Programmierung eines ATtiny85 mit dem Arduino Uno als ISP
Abb.: Aufbau zur Programmierung eines ATtiny85 mit dem Arduino Uno als ISP
PinATtiny84 PinATtiny85 PinArduino Uno
1 8 5V (VCC)
14 4 GND
4 1 10
7 5 11
8 6 12
9 7 13

Wichtig: Den 10µF Elektrolytkondensator zwischen RESET und GND beim Arduino nicht vergessen!

ATtiny als Board auswählen

Damit nun der ATtiny als Board ausgewählt und verwendet werden kann, muss zunächst eine zusätzliche Konfiguration für den Board-Manager vorgenommen werden:
Im Menüpunkt Datei » Voreinstellungen wird im Feld Zusätzliche Boardverwalter-URLs folgende URL hinzugefügt (kann zu evtl. anderen vorhandenen URL mit einem Komma separatiert werden):
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Im Menüpunkt Werkzeuge » Board » Boardverwalter muss nun in der Liste nach dem "attiny by David A. Mellis" gesucht werden und dies wird dann installiert:

Boardverwalter attiny installieren
Abb.: Der Boardverwalter "attiny" wird installiert

Nun kann das entsprechende Board im Menüpunkt Werkzeuge » Board mit seinen Konfigurationen eingestellt werden:

Board auswählen
Abb.: Das gewünschte ATtiny-Board wird in der Arduino-IDE ausgewählt.
Board konfigurieren
Abb.: Das gewünschte ATtiny-Board wird in der Arduino-IDE konfiguriert.

Nun wird im Menüpunkt Werkzeuge » Programmer noch von "AVRISP mkII" zu "Arduino as ISP" umgeschaltet, damit nicht der Arduino selbst beschrieben wird, sondern das Ziel-Board: der ATtiny.

Nun sind alle Vorbereitungen getroffen und der ATtiny kann wie der Arduino programmiert werden.

Bei Verwendung eines ATtiny13 bzw. ATtiny13A wird noch zusätzlich die Board-URL hinzugefügt:
https://mcudude.github.io/MicroCore/package_MCUdude_MicroCore_index.json
Im Menüpunkt Werkzeuge » Board » Boardverwalter wird nach "MicroCore by MCUdude" gesucht dann installiert.

Schaltung mit dem ATtiny84A

Sketch

Die Test-Schaltung soll 5 LEDs in verschiedenen Takt-Zyklen blinken lassen (300ms, 600ms, 900ms, 1200ms und 1800ms). Dafür werden die Arduino-Pins 6, 7, 8, 9 und 10 auf dem ATtiny84A verwendet.

#define AMOUNT_LEDS 5

const byte leds[AMOUNT_LEDS] = {10, 9, 8, 7, 6};
unsigned long lastAction[AMOUNT_LEDS];

void setup()
{
    for(byte i=0; i<AMOUNT_LEDS; i++) {
        pinMode(leds[i], OUTPUT);
        lastAction[i] = 0;
    }
}

void loop()
{
    for (byte i=0; i<AMOUNT_LEDS; i++) {
        if (millis()-lastAction[i] > (i+1)*300) {
            lastAction[i] = millis();
            digitalWrite(leds[i], !digitalRead(leds[i]));
        }
    }
}

Der ATtiny84A wird nun in den ISP-Aufbau gesetzt und der Sketch wie gehabt kompiliert und hochgeladen.

Aufbau der Schaltung

Nun kann der ATtiny84A dem Programmier-Aufbau entnommen und in die folgende Schaltung eingesetzt werden:

Aufbau für den Test-Sketch des ATtiny84A
Abb.: Aufbau der Test-Schaltung für den ATtiny84A

Resultat

So (oder so ähnlich) sollte dann die fertige Schaltung mit dem programierten ATtiny84A aussehen. Statt einem 18650-LiPo habe ich eine CR3230-Knopfzelle ausprobiert. Sie reicht aus, um die Schaltung ausreichend zu versorgen. (1,5MB)

Programmer als Arduino-Shield

Wenn man viel mit dem ATtiny arbeiten möchte, bietet sich ein eigens erstelltes Arduino-Shield als Programmer an. Mein erster Ansatz war eine einfache, manuell verdrahtete Platine, die man auf den Arduino stecken konnte:

Gelötetes Arduino-Shield als ATtiny-Programmer
Abb.: Oberseite des selbstgelöteten ATtiny-Programmers als Arduino-Shield
Gelötetes Arduino-Shield als ATtiny-Programmer
Abb.: Unterseite des selbstgelöteten ATtiny-Programmers als Arduino-Shield

Als nächstes sollte aber auch ATtiny in SMD-Bauweise programmiert werden können. Daher habe mit EasyEDA ein Layout für ein Arduino-Shield entworfen und dann bei JLCPCB fertigen lassen. Nun werden ATtiny84 und ATtiny85 sowohl in DIP- als auch in SMD-Bauweise unterstützt. Damit die SMD-Chips guten Kontakt zu den Pads auf der Platine bekommen sind zwei 3mm Löcher vorhanden, die einen Mechanismus ermöglichen, damit man den Attiny leicht auf die Platine drücken kann.

Gefertigte Platinen des ATtiny-Programmers
Abb.: Gefertigte Platinen des ATtiny-Programmers
Bestückter ATtiny-Programmer
Abb.: Bestückter ATtiny-Programmer
Bestückter ATtiny-Programmer
Abb.: Bestückter ATtiny-Programmer (Unterseite)
ATtiny-Programmer sitzt als Shield auf dem Arduino-Board
Abb.: ATtiny-Programmer sitzt als Shield auf dem Arduino-Board

Das Layout und die Gerber-Dateien des Programmers können im Folgenden kostenfrei heruntergeladen und frei verwendet werden. Hinweis: nur immer einen der beiden Mikrocontroller einsetzen und niemals beide gleichzeitig!

Gerber-Dateien für ATtiny-Programmer (Arduino shield) [12kB]
ATtiny-Programmer als Arduino-Shield
Abb.: ATtiny-Programmer als Arduino-Shield

Weiterführende Links

zurück