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.

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

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.
Nicht alle zeitabhängigen Funktionen, wie z.B. delayMicroseconds() arbeiten mit allen Taktfrequenzen des ATtiny korrekt!

• pinMode()
• digitalWrite()
• digitalRead()
• analogRead()
• analogWrite()
• shiftOut()
• pulseIn()
• millis()
• micros()
• delay()
• delayMicroseconds()
• SoftwareSerial

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ässlich. 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

Verwendete Bauteile

• Grundlegende Werkzeuge und Hilfsmittel
• ATtiny 84A oder alternativ ATtiny85 (weniger Pins!)
• Arduino UNO (oder kompatibles Board)
• 10µF Elektrolytkondensator
• 5x LED (hier: 5mm rot)
• 5x 1kΩ Widerstand
• 18650 Li-Ionen-Akku
• 18650 Batterie-Board
• Steckkabel ("Jumperkabel")
• Steckbrett ("Breadboard")

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:

Arduino als ISP aufbauen

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

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:

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

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:

Resultat

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:

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.

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!

Weiterführende Links

• https://github.com/MCUdude/MicroCore: Integration des ATtiny13 in die Arduino-IDE
• https://github.com/SpenceKonde/ATTinyCore: ATTiny Core - 1634, x313, x4, x41, x5, x61, x7, x8 and 828 for Arduino 1.6.5+
• https://github.com/damellis/attiny: ATtiny support für die Arduino-IDE
• DIY ATtiny programming shield for Arduino Uno