ATtiny85 / 84 / 45 / 44 / 25 /24 programmieren

Über den Beitrag

Häufig gibt es Projekte für die man die großen ATmegas wie den 328(P) oder 168 eigentlich nicht benötigt. Verbaut finden sich diese Microcontroller z.B. auf dem Arduino Nano oder dem Arduino Pro Mini. Falls ihr es nicht schon tut, solltet ihr prüfen, ob ihr in dem einen oder anderen Fall nicht auch mit den platz- und energiesparenden, kleinen Brüdern ATtiny85, 84, 45, 44, 25 oder 24 (kurz: ATtiny85 & Co) auskommt. 

In diesem Beitrag möchte ich zeigen, wie ihr eure Sketche auf den ATtiny85 & Co hochladen könnt und zwar mit:

  • dem Arduino als Programmer und der Arduino IDE
  • dem USBtinyISP Programmer und der Arduino IDE
  • dem AVR Dragon oder Atmel-ICE und Atmel Studio 

Auf letztere Methode gehe ich nur kurz ein, da eine Schritt-für-Schritt Einführung den Rahmen des Beitrages sprengen würde. Zu einem späteren Zeitpunkt werde ich das nochmal als separates Thema behandeln.  

Ebenso werde ich auf die Eigenschaften der ATtinys und die Unterschiede zum großen Bruder ATmega nicht hier, sondern in einem weiteren Beitrag eingehen. Hier geht es primär um das Hochladen.

Wenn ihr es noch einfacher haben möchtet, dann könnt ihr auch alternativ zum Digispark greifen. Dieses ist ein auf dem ATtiny85 basierendes Modul, welches über USB programmiert wird. Beschrieben habe ich es hier

Pinout des ATtiny85 & Co

Pinout des ATtiny85 / 45 / 25
Pinout des ATtiny85 / 45 / 25

Die Pinoutschemata vom ATtiny85, 45 und 25 sind identisch. Neben VCC und GND gibt es sechs I/O Pins die, wie von den ATmegas gewohnt, über mehrere Funktionen verfügen. Für das Hochladen der Sketche werden die Pins 1, 5, 6 und 7 alias PB5, PB0, PB1 und PB2 alias RESET, MOSI, MISO und SCK benötigt.

Ein Datenblatt für diese Teilfamilie findet ihr z.B. hier.

Pinout des ATtiny84 / 44 / 24

Auch die Pinoutschemata vom ATtiny84, 44 und 24 sind identisch. Im Gegensatz zu der ATtinyx5 Reihe sind 12 I/O Pins vorhanden. Im weiteren Verlauf behandele ich primär die ATtinyx5 Reihe. Es sollte leicht sein, die Schaltungen und Erklärungen auf die 4er Reihe zu übertragen. 

Ein Datenblatt für diese Teilfamilie findet ihr hier.

Hochladen mit der Arduino IDE

Vorbereitung der Arduino IDE für ATtiny85 & Co

Zunächst müsst ihr der Arduino IDE den Umgang mit den ATtinys beibringen. Dazu hinterlegt ihr im ersten Schritt die entsprechende Boardverwalter URL in:

Datei -> Voreinstellungen -> Zusätzliche Boardverwalter-URLs.

Klickt auf das markierte Symbol und fügt im aufgehenden Fenster die Zeile:

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

ein. Dann schließt die Fenster mit „OK“. 

Boardverwalter URL für ATtiny Familie eintragen
Boardverwalter URL für ATtiny Familie eintragen

Im nächsten Schritt geht ihr auf:

Werkzeuge -> Board: …. -> Boardverwalter

und sucht nach „attiny“. Ihr wählt das Paket von David A. Mellis und installiert es. Dann startet ihr die Arduino IDE neu und das war’s auch schon.

Boardverwalter Paket installieren
Boardverwalter Paket installieren
Boardverwalter Paket ATtiny für ATtiny85 und Co.
Boardverwalter Paket ATtiny (ATtiny25 und 24 werden auch unterstützt)

Arduino als Programmer für ATtiny85 & Co

Schaltung

Als Erstes nutzen wir einen Arduino UNO als Programmer. Ein Nano, Mega, Pro Mini, usw. tut es natürlich genauso. Mein Anwendungsbeispiel ist ein einfacher Blinksketch. Die Schaltung dazu findet ihr weiter unten. Die Blink-LED ist an PB4 (Pin 3) angeschlossen. Zwischen dem Arduino RESET Pin und GND befindet sich ein 10 µF Kondensator. Das wird an vielen Stellen empfohlen, bei mir hat es aber auch immer ohne diese Maßnahme funktioniert. Ansonsten verbindet ihr die Komponenten wie folgt:

Anschlussschema Arduino UNO - ATtiny85 (gilt auch für ATtiny45 und 25) bzw. ATtiny84 (gilt auch für ATtiny44 und 24)
Schaltplan zur Programmierung des ATtiny85 / 45 / 25
Schaltplan zur Programmierung des ATtiny85 / 45 / 25

Beispielsketch

Zum Sketch muss ich wohl nichts hinzufügen, außer vielleicht, dass sich die Pinbezeichnung auf PBx und nicht auf die Nummer des Beinchens bezieht. 

int ledPin = 4;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);   
  delay(200);                     
  digitalWrite(ledPin, LOW);    
  delay(200);                     
}

 

Hochladen

Jetzt müsst ihr noch dafür Sorge tragen, dass der Sketch auf dem ATtiny und nicht auf dem Arduino landet. Dafür ladet ihr zunächst den ArduinoISP Sketch aus den Beispielen auf den Arduino. Für diesen Schritt ist immer noch der Arduino UNO als Board zu wählen. Falls ihr einen Kondensator am Arduino Reset habt, nehmt ihn für diesen Schritt ab! 

Auswahl des ArduinoISP Sketches
Auswahl des ArduinoISP Sketches

Dann wählt ihr euren ATtiny, den Takt und natürlich den richtigen Port:

Auswahl von ATtiny85, 45 oder 25; Auswahl von Takt und Port im Menü.
Anzupassende Auswahl im Werkzeuge Menü

Schließlich müsst ihr noch den richtigen Programmer auswählen:

Werkzeuge -> Programmer -> „Arduino as ISP“

(nicht: ArduinoISP!). Dann habt ihr es geschafft und könnt den Sketch endlich hochladen. 

Hinweis: bei Wechsel der Taktrate und sicherheitshalber vor dem ersten Hochladen müsst ihr den Bootloader neu brennen. Probiert es mal aus: Ladet den Beispielsketch einmal mit der Auswahl 16 MHz und danach mit 1 MHz hoch – ist der Bootloader noch derselbe, ist die Blinkfrequenz bei 16 MHz sechzehnmal langsamer. 

Kleine Helferlein

Wenn Ihr viel mit den ATtinys arbeitet, dann empfehle ich in einen Breadboardadapter (im nächsten Bild links) zu investieren, da es das Arbeiten erheblich übersichtlicher macht. Besonders sinnvoll ist der Adapter in Verbindung mit dem USBtinyISP Programmer, zu dem wir gleich kommen werden. Man kann den Adapter aber auch mit einem UNO benutzen, wenn man sich ein kleines Shield baut. Den Breadboardadapter gibt es z.B. hier oder mit 2 x 3 Pinleiste hier zu kaufen. 

Adapter Shield zur Programmierung von ATtiny85 & Co
Selbstbau Adapter Shield mit Breadboard Adapter für ATtiny85 & Co
Adapter Shield von unten
Adapter Shield von unten

Hochladen mit dem USBtinyISP

Das Schöne am Arduino als Programmer ist, dass man das Teil sowieso besitzt. Bequemer ist aber das Arbeiten mit einem USBtinyISP Programmer, da man nicht den Umweg über den ArduinoISP Sketch gehen muss. Außerdem kann man direkt einen Breadboardadapter draufstecken. Den Programmer gibt es für <10 Euro z.B. bei Amazon

USBtinyISP Programmer
USBtinyISP Programmer

Vorbereitung

Auch bei Benutzung des Programmers müssen die Schritte unter „Vorbereitung der Arduino IDE“ weiter oben natürlich erledigt sein. Dann braucht Ihr noch einen Treiber für den USBtinyISP. Das Treiberinstallationsprogramm bekommt ihr hier. Startet es, setzt einen Haken bei „Trinket / Pro Trinket / Gemma (USBtinyISP)“ und klickt auf „Install“. 

Adafruit USBTtnyISP Treiberinstallation

Die Schaltung

Die Schaltung ist grundsätzlich die Gleiche wie oben, nur eben mit dem Programmer anstelle des Arduino:

Schaltung für die Programmierung des ATtiny85 mit USBtinyISP Programmer
Schaltung für den ATtiny85 / 45 / 25 mit USBtinyISP Programmer

Hochladen

In der Arduino IDE wählt ihr als Programmer „USBtinyISP“.  Wahrscheinlich fällt euch auf, dass „Port“ als Auswahl nicht zur Verfügung steht, obwohl ihr den Programmer angeschlossen habt. Keine Sorge, das gehört so. Dann wählt ihr den ATtiny Typ und die Taktrate aus und könnt den Sketch hochladen. Bei älteren Versionen der Arduino IDE muss man wohl „Hochladen mit Programmer“ im Menüpunkt „Sketch“ wählen oder alternativ auf den Hochladen Pfeil klicken und dabei die Umschalttaste gedrückt halten. In meiner Arduino IDE Version (1.8.9) geht es auch ohne diese Maßnahmen. 

Wenn es nicht funktioniert

Eine berühmt-berüchtigte Fehlermeldung ist „Could not find USBtiny device (0x1781/0xc9f)“:

Fehlermeldung

Solltet ihr diese Meldung bekommen, obwohl der USBtinyISP angeschlossen ist, liegt mit großer Wahrscheinlichkeit ein Treiberproblem vor. Ich hatte das auch schon. Geht – sofern ihr Windows benutzt – in den Geräte-Manager und sucht den USBtinyISP. Schaut euch in den Eigenschaften die Treiberdetails an. Das müsste ungefähr so aussehen: 

USBtinyISP im Geräte-Manager

Bei mir hatte Windows einen anderen Treiber genommen, den ich auf meinem Rechner hatte. Die Lösung: Auf „Treiber aktualisieren“ gehen -> „Auf dem Computer suchen“ -> „Aus einer Liste verfügbarer…..“. Wenn dort mehrere Treiber aufgeführt sind, einfach durchprobieren. 

Hochladen mit dem Atmel Studio

Diese Variante möchte ich der Vollständigkeit halber mit aufführen. Allerdings ist das Thema so umfangreich, dass es den Rahmen sprengen würde. Ich werde es deswegen hier nur kurz anreißen und in einem separaten Beitrag eine Schritt-für-Schritt Einführung geben. 

Atmel Studio (derzeit Version 7) ist eine kostenlose IDE die man sich hier herunterladen kann. Sie umfasst alles was man softwareseitig braucht um Atmel Microcontroller zu programmieren. 

Als passende Hardware werden verschiedene Programmer angeboten, z.B. der AVR Dragon oder Atmel-ICE:

Programmer für Atmel Studio, links: Dragon, rechts: Atmel-ICE
Programmer für Atmel Studio, links: Dragon, rechts: Atmel-ICE

Die Programme, die man in Atmel Studio schreibt, sind normalerweise in „C“ geschrieben und wesentlich maschinennäher als die gewohnten Arduino Sketche. Der Blink-Sketch sieht dann folgendermaßen aus: 

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


int main(void)
{
    DDRB |= (1<<PB4);
    
  while (1) 
  {
    PORTB = (1<<PB4);
    _delay_ms(500);
    PORTB &= ~(1<<PB4);
    _delay_ms(500);
    }
}

 

Das mag ein wenig abschreckend aussehen, hat aber durchaus seine Vorteile, z.B. im Hinblick auf die Geschwindigkeit. Außerdem erkennt man besser was wirklich auf der Ebene von Ports und Registern passiert. 

Weitere Vorteile am Arbeiten mit Atmel Studio und den genannten Programmern sind unter anderem:

  • Zugriff auf die Fuse-Bits
  • Debugging: schrittweise Programmausführung und Variablenverfolgung
  • bessere Strukturierung großer Projekte

Der Nachteil: die Geschichte ist recht gewöhnungsbedürftig und die Programmer sind relativ teuer. Trotzdem Lust auf mehr? Dann haltet die Augen offen für den speziellen Beitrag zu dem Thema. 

14 thoughts on “ATtiny85 / 84 / 45 / 44 / 25 /24 programmieren

  1. Lieber Wolfgang,

    ihre Beiträge sind einfach hervorragend. Danke! Auch wenn man schon glaubte, vieles zu wissen…
    Allerdings gehen unsere geliebten ATmegas und ATtinys langsam in Rente. Da man nicht weiß, wie lange die Texte noch da sind, drucke ich mir gern solche Beiträge aus. Leider gibt es mit Wolles Seiten Probleme. Hätten Sie einen Tip?

    Viele Grüße aus Berlin von
    Gerd Heinz

  2. Hallo Wolfgang,

    Tolle Anleitung von dir!
    Ich habe mir so einen USBtinyISP-Programmer zugelegt (https://www.amazon.de/gp/product/B07MR7MF9R/ref=ppx_yo_dt_b_asin_title_o06_s01?ie=UTF8&psc=1), der die Sache grundsätzlich auch erledigen soll. Ich möchte damit einige Attiny84 flashen. bin mir aber nun nicht sicher, wie die Pin-Zuordnung im Programm sein soll. Bei Programmierung über einen Uno („Arduino as ISP“) ist die Pin-Zuordnung so wie beim Uno, nicht wie von Attiny selbst. Muss ich vor dem Scatch einen Bootloader flashen?

    Beste Grüße, Herbert

    1. Hallo Herbert,

      du brauchst keinen Bootloader. Der Bootloader wird bei den Arduino Boards vor allem deswegen benötigt, weil die Programmierung über die seriellen Anschlüsse RX/TX erfolgt. Das muss man den Microcontrollern sozusagen erst beibringen. Hier wird aber über ISP programmiert, was eigentlich die „natürliche“ Methode ist.

      Cooler kleiner Programmer, den du da ausgesucht hast. Über den bin ich noch nicht gestolpert.

      Die Pinbezeichnungen im Programm sind: PA0 ist 0, PA1 ist 1 ….PA7 ist 7, PB0 ist 10, PB1 ist 9 und PB2 ist 8. Falls es das ist was du meinst.
      VG, Wolfgang

  3. Hallo,
    ich habe dein Beispiel ausprobiert: „Arduino as ISP“
    Die Programmierung hat immer nur nach dem zweiten Versuch funktioniert: egal ob BootLoader oder Sketch!

    Herzlichen Dank für die Anleitung, hat mir sehr geholfen!

    eine Frage am Rande: kann man an einem PIN des ATtiny84 sowohl den Interrupt „Rising“ UND „Falling“ in einem Sketch nutzen?
    LG
    Günter

    1. Hallo Günter,

      ich weiß nicht, ob ich die Frage richtig verstehe – wäre das nicht einfach „change“? Damit löst der Interrupt sowohl mit der steigenden, wie mit der fallenden Flanke aus.

      VG, Wolfgang

      1. Hallo Wolfgang,
        es sollen je nach steigender oder fallender Flanke unterschiedliche Dinge getan werden, darum die Frage.
        Ich habe aber eine Lösung gefunden mit „Change“ und im Change-ISR-Handler wird dann unterschieden ob es RISING oder FALLING war.

        Aber noch einmal generell: kann man sowohl Interrupt „Rising“ UND „Falling“ in einem Sketch nutzen?

        LG
        Günter

        1. Ein Interrupt, den du für einen Pin einrichtest, kann immer nur auf Rising oder Falling oder Change reagieren. Du kannst innerhalb eines Sketches wechseln, aber gleichzeitiges Ring und Falling geht nicht. Aber das wäre ja auch gleichbedeutend mit Change, deswegen verstehe ich die Frage nicht so ganz. Was du natürlich machen kannst, ist zwei Interrupts für unterschiedliche Pins definieren und dabei einen auf Rising und den anderen auf Falling auslösen lassen. Und wenn du bei Change wissen willst ob es ein Rising oder Falling Event war, dann würde ich es so machen wie du, nämlich mit einer Zustandsabfrage.

          1. Hallo Wolfgang,
            danke für die Aufklärung!
            Ich glaube, dass ich die Lösung gefunden habe. Ob es funktioniert, werden die nächsten Tage zeigen.
            Vielleicht ergeben sich weitere Fragen.
            Schönes WE
            LG
            Günter

  4. Hallo, hier „Wolfi“,
    mein ATtiny blinkt! (siehe vorhergehende Mail)
    Mein Fehler:
    Da der ATtiny45/85 ja als 20MHz-Ausführung verkauft wird, habe ich in der Arduino-IDE auch „Clock“ auf 20 gesetzt. Aber diese Einstellung betrifft (jetzt auch mir bekant) bekanntlich einen Externen Takt. Fazit: ATtiny unbrauchbar (zumindest vorerst, man soll in wieder Leben einhauchen können, aber das eventuell süäter als Versuch).
    Jetzt mit 1MHz Takt (intern) funktioniert ein ATtiny45.

    Trotzdem vielen Dank für die hier bereitgestellte Info, hat mir sehr geholfen.

    Gruß
    Wolfi

    1. Alles klar. Ist blöd, dass man keine Warnung bekommt. So kann man sich dann aussperren. Ist mir auch schon passiert. Mit Atmel Studio kannst du die Taktzahl wieder „hinbiegen“.

  5. Wunderschön erklärt.
    Aber leider bei mir ohne Erfolg.
    Fehlermeldung:
    avrdude: Version 6.3-20190619
    Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
    Copyright (c) 2007-2014 Joerg Wunsch

    System wide configuration file is „C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf“

    Using Port : COM10
    Using Programmer : stk500v1
    Overriding Baud Rate : 19200
    AVR Part : ATtiny45
    Chip Erase delay : 4500 us
    PAGEL : P00
    BS2 : P00
    RESET disposition : possible i/o
    RETRY pulse : SCK
    serial program mode : yes
    parallel program mode : yes
    Timeout : 200
    StabDelay : 100
    CmdexeDelay : 25
    SyncLoops : 32
    ByteDelay : 0
    PollIndex : 3
    PollValue : 0x53
    Memory Detail :

    Block Poll Page Polled
    Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
    ———– —- —– —– —- —— —— —- —— —– —– ———
    eeprom 65 6 4 0 no 256 4 0 4000 4500 0xff 0xff
    flash 65 6 32 0 yes 4096 64 64 4500 4500 0xff 0xff
    signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
    lock 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
    lfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
    hfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
    efuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
    calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00

    Programmer Type : STK500
    Description : Atmel STK500 Version 1.x firmware
    Hardware Version: 2
    Firmware Version: 1.18
    Topcard : Unknown
    Vtarget : 0.0 V
    Varef : 0.0 V
    Oscillator : Off
    SCK period : 0.1 us

    avrdude: AVR device initialized and ready to accept instructions

    Reading | ################################################## | 100% 0.02s

    avrdude: Device signature = 0xffffff (probably .avr8x_mega) (retrying)

    Reading | ################################################## | 100% 0.02s

    avrdude: Device signature = 0xffffff (probably .avr8x_mega) (retrying)

    Beim Hochladen des Sketches ist ein Fehler aufgetreten
    Reading | ################################################## | 100% 0.02s

    avrdude: Device signature = 0xffffff (probably .avr8x_mega)
    avrdude: Yikes! Invalid device signature.
    Double check connections and try again, or use -F to override
    this check.

    avrdude done. Thank you.

    Was mache iczh falsch?
    Gruß
    Wolfi

    1. Hi, ich habe ja einige Wege aufgezeigt, wie man diese MCU Familie programmiert. Welchem Weg hast du hier probiert? Welcher Programmer (STK 500?)? Welchen Microcontroller (ATtiny45, wie hier steht?)? Welche Taktfrequenz? Welche Einstellungen hast du in der Arduino IDE gewählt?

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.