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

Über den Beitrag

Update 08.07.2022: In diesem Beitrag beschreibe ich das Board Manager Paket „attiny“. Ich empfehle aber mittlerweile das bessere Paket „ATTinyCore“ von Spence Konde. Den Beitrag dazu findet ihr hier.

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. 

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

  1. Hallo Wolfgang,
    zunächst Danke für Deine übersichtliche Anleitung zum Programmieren eines Attiny mit dem Arduino.

    Ich bin absoluter Anfänger und Neueinsteiger. Das Einzige, was ich bisher geschafft habe: Einen Uno oder auch Nano mit der Arduino ISp 1.8.13 und auch der Version 1.8.19 einzurichten und den Sketch „Blink“ hochzuladen. Und ich habe im Sketch versuchsweise die Zeiten für High und Low verändert/verlängert, was dann auch funktionierte. Auch nach Trennen vom USB und nur Anschluß an 5V Stromversorgung funktioniert es mit den neu programmierten High und Low-Zeiten. Für mich bis dahin schon ein Riesenerfolg.

    Das weitere Einrichten für das Programmieren von Attiny scheitert jedoch. Sowohl bei Deiner Anleitung, als auch zuvor bei zwei weiteren Anleitungen von anderen Autoren. Das heißt, dass ich jetzt schon Wochen damit beschäftigt bin. Ich bin sicher, dass es mit sachkundiger Hilfe irgendwann funktionieren würde, aber ich möchte nun nicht weitere Wochen nur damit verbringen, herauszufinden, woran es lag. Darum meine Frage:

    Ist es möglich, Arduino ISP auf einem Datentrager fertig einzurichten (fertig für das Programmieren von Attiny85), so dass es an einem beliebigen anderen PC funktioniert? Als Datenträger wäre für mich ideal, eine SSD-Festplatte. Oder geht es vielleicht sogar mit einem USB-Stick?

    Deine Antwort wäre für mich sehr hilfreich. Auch „zur Argumentation“ in einem großen Arduino-Forum, wo man es als Laie erfahrungsgemäß nicht leicht gemacht wird. Ich brauche das Forum aber für meinen weiteren Einstieg in die Materie.

    Viele Grüße und Danke vorab
    Hans-Dieter

    1. Hallo Hans-Dieter,

      tut mir leid, dass es nicht funktioniert. Wenn du mir genau sagen würdest, an welcher Stelle es nicht funktioniert, könnten wir das Problem näher einkreisen. Auch Fotos o.ä. von der Schaltung sind hilfreich. Kannst du an wolfgang.ewald@wolles-elektronikkiste.de senden. Nur ein Angebot.

      Die Frage, die du hast, verstehe ich nicht ganz. Der ArduinoISP Sketch muss auf den Arduino, der als Programmer für den ATtiny dienen soll. Und dann kannst du von jedem PC aus, auf dem die Arduino IDE (also das Arduino-Programm) installiert ist, den ATtiny über den Arduino programmieren.

      VG, Wolfgang

      1. „Es gibt keine Lobby für das Versagen“
        Welche Kraft sollte diese auch nähren? Menschen tun sich nicht zusammen, um über Misserfolge zu berichten.

        Hallo Wolfgang,
        selbstverständlich nehme ich Dein Angebot gerne an. Und ich bin auch bereit, Dir die Stellen aufzuzeigen, an denen es „bei mir“ nicht so wie beschrieben funktioniert. Ich versuche es an zwei Computern, auf dem einen ist das ältere Arduino 1.8.13 und auf dem anderen das aktuellere Arduino 1.8.19 installiert. Auf beiden funktioniert Deine Anleitung nicht. (und ebenso nicht die von zwei anderen Webseiten-Autoren) Allerdings zeigen sich zwischen den beiden Versionen offensichtliche Unterschiede. Es scheitert an verschiedenen Stellen, anscheinend aus gänzlich verschiedenen Gründen.

        Mein Ziel ist aber nicht, das aufzuklären oder gar die Anleitung zu kritisieren. Mein Ziel ist lediglich, eine funktionierende Einheit zu bekommen, auf die ich immer wieder zurückgreifen kann, um das Programmieren „nach meinen Wünschen zu lernen“. Und darum wünschte ich mir, dass mir jemand einen Datenträger, eine SSD-Festplatte oder einen USB-Stik mitsamt der Arduino IDE Software und einem Arduino Uno mit einem passenden Shield liefert. Selbstverständlich gegen Bezahlung. Ich konnte aber bisher keine klare Antwort auf die Frage bekommen, ob das überhaupt machbar ist. Ich komme bisher überhaupt nicht weiter, auch nicht mit viel Hilfe aus meinem Bekanntenkreis.

        Als absoluter Laie und Neueinsteiger auf diesem Gebiet habe ich vor etwa 5 Jahren damit begonnen, und zwischenzeitlich mit großen Abständen erneut mehrfach den Versuch gemacht. Angefangen habe ich mit einem Mikrocontroller Lernpaket. „Das Franzis Lernpaket“ samt Lehrbuch vom Autor Burkhard Kainka.

        Das Bemerkenswerte daran ist aus meiner Sicht, dass es nach einiger Zeit zwar noch weitere Lernpakete, auch von Burkhard Kainka, gab. Aber keines mehr zum Thema „Mikrocontroller“. Das Produkt wurde stillschweigend aus dem Lieferprogramm genommen. Und in Mikrocontroller Foren las ich einige Beiträge von gescheiterten Versuchen. Auf Kainkas Webseite las ich von „neuer Platine“, die in Arbeit sei. Aber da kam dann nichts mehr.

        Für mich als Laien sah das ganz am Anfang immer so aus, als sei ich von Tausenden glücklichen Besitzern dieses „Franzis Lernpaketes“, der einzige, der zu blöd dafür ist. Trotzdem habe ich es nie richtig aufgegeben. Und jetzt, heute, Mai 2022 weiß ich ganz sicher, dass ein sehr großer Teil solcher Anleitungen im Internet aus den verschiedensten Gründen nicht funktioniert. Dass aber die Autoren meistens nie davon erfahren. Weil es eben keine Freude bereitet, über seine Misserfolge zu berichten, teilen die Erfolglosen es ihnen nicht mit.

        Und jeder, der hier mitliest und bei dem es funktioniert, wird nicht begreifen, dass es andere gibt, bei denen es nicht funktioniert.

        Ich freue mich auf die Zusammenarbeit mit Dir, so wie angeboten über Deine E-Mailadresse. Und ich bin auch sicher, dass ich in Kürze ATtinys programmieren kann.

        Danke für Deine Arbeit!
        Viele Grüße
        Hans-Dieter

        1. Hallo Hans-Dieter,

          wenn drei Autoren Anleitungen herausgeben, alle drei funktionieren bei dir nicht und du dich auch als Anfänger bezeichnest dann ist die Wahrscheinlichkeit größer, dass der Fehler bei dir liegt als in den Anleitungen. Ich bin schon mit vielen Lesern, die dachten, sie hätten sich GENAU an meine Anleitung gehalten, die Dinge im Detail durchgegangen und sind dann darauf gekommen, dass sie sich doch nicht daran gehalten haben, weil sie etwas falsch verstanden haben. Oder es war schlicht irgendetwas defekt. Das Angebot, auf die Fehlersuche zu gehen, steht immer noch.

          Und was das Shield angeht: Im Beitrag findest du die Abbildung eines Selbstbau-Shields. Opfere einen Arduino UNO auf dem du den ArduinoISP Sketch permanent lässt, pack das Shield oben drauf und dann kannst du von jedem PC mit Arduino IDE den ATtiny programmieren. Oder investiere in einen Programmer für < 10 Euro und dann kannst du es auch. Du brauchst lediglich die Arduino IDE. VG, Wolfgang

  2. Guten abend, zunächst vielen Dank für diese sehr gute Seite mit vielen sinnvollen Anwendungen und Tips.
    Nun zu dem Grund meines Schreibens: Ich bekommen immer Kompilierungsfehler beim Versuch einen Sketch für einen Servo (SG 90) auf einen ATtiny 85 hochzuladen . Der Sketch beinhaltet die Bibliothek , hieran stört er sich auch, denn er meldet das er sie nicht kennt. Gibt es eine Möglichkeit das zu ändern ?
    mfg
    Joachim aus Halle/Westf.

    1. Hallo Joachim,
      die Servo Bibliothek ist sehr hardwarespezifisch geschrieben. Das Problem ist der Timer. Aber ich habe auf GitHub etwas gefunden:
      https://github.com/ElizabethTeaches/PrecisionServo
      Zitat: „This library was tested with an ATTiny85 via a usb programmer on an Arduino IDE with the Tower Pro Micro Servo 9g (an SG90 servo).“
      Die Bibliothek kann man nicht über die Arduino-Bibliotheksverwaltung installieren. Falls du das noch gemacht hast: den Link oben aufrufen, auf das grüne Feld „Code“ gehen, Download Zip wählen, die Zip Datei im Aduino library Ordner entzippen. Dann kann man die Bibliothek einbinden. Probiert habe ich die Bibliothek nicht, aber klingt eigentlich nach dem was du suchst. Besipielsketche sind auch dabei.
      Viel Erfolg & VG, Wolfgang

  3. Hallo Wolfgang,

    wirklich eine tolle Homepage, die mir den Einstieg in die Microcontroller-Sache erheblich erleichtert hat !

    Da ich mich nun entschossen habe, einige kleinere Projekte mit dem ATtiny84 zu realisieren, bin ich auf
    dieser Seite über den Absatz “ Hinweis: bei Wechsel der Taktrate und sicherheitshalber vor dem ersten Hochladen müsst ihr den Bootloader neu brennen….“ gestolpert.
    Was genau wird hier nun eigentlich an den ATtiny übertragen (ein Bootloader mit der Unterstützung einer seriellen Programmübertragung ist ja bei der ISP-Programmierung nicht erforderlich) ?

    Viele Grüße
    Alex

    1. Hallo Alex,
      stimmt, eigentlich braucht man bei der ISP Programmierung keinen Bootloader. Beim Wechsel der Taktrate muss man eigentlich nur die entsprechenden Fuse Bits setzen. Um das in der Arduino zu bewerkstelligen, muss man aber den Menüpunkt „Bootloader brennen“ wählen. Etwas zielgenauer kann man das mit Programmen wie Microchip (Atmel) Studio machen.
      VG, Wolfgang

      1. Hallo Wolfgang,

        vielen Dank für die superschnelle Antwort !
        Nur nochmals für mein Verständnis: Werden beim „Bootloader brennen“ des ATtiny84 mittels eines ISP-Programmers wirklich nur die Fuse Bits gesetzt, d.h. es wird nichts übertragen was irgendwelchen Speicher belegt ?

        Grüße
        Alex

        1. Was die Arduino IDE überträgt oder nicht überträgt kann ich spontan nicht sagen. Vom Prinzip her braucht man keinen Bootloader wie bei der Arduino-eigenen Programmierung per RX/TX. Ich müsste da auch noch einmal nachforschen.

        2. Hallo Alex,

          ich habe nochmal geforscht und diese Stelle:
          https://forum.arduino.cc/t/do-we-need-to-burn-bootloader-for-new-attiny-ic/502452
          gefunden, die auch besagt, dass beim Brennen des Bootloader für den ATtiny nur die Fuses gesetzt werden:

          The thing that’s not obvious about Tools > Burn Bootloader is that it doesn’t only burn the bootloader. It also sets the fuses on the microcontroller according to the hardware definition of the board you currently have selected in the Tools > Board menu. So even though there is no bootloader to burn, if you need to change the fuses then you still use Tools > Burn Bootloader. Once you’ve done that it’s not necessary to do again unless you want to change the fuses. It definitely makes sense to do a Tools > Burn Bootloader to be sure you have the expected fuses set.

          und:
          Most popular hardware packages for the ATtiny85 (damellis/attiny and SpenceKonde/ATTinyCore) do not use a bootloader for the ATtiny85 and thus no boot section is reserved. When you do a Tools > Burn Bootloader with one of those boards selected all that happens is the fuses are set.

          1. Hallo Wolfgang,

            vielen Dank für die Mühe – genau diese Informationen hatte ich vergeblich gesucht !

            Viele Grüße
            Alex

  4. Moin,
    ich habe den Arduino mega 2560,und habe mir eine Nullkraftadpter platine zum Programmieren von Atinnys gekauft.Meine frage icst kann ich dafür die Icsp Stecker auf dem Arduinoboard verwenden anstatt ein Steckboard.Da ich das eine oder andere Projekt dauerhaft behalten möchte.

    1. Hallo, man kann auch den ICSP Stecker zum Programmieren benutzen. Die ICSP Pins (MISO, MOSI, etc) sind genau wie ihre Pendants auf der Pinleiste direkt mit den entsprechenden Ein-/Ausgängen des Atmega2560 verbunden.

      1. Hätte da nochmal eine Frage:
        Der arduino mega 2650 hat ja zwei icsp anschlüsse ist es egel welchen ich nehme um nur einen sketch zuübertragen.Oder nur die pins am 16u2 chip.Bin halt absoluter anfänger was das brennen von sketchen angeht.
        Mit freundlichen Grüssen
        Stephan Haase.

        1. Hi, für die Programmierung des Attiny nimm den ICSP Anschluss in der Mitte neben dem Reset Knopf (jedenfalls ist er bei meinem Board an dieser Stelle). Der andere 6 Pin Header ist ein Zugang zum 16U2 Chip. Wenn du dir nicht sicher bist und hast ein Multimeter, dann kannst ganz einfach prüfen, welcher Header mit den ISP Pins der Pinleisten verbunden sind.

  5. Hallo Wolfgang,

    vielen Dank für diesen sehr schönen Beitrag. Ich konnte die Anleitung zum Flashen des ATtiny85 mit einem Arduino Uno ohne Probleme umsetzen. Eine kleine Frage hätte ich. Wofür ist der Kondensator (ich hatte keinen 10µF-Kondensator nur einen mit 47 µF) am Reset-Pin des Arduino notwendig?

    Als Anwendung möchte ich entweder den Dallas DS18B20-Temperatursensor oder den DHT22 anschließen und per 433 MHz Daten zu meiner FHEM-Hausautomation senden, das ganze so batterieschonend wie möglich. Ich habe zwar im FHEM-Forum Sketche dazu gefunden, die ich aber erst noch für mich sortieren muss. Falls du in dieser Richtung etwas hast, was du mir zum Testen empfehlen kannst, dann wäre ich daran interessiert.

    Zumindest etwas teile ich mit deinem Lebenslauf, denn ich bin auch Chemiker mit einem Hang zur Mikroelektronik und Hausautomation.

    Viele Grüße
    Gisbert

    1. Hallo Gispert,

      erstmal vielen Dank für den Kommentar. Was den Kondensator angeht, kann ich mich nur noch einmal selbst zitieren:
      „Das wird an vielen Stellen empfohlen, bei mir hat es aber auch immer ohne diese Maßnahme funktioniert“. Warum das empfohlen wird, weiß ich schlicht nicht.
      Die beiden von Dir genannten Sensoren funktionieren beide gut und die Ansteuerung ist kein Problem. Wenn du Strom sparen willst, dann solltest du deinen Microcontroller zwischen den Messungen in den Schlaf schicken:
      https://wolles-elektronikkiste.de/sleep-modes-und-power-management
      Viel Spaß bei deinem Projekt!
      VG, Wolfgang

      1. Coole Seite.
        Der Kondensator ist um einen Reset nach anlegen der Stromversorgung auszulösen.
        Die Resetleitung wird dann quasi vom Kondensator auf Masse gezogen bis der Kondensator geladen ist.
        Da müsste es einen Mindestwert in uF geben damit der Prozessor genug Zeit zum resetten hat.
        Ein größerer Wert verlängert dann die Zeit bis der Prozessor startet -> praktisch für Anbauteile, welche länger als der Prozessor brauchen bis sie bereit sind 🙂

  6. Hallo Ein Experiment mit ATtiny war schon länger auf meiner ToDo-Liste. Danke für die ausführliche und excellente Anleitung! Spart viel youtube-Zeit.

    Obwohl ich mir einen USB-Programmer geholt hatte, bin ich auf die Lösung mit dem UNO umgeschwenkt: Viele Webseiten mit Treibern scheinen mir veraltet und ich war zu faul zum suchen und ausprobieren. Mit dem (eh unbenutzten) UNO funktionierte es auf Anhieb.

    Und hätte ich den Hinweis zum Brennen des Bootloaders gleich am Anfang gelesen und befolgt, hätten meine Neopixels eine Stunde früher funktioniert…

  7. Salve Wolfgang, scusami ma sono alle prime armi.
    Potrei chiederti un aiutino?
    Vorrei accendere 2 led indipendenti con ritardo +- 35 sec, con musichetta random da sd o modulo mp3, e fare in modo che quando e‘ acceso un led, se premo il secondo pulsantr si accendono i 2 led, passato il tempo da solo messaggi.
    Dopo 10 minuti di inattivita‘ va in off l’ATiny85 in attesa del prossimo input, (x il risparmio energia).
    Si puo‘ fare?
    Grazie

    1. Ciao Sergio, purtroppo non parlo italiano. Ho tradotto il tuo messaggio con deepL, ma poi è difficile da capire.

  8. Hallo Wolfgang,
    ersteinmal vielen Dank, für deine Beiträge. Ich taste mich gerade an die AVR Programmierung heran und möchte eine Pumpensteuerung für einen Brunnen umsetzen. Mit einem Arduino funktioniert das. Weil das ganze aber auf einer Weide steht und mit an der Solaranlage für das Weidezaungerät gehängt werden soll und auch immer nur kleine Mengen gepumpt werden können, möchte ich den Stromverbrauch der Steuerung so niedrig wie möglich halten und das Ganze mit einem ATTiny 84 umsetzen. Ich habe den auch schon so weit, dass er im Sleepmodus mit wenigen uA auskommt.
    (Dazu musste ich übrigens den ADC extra deaktivieren, Register ADCSRA, Bit ADEN auf 0 setzen und dann Power Down, dann verbraucht er ca. 4uA, statt der 240uA (bei 3,3V, 1MHz), wenn ich den ADC nicht seperat deaktiviere. Ich habe nicht ganz verstanden, warum ich den extra deaktivieren muss, aber so gehts).
    Naja, mein Problem jetzt: Ich habe an der Steuerung einig Einstellungen nachzujustieren, die ich nur im laufenden Betrieb ermitteln und eingeben kann.
    Das ging mit dem Arduino sehr gut. USB Kabel rein, Programmieren, Programm laufen lassen, am Serial Monitor Messwerte anzeigen lassen, Einstellungen vornehmen, Programmieren und die nächste Testrunde.
    Mit dem Tiny bin ich wie folgt vorgegangen: Programmierung in der Arduino IDE, Programm übertragen mit Arduino as ISP, nur leider hat auf diesem Wege die Datenausgabe auf den SerialMonitor nicht funktioniert. Ich habe versucht mit der Library Software.Serial die Daten zu übertragen und habe mit unterschiedlichen Einstellungen herumprobiert, bekomme aber bestenfalls krytischen Datenmüll auf den Bildschirm. Mit einem FTDI232 kann ich mir die Daten ohne Probleme auf dem Bildschirm anzeigen lassen, nur kann ich damit nicht programmieren (zumindest habe ich noch nichts gefunden) und muss deshalb immer umstöpseln, weil ich auch nicht genug Pins übrig habe um beide Adapter (Arduino as ISP und FTDI232) gleichzeitig dranzuhängen.
    Atmel Studio war mir ehrlich gesagt eine Nummer zu groß. Deswegen meine Frage: Hast du einen Tipp, wie man einen ATTiny mit ein und demselben Adapter programmieren kann und anschließend direkt die Werte auf den SerialMonitor bekommt? Mein nächster Versuch wäre AVRTinyISP, aber da habe ich noch nicht wirklich eine Aussage gefunden, ob das mit dem SerialMonitor geht.

    1. Hallo Stefan,
      das scheint in der Tat nicht ganz trivial zu sein. Ausprobiert habe ich es selbst noch nicht. Es gibt wohl Möglichkeiten, das habe ich gerade nochmal recherchiert. Aber nichts davon erscheint bequem (nach dem Motto: Bibliothek installieren und alles läuft). Da müsste ich jetzt selbst auch herumtüfteln. Hier ist zumindest ein Link zu einer Seite wo mehrere Wege vorgestellt werden.

      http://www.ernstc.dk/arduino/tinycom.html

      Mehr kann ich leider nicht anbieten. Vielleicht liest das hier aber jemand, der einen guten Weg kennt!?

      VG, Wolfgang

      1. Hallo Wolfgang,
        vielen Dank erstmal für die Antwort. Ich bin erst einmal beruhigt, dass es wirklich nicht so einfach ist und ich nur irgend eine ganz triviale Lösung übersehen habe.
        Ich habe an meinem Tiny84 die Pins jetzt so organisiert, dass ich für mein Projekt 7 Pins brauche, dann noch 3 und Reset um ihn über den Arduino als ISP zu programmieren und dann bleibt noch ein Pin übrig, der ja für die „Debug“-Ausgabe auf den Serial Monitor am Laptop reichen sollte. Da denke ich wird mir dein Link weiterhelfen. Ich hatte schon befürchtet, dass ich dafür an die SoftwareSerial Bibliothek ran muss – ich hatte gehofft, mich davor drücken zu können, der Einstieg in die Materie ist schon kompliziert genug. Aber genau darauf geht der Autor in deinem Link ein, Serielle Kommunikation mit dem Tiny, ggf. auch nur in eine Richtung. Ich muss das noch ganz zuende austüfteln, aber ich kann jetzt den UNO und die Serielle Schnittstelle gleichzeitig an der Schaltung lassen ohne umzustöpseln und ohne, dass da irgendwelche komischen Sachen passieren. Ich muss lediglich noch in der Arduino IDE zwischen Port 3 zum Programmieren und Port 4 für den Serial Monitor hin und her schalten. Das ist echt ein riesen Gewinn!!
        Vielen Dank
        Stefan

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

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

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

  12. 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“.

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