ATtiny mit Arduino Code programmieren

Über den Beitrag

Vor geraumer Zeit hatte ich einen Beitrag zum Thema „ATtiny85 / 84 / 45 / 44 /25 / 24 programmieren“ geschrieben. Dabei kam das Boardverwalter Paket „attiny“ von David A. Mellis zum Einsatz. Es gibt allerdings ein anderes Paket namens ATTinyCore von Spence Konde, welches viel mehr Vertreter der ATtiny Familie abdeckt und erheblich komfortabler ist. Zudem sind sowohl der Funktionsumfang, wie auch die Unterschiede der einzelnen Vertreter der ATtiny Familie ganz hervorragend dokumentiert.

Zeit also für einen neuen Beitrag zu diesem Thema! Das kommt auf euch zu:

Vorteile von ATTinyCore vs. attiny

ATTinyCore kann alles, was auch das ältere Paket „attiny“ kann, nur noch mehr. Hier die aus meiner Sicht wichtigsten Vorteile:

  • Ihr könnt derzeit 20 ATtiny MCUs anstelle von 6 programmieren.
  • ATTinyCore beherrscht I2C, SPI und UART (Serial) ohne dass ihr zusätzliche Bibliotheken benötigt.
  • Größere Bootloaderauswahl (gilt allerdings nicht für alle Vertreter):
    • Ohne, d.h. Programmierung per ISP.
    • Optiboot, d.h. „Arduino-like“ Programmierung über Serial.
    • Micronucleus (VUSB), d.h. Programmierung à la Digispark.
  • Mehr Feineinstellungen sind möglich, wie die (De-)Aktivierung von micros()/millis() oder BOD-Level (Brown Out Detection).

Dabei möchte ich besonders den zweiten Punkt hervorheben. Die meisten ATtinys besitzen anstelle einer „echten“ I2C-, SPI- und UART-Schnittstelle eine sogenannte USI-Schnittstelle (Universal Serial Interface). Es ist zwar möglich I2C, SPI und UART über die USI-Schnittstelle zu implementieren, das erfordert aber eine entsprechende Softwarelösung. Und genau die ist in ATTinyCore schon implementiert. 

Die ATtiny Familie – Übersicht

Ich habe in Microchip Studio (ehemals Atmel Studio), der Software von Microchip zum Programmieren der AVR- und SAM-Mikrocontroller, nachgezählt: Dort könnt ihr zwischen 75 verschiedenen ATtiny MCUs auswählen. Man kann wohl eher von einer Großfamilie sprechen.

Welche ATtiny Typen ihr mit ATTinyCore programmieren könnt

Hier eine Liste der ATtiny-MCUs, die für ATtinyCore geeignet sind:

ATtiny Typen, die ihr mit ATTinyCore programmieren könnt.
ATtiny Typen, die ihr mit ATTinyCore programmieren könnt.

Die Tabelle listet nur einige wenige technische Eigenschaften der ATtinys auf. Wer mehr wissen möchte und keine Lust hat, lange Datenblätter zu lesen, dem kann ich wirklich wärmstens empfehlen, in der ATTinyCore Dokumentation auf GitHub zu stöbern.

Nicht abgedeckte ATtiny Typen in ATtinyCore

Es gibt ein weiteres Paket von Spence Konde mit dem Namen megaTinyCore. Dieses deckt die rechts aufgelisteten ATtiny-Typen ab, die sich fundamental von den anderen Familienmitgliedern unterscheiden. Sie werden nicht über ISP, sondern über UPDI  (Universal Programming and Debugging Interface) programmiert. UPDI ist ein „single-wire“ Verfahren, das also über ein einziges Datenkabel läuft.

Über die UPDI-basierten ATtinys werde ich später einmal einen separaten Beitrag machen. Zunächst muss ich mich da selbst noch einarbeiten.

Warum sollte ich ATtiny MCUs verwenden?

Vergleicht ihr die Leistungsstärke von ATtiny MCUs mit denen eines ESP32, ESP8266 oder ATmega Typen, dann sehen die ATtinys nicht unbedingt gut aus. ABER: Sie sind klein, sie sind stromsparend und in der Regel günstig. Für viele Projekte sind die großen MCUs überdimensioniert.

Vorbereitung der Arduino IDE

Geht in der Arduino IDE auf Datei → Einstellungen. Klickt auf das Symbol neben „Zusätzliche Boardverwalter-URLs“. Im aufpoppenden Fenster tragt ihr die folgende Zeile ein:

https://drazzy.com/package_drazzy.com_index.json

Dann schließt ihr die Fenster mit Klick auf „OK“.

ATtiny Programmierung mit der Arduino IDE: Boardverwalter URL für ATTinyCore eintragen
Boardverwalter URL für ATTinyCore eintragen

Nun navigiert ihr zu Werkzeuge → Board → Boardverwalter. Gebt „attiny“ als Suchbegriff ein und installiert ATTinyCore von Spence Konde.

ATtiny Programmierung mit der Arduino IDE: ATTinyCore Paket installieren
ATTinyCore Paket installieren

Wenn alles geklappt hat, dann solltet ihr jetzt ATTinyCore unter den auswählbaren Boardgruppen finden:

Riesenauswahl an ATtinys und Optionen nach Installation von ATtinyCore
Riesenauswahl an ATtinys und Optionen

Upload von Sketchen auf den ATtiny

Jetzt kommt der interessantere Teil, denn jetzt laden wir Sketche auf den ATtiny. Dabei gibt es, wie schon erwähnt, drei Methoden. Als Anschauungsobjekt verwende ich den beliebten ATtiny85. Ich habe aber auch einen ATtiny4313, einen ATtiny861 und einen ATtiny1634 erfolgreich mit den jeweils verfügbaren Optionen getestet.

Zur besseren Orientierung ist hier die Pinbelegung des ATtiny85:

Pinout des ATtiny85
Pinout des ATtiny85

Die hier vorgestellten Methoden lassen sich leicht auf die anderen ATtinys übertragen.

Option 1: Upload ohne Bootloader (ISP)

Die gängigste, „natürliche“ Methode, einen Mikrocontroller zu programmieren, ist ISP (In-System-Programming). Die Bezeichnung soll verdeutlichen, dass der Mikrocontroller in seiner Anwendungsumgebung programmiert werden kann. Er muss also nicht vor seinem Einbau separat vorbereitet werden.

Die ISP Programmierung erfolgt über die Pins der SPI Schnittstelle. Da auch die Pinbezeichnungen gleich sind (MOSI, MISO, SCK) ist die Verkabelung einfach.

Variante 1: Der Arduino als ISP Programmer

Vorbereitung

Die schlechte Nachricht ist, dass ihr zum Programmieren per ISP einen Programmer braucht. Die gute Nachricht lautet, dass ihr einen Arduino UNO oder Nano zum Programmer machen könnt. Dazu müsst ihr nur eines tun:

  • Ladet den Sketch ArduinoISP auf das Board, das als Programmer dienen soll. Ihr findet den Sketch in der Arduino IDE unter Datei → Beispiele → Mitgelieferte Beispiele → ArduinoISP.

Jetzt verbindet ihr euren eben erzeugten Programmer wie folgt mit dem ATtiny (Beispiel Arduino Nano):

Arduino Nano als ISP Programmer für den ATtiny85
Arduino Nano als ISP Programmer für den ATtiny85

Auf dem Arduinoboard ist MOSI der digitale Pin 11, MISO ist 12 und SCK ist 13. Wo sich die entsprechenden Pins beim Mikrocontroller befinden, ist leicht über sein Pinoutschema herauszubekommen. Den digitalen Pin 10 des Arduino verbindet ihr mit dem Resetpin des ATtiny. An den Reset-Pin des Arduino hängt ihr noch einen Kondensator (10 µF). Die LED an PB4 verwenden wir später. Für die Programmierung braucht ihr sie nicht.

Falls ihr erst die Schaltung aufgebaut habt und dann den ArduinoISP Sketch hochladen wollt, kann der Kondensator Probleme bereiten. Entfernt ihn beim Hochladen.

Hochladen
Settings für den ATtiny in der Arduino IDE
Settings für den ATtiny85

Jetzt wählt ihr in der Arduino IDE die Boardfamilie und das Board aus.

Dann könnt ihr noch einige Einstellungen vornehmen, wie beispielsweise die Taktrate. Lasst die weiteren Optionen am besten erst mal so wie sie sind.

Als Programmer stellt ihr „Arduino as ISP“ ein.

Vor dem ersten Programmupload klickt ihr auf „Bootloader brennen“. Das ist irreführend, denn es wird kein Bootloader gebrannt, sondern es werden lediglich die sogenannten Fuse-Bits gesetzt. Dabei handelt es sich um nicht-volatile, also permanent eingestellte Bits, mit denen die eben beschriebenen Einstellungen im Mikrocontroller vorgenommen werden.

Und nun könnt ihr endlich einen Sketch hochladen. In der neuen Arduino IDE (Version >= 2.0) müsst ihr dazu Strg + Shift + u drücken oder über das Menu gehen: Sketch → Mit Programmer hochladen. Für gewöhnlich teste ich erst einmal, ob ein einfacher Blinksketch wie der folgende funktioniert:

int ledPin = 4;

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

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

 

Variante 2: Andere ISP-Programmer verwenden

Programmer-Übersicht
USBtinyISP Programmer
ISP Breadboardadapter
ISP Breadboardadapter

Wenn ihr hinsichtlich der ATtiny Programmierung auf den Geschmack gekommen seid, empfehle ich die Anschaffung eines ISP Programmers. Eine preiswerte Option ist der USBtinyISP, den ihr für <10 Euro z.B. bei Amazon bekommt. Falls ein Treiber benötigt wird, schaut hier bei Adafruit.

Am besten investiert ihr dann noch in einen ISP-Breadboardapter (rechts), der euch das Leben erheblich vereinfacht und die Gefahr von Falschverkabelungen deutlich mindert.

Ähnlich günstig sind USBasp Programmer. Zu dem Teil, das ich gekauft habe (s.u.), gab es sogar eine gute Anleitung, was ja sonst leider selten ist.

USBasp Programmer

Ein etwas teurerer Programmer, der dann aber auch sowohl mit der Arduino IDE wie auch mit Microchip Studio funktioniert, ist der Diamex USB-ISP. Ihr bekommt ihn hier für etwas über 20 Euro. Alternativ gibt es diese Teile als Tremex USB ISP Programmer z. B. bei Amazon.

Diamex / Tremex USB-ISP Programmer
Diamex USB-ISP Programmer

Die Luxus-Variante ist der ATATMEL-ICE Programmer (kurz: ATMEL-ICE). Er funktioniert mit der Arduino IDE, mit Microchip Studio, beherrscht debugWire und UPID. Dafür legt ihr dann allerdings um die 150 Euro auf den Tisch…

Anschluss an den ATtiny und Hochladen
ISP Anschlusschema

Der Anschluss an den ATtiny ist mithilfe des rechts abgebildeten Schemas für den ISP Stecker selbsterklärend.

Da man sich dabei leicht vertun kann, möchte ich noch einmal für Breadboardschaltungen den schon erwähnten Adapter empfehlen.

Zum Hochladen von Sketchen wählt ihr in der Arduino IDE den Ziel-Mikrocontroller, den Programmer und brennt vor dem ersten Hochladen den Bootloader. Dann könnt ihr den ersten Probesketch hochladen.

Option 2 – Upload mit Optiboot Bootloader

Über den Optiboot Bootloader

Diese Methode ist diejenige, die auch auf den Arduino Boards zum Einsatz kommt. Der Optiboot Bootloader sorgt dafür, dass die Sketche über die serielle Schnittstelle (USI beim ATtiny, sonst UART) hochgeladen werden. Vorteilhaft ist, dass weniger Leitungen als beim Hochladen per ISP benötigt werden. Außerdem könnt ihr den seriellen Monitor wie bei Verwendung eines Arduino Entwicklungsboards benutzen. Der große Nachteil ist, dass der Bootloader fast 600 Bytes des Flashspeichers belegt. Deswegen unterstützt ATTinyCore den Optiboot-Bootloader nicht für die ATtinys mit 2 kB Speicher.

Bootloader brennen

Leider kommt ihr nicht umhin, den Optiboot-Bootloader per ISP auf den ATtiny zu brennen. D.h. zumindest einmal müsst ihr also eine der zuvor beschrieben Prozeduren (Option 1 oder 2) anwenden. Bei der Einstellung des Ziel-Mikrocontrollers wählt ihr die Optibootvariante.

USB zu TTL Adapter

Damit die USB-Schnittstelle eures PCs mit der seriellen Schnittstelle des ATtiny kommunizieren kann, braucht ihr einen Adapter. Den findet ihr in Online-Shops für wenige Euro unter der Bezeichnung „USB-zu-TTL“, „USB-UART“ oder „FT232RL-FTDI“ Adapter.

Verschiedene USB zu TTL Serial Adapter zur ATtiny Programmierung
Verschiedene USB-zu-TTL Serial Adapter

Anschluss an den ATtiny

Verbindet den RX-Pin eures Adapters mit AIN0 des ATtiny und TX mit AIN1. Dann verbindet ihr noch VCC mit VCC und GND mit GND. Der Taster an Reset des ATtiny soll nur andeuten, dass ihr Reset bei Bedarf auf GND ziehen können sollt. Das wird für den Upload bnötigt.

ATtiny – Anschluss an einen USB zu TTL Serial Adapter

Alternativ zum Taster nutzt ihr – sofern vorhanden – den DTR Pin des Adapters für den Upload. Dafür müsst ihr den DTR Pin des Adapter mit dem Reset Pin des ATtiny über einen Kondensator verbinden und einen Pull-Up Widerstand hinzufügen:

Upload mithilfe des DTR Pins
Upload mithilfe des DTR Pins

Sketche hochladen

Wählt den Port, an dem der USB-zu-TTL Adapter hängt. Es ist egal, welchen Programmer ihr einstellt. Nun ladet euren Sketch hoch. Dazu wartet ihr, bis der Sketch kompiliert ist und der eigentliche Upload beginnen soll. Dann führt einen Reset am ATtiny aus. Hier kommt jetzt der Taster zum Einsatz (oder der DTR Pin). Ich habe den Testsketch etwas erweitert, um zu prüfen, ob die Ausgabe am seriellen Monitor funktioniert.

const int ledPin = 4;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  Serial.println("Hello World");
  digitalWrite(ledPin, HIGH);   
  delay(500);                     
  digitalWrite(ledPin, LOW);    
  delay(500);                     
}

 

Option 3 – Micronucleus: wir bauen einen Digispark!

Über den Micronucleus

Der Micronucleus ist der Bootloader, der auf den Digispark Boards verwendet wird. Dabei wird der ATtiny ohne Adapter direkt über USB programmiert. Um das zu ermöglichen, nutzt der Micronucleus eine Technik namens VUSB. Damit können auch Bauteile, die keine Hardware USB-Schnittstelle besitzen, über USB angesprochen werden.

Ein gewisser Vorteil des Micronucleus ist, dass ihr den Reset-Pin des ATtiny in einen GPIO umwandeln könnt. Der Nachteil ist – wie beim Optiboot – die Reduktion des verfügbaren Flash-Speichers. Leider ist der Speicherbedarf des Micronucleus noch größer. Von den 8192 Bytes eines ATtiny85 bleiben euch nur 6586 Bytes für eure Programme.

Vorbereitung

Falls ihr noch nicht mit dem Digispark gearbeitet haben solltet, dann müsst ihr zunächst einen Treiber für den Micronucleus installieren, den ihr hier herunterladen könnt. Entpackt die Zip-Datei und führt „Install Drivers.exe“ für ein 32-Bit System aus oder „DPInst64.exe“ für ein 64-Bit System.

Dann müsst ihr auch hier zunächst den Bootloader einmalig per ISP brennen („Fresh Install“):

Bootloader brennen - Optionen der Arduino IDE
Bootloader brennen – Optionen der Arduino IDE

Für den Reset-Pin könnt ihr „Reset“ oder „GPIO“ wählen. Mit „GPIO“ habt ihr einen GPIO mehr zur Verfügung, könnt den ATtiny dann allerdings nicht mehr per ISP programmieren. Dazu müsstet ihr erst ein Bootloader-Upgrade per USB durchführen und dabei dem Reset-Pin seine Resetfunktion zurückgeben.

Schaltung

Für die Schaltung benötigt ihr, außer dem ATtiny, zwei 68 Ω Widerstände, einen 1.5 kΩ Widerstand und zwei 3.6 Volt Zenerdioden. Die Zenerdioden dienen dem Schutz der USB-Schnittstelle eures Computers, denn die Datenleitungen laufen auf 3.3 Volt. Seid also vorsichtig, was ihr tut!

Schaltung für die ATtiny Programmierung mit dem Micronucleus Bootloader
Schaltung für die Programmierung mit dem Micronucleus Bootloader

Für den USB-Anschluss empfehle ich ein USB Break-Out Modul, das ihr für < 1 Euro in Online-Shops bekommt. So sah die Schaltung dann auf dem Breadboard aus:

Breadboardschaltung à la Digispark

Welche Pins ihr bei anderen ATtinys mit den USB-Anschlüssen verbinden müsst, findet ihr in der ATTinyCore Dokumentation auf GitHub. Folgt diesem Link und klickt dann auf den ATtiny eurer Wahl.

Den vollständigen Schaltplan für einen Digispark findet ihr hier. Da ist dann auch der Festspannungsregler und die On-Board LED enthalten.

Sketche hochladen

Das Hochladen funktioniert wie bei einem Digispark. Das heißt, ihr verbindet eure Schaltung zunächst noch nicht über USB mit dem Computer. Als Programmer wählt ihr in der Arduino IDE den „Micronucleus“. Dann startet ihr das Hochladen. Die USB-Verbindung stellt ihr erst her, wenn ihr dazu aufgefordert werdet:

Upload per Micronucleus
Upload per Micronucleus

Hochladen per ISP und den seriellen Monitor nutzen

Ihr wollt keinen Bootloader und trotzdem den seriellen Monitor nutzen? Da gibt es zwei Möglichkeiten.

Option 1: zusätzlich den USB zu TTL Serial Adapter verwenden

Ihr verfahrt zum Hochladen der Sketche so, wie oben für ISP beschrieben und schließt zusätzlich den USB-zu-TTL Adapter an. In der Schaltung unten verwende ich dafür die Serial Pins AIN0 und AIN1. Alternativ könnt ihr auch ein SoftwareSerial einrichten.

Arduino als ISP mit USB zu TTL Adapter für den seriellen Monitor
Arduino als ISP mit USB-zu-TTL Adapter für den seriellen Monitor

Option 2: mit modifiziertem ArduinoISP Sketch

Eine schöne Alternative habe ich hier gefunden. Ein schlauer Mensch hat den ArduinoISP Sketch so modifiziert, dass ihr keinen zusätzlichen Adapter braucht, um den seriellen Monitor zu nutzen. Sehr smart! Ich habe es ausprobiert und es funktioniert einwandfrei.

Danksagung

Das Paket ATTinyCore von Spence Konde ist einfach fantastisch!  Vielen Dank.

81 thoughts on “ATtiny mit Arduino Code programmieren

  1. Hallo Wolfgang!

    Ich habe hier so einen MH-ET LIVE (bzw. 5 Stück) und einen USBTinyISP-Programmer (alles China > spottbillig).
    Der MH-ET ist ja ein ATTiny88 und es funktioniert alles bestens.

    Ich habe nur eine Frage zu den Einstellmöglichkeiten.

    Board: ATTiny48/88 (No Bootloder)
    Programmer „USBtiny (ATTinyCore) FAST …

    und dann kommt der Menüeintrag: tinyNeoPixel port mit vier Auswahlmöglichkeiten

    1. Port A (pins 23-28)
    2. Port B (pins 16-22,27)
    3. Port C (pins 9-13)
    4. Port D (pins 0-7)

    Voreingestellt ist die erste Möglicjkeit.
    Was ist das alles?

    Gruß
    Michael

    1. Hallo Michael,
      das muss dich nur interessieren, wenn du etwas mit NeoPixel machst. Sonst einfach ignorieren. Hier gibt es was über NeoPixel:
      https://pglu.ch/was-sind-neopixel/
      Und hier ist die Dokumentation für das Boardpaket:
      https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/avr/extras/tinyNeoPixel.md#tinyneopixel—a–library-for-ws2812-neopixel-and-similar-at-full-range-of-supported-clock-speeds
      VG, Wolfgang

  2. Hallo Wolfgang,

    Ich versuche gerade, dem ATtiny85 einen seriellen Output zu entlocken. Angeblich funktioniert hier nur SoftwareSerial. Aber wenn ich den Bordverwalter von Konde nutze (zuerst hatte ich nur den Seeduino installiert), gibt es dort ein einziges Beispielscript, welches einen seriellen Output mit dem ’normalen‘ Serial-Befehl erzeugt. Heißt das, dass ATtinyCore hier gezielt ‚eingreift‘?
    Kannst du mir bitte sagen, wie ich sehen kann, mit wieviel Mhz mein Chip läuft? Ich verstehe das mit den Takten und den Fuses noch nicht so recht.
    Und eine letzte Bitte: ich bin es noch nicht gewohnt, so sehr auf die Größe des Scriptes zu achten und stoße schnell an die Grenzen des Chips (trotz ‚beachtlicher‘ 8 kb). Kannst du mir einen schmalen Countdown-Timer empfehlen, der wenig Speicher verbraucht?

    Danke und liebe Grüße,
    Martin

    1. Hallo Martin,

      ja, der ATtiny85 hat keine UART Schnittstelle, wie sie normalerweise für Serial genutzt wird. Es gibt aber verschiedene Wege, eine UART Schnittstelle zu emulieren. Dazu zählt SoftwareSerial oder die Nutzung der USI Schnittstelle. Spence Konde hat einen eigenen Weg eingeschlagen, der hier beschrieben ist:

      https://github.com/SpenceKonde/ATTinyCore?tab=readme-ov-file#i2c-spi-and-serial

      Wegen der Taktfrequenz: Lade einfach mal einen Blinksketch hoch, wähle als Einstellung in der Arduino IDE z.B. „8 MHz intern“ und schau, ob die Blinkfrequenz stimmt. Du kannst mit „1 MHz intern“ auch mal dagegen testen. Wenn du einen anderen Takt einstellen willst, dann stell den Takt deiner Wahl ein und brenne den Bootloder. Dafür brauchst du allerdings einen Programmer oder nutzt einen Arduino als Programmer. Ich empfehle aber ein paar Euro in einen Programmer zu investieren. Das mit dem Arduino funktioniert zwar einwandfrei, ist aber eine Fummelei.

      Zum Countdown Timer: Da kann ich nicht wirklich was empfehlen, so etwas würde ich immer über millis oder über Timer-Interrupts selbst bauen.

      VG, Wolfgang

  3. Hallo Wolfgang,
    ich habe beim Hochladen von Sketchen auf Attiny85 das eigentlich harmlose Problem, dass ich jedesmal den Bootloader vorher neu brennen muss. Sonst kommt folgende Meldung:

    avrdude: verification error, first mismatch at byte 0x000a
    0x24 != 0x36
    avrdude: verification error; content mismatch
    Fehlgeschlagenes Hochladen: Hochladefehler: exit status 1

    Ich verwende die IDE2.3.1 auf Linux mint, zwei verschiedene Arduino Unos als ISP (immer die gleiche Meldung) und brenne den Optiboot. Neuinstallieren der IDE hat nichts geändert.
    Vor einigen Jahren war das bei der gleichen Charge Attiny85 und denselben Arduinos nicht der Fall.
    Hast Du eine Idee, woran es liegt?

    1. Hallo Georg, das ist ja eigenartig. Aber etwas habe ich noch nicht verstanden. Also, du verwendest den Arduino UNO als ISP um den Optiboot Bootloader zu brennen. Das macht man ja eigentlich nur, wenn man die Sketche danach mit einem USB-zu-TTL Adapter per RX/TX hochladen möchte. Ist das, was du eigentlich vorhast und kommt dann die Fehlermeldung? Oder willst du auch per Arduino as ISP die Sketche hochladen? Für letzteres Vorhaben müsstest du „ATtiny25/45/85 (No Bootloader)“ als Board und als Chip ATtiny85 auswählen und dann den Bootloader brennen. Das mag sinnlos erscheinen, da du ja keinen Bootloader auf dem ATtiny85 habe willst, aber in dem Fall heißt „Bootloader brennen“ nur die Fuses zu setzen. Danach müsstest du eigentlich Sketche uploaden können ohne weiteres Brennen des Bootloaders.
      VG, Wolfgang

      1. Hallo Wolfgang,
        danke für die schnelle Antwort. Den Optiboot habe ich schließlich gewählt, weil es anders nicht funktionierte. Habe das gerade noch einmal geprüft: Wenn ich die Option „ATtiny25/45/85 (No Bootloader)“ wähle, ist automatisch beim Chip der ATtiny85 gewählt. Klicke ich dann auf Bootloader brennen, kommt die Meldung, dass es funktioniert hat. Beim anschließenden Versuch, den Blink-Sketch auf den ATtiny zu laden kommt aber die Fehlermeldung „No programmer“. Brenne ich dann Optiboot, kann ich wieder einmal einen Sketch hochladen.
        Ist es möglich, dass man nicht mehr alles vom Optiboot weg bekommt, wenn man den einmal gebrannt hatte, oder woran könnte es noch liegen? Vielleicht habe ich irgendwas noch nicht verstanden.
        Gruß von Georg

        1. Hallo Georg, ich glaube, ich weiß jetzt, woran es liegt. Du musst zum Hochladen mit der Arduino IDE 2.x.y entweder Ctrl/Shift/u wählen oder per Menü über Sketch -> „Mit Programmer hochladen“ wählen. Was mit AttinyCore in den Versionen 2.x.y nicht funktioniert, ist die Kombination Shift + Klick auf das Pfeilsymbol (wohl aber in den Versionen 1.x.y).
          Sehr kurios ist – aber ich konnte es reproduzieren – dass nach dem Brennen des Optiboot Bootloaders der einfache Klick auf das Pfeilsymbol zum Hochladen per ArduinoISP ausreicht. Warum auch immer. Das führt einen natürlich auf völlig falsche Fährten. Hätte es gar nicht funktioniert, wärst du vielleicht schon drauf gekommen.
          VG, Wolfgang

          1. Es klappt. Genial!
            Die Blumen kommen jetzt erst hinterher: Es ist bewundernswert, was Du hier für ein Webangebot aufrecht erhältst. Und zusammen damit, dass Du auch noch persönlich erreichbar bist, ist das schon eine Art Alleinstellungsmerkmal.
            Also noch einmal vielen Dank für die Mühe.
            Gruß von Georg

  4. Hallo Wolfgang,
    wenn ich den ATTiny45 mit der Arduino IDE programmiere , kann ich dann die Funktion „millis()“ für einfaches Timing verwenden?
    Mein Sketch wird problemlos kompiliert, es kommen jedoch folgende Fehlermedungen:
    lade Bibliothek von g:\Franz\Technologie\Software\Arduino\libraries\index: ungültige Bibliothek: keine Header-Dateien gefunden
    lade Bibliothek von g:\Franz\Technologie\Software\Arduino\libraries\wimleers-flexitimer2-v1.1-0-g7338cfb: ungültige Bibliothek: keine Header-Dateien gefunden

    1. Hallo Franz,

      ja, millis() ist implementiert. Bei dem Paket AttinyCore ist millis() auch standardmäßig aktiviert. Unter Werkzeuge findest du den Eintrag millis()/micros() und da sollte „Enabled“ stehen.

      Ich habe mir mal die wimleers/flexitimer2 Bibliothek angeschaut. Anscheinend nutzt sie den Timer2, den es auf dem Attiny45 nicht gibt. Passt die Fehlermeldung allerdings irgendwie nicht dazu.

      Viel Erfolg!

      Schöne Grüße, Wolfgang

        1. Hallo Wolfgang,
          es klappt mit dem ATtiny soweit alles sehr gut. Ein offenes Problem habe ich jedoch noch mit dem Paket ATTinyCore. Ich habe die URL: „http://drazzy.com/package_drazzy.com_index.json“ eingetragen und das Paket wird auch heruntergeladen. In der Bibliotheksverwaltung scheint ATTinyCore jedoch nicht auf. Die Version meiner Arduino-IDE ist 2.2.1. Kann es sein das die Library nicht mit dieser Version kompatibel ist?
          LG Franz

          1. Hallo Franz,
            ich habe das Paket mal „spaßeshalber“ de- und reinstalliert. Das klappt bei mir mit Arduino 2.2.1 und ATtinyCore 1.5.2. Keine Ahnung, warum es bei dir nicht geht.

            Wo es definitiv ein Problem gibt, ist die Installation der neuesten ATtinyCoreVersion 2.0.0. Das ist auch hier schon mal „angemeckert“ worden:
            https://github.com/SpenceKonde/ATTinyCore/issues/783

            Was klappen sollte, ist die manuelle Installation.
            1. Falls es ihn noch nicht gibt, erstelle einen Ordner „hardware“ (ohne die Anführungszeichen) in deinem Sketch-Ordner.
            2. Lade das Paket als zip Datei herunter. Dazu gehst du auf diese Seite:
            https://github.com/SpenceKonde/ATTinyCore
            dort gehst du auf das grüne Feld „Code“ und dann auf „Download Zip“.
            3. Entpacke die Zip-Datei (irgendwo).
            4. Nimm den entpackten Ordner „ATTinyCore-2.0.0-devThis-is-the-head-submit-PRs-against-this“ und ziehe ihn den Ordner „hardware“.
            5. Starte die Arduino IDE.

            Die Version 2.0.0 könnte noch Fehler haben. Wenn du lieber die etablierte Version 1.5.2 manuell installieren möchtest, dann lade das Paket hier herunter:
            https://github.com/SpenceKonde/ATTinyCore/releases
            Alle anderen Schritte bleiben gleich.

            Viel Erfolg!
            VG, Wolfgang

            1. Hallo,
              danke für den Tipp. Hatte das gleiche Problem (Version 2.2.1 auf Linux Mint), dass das Herunterladen zwar klappt, aber der Core nicht zur Verfügung steht. Nachdem ich im Sketchordner den Ordner „hardware“ wie beschrieben angelegt und gefüllt habe, taucht der Core jetzt als „ATTinyCore (in Sketchbook)“ auf.

  5. Hallo Wolfgang,
    Ich konnte und kann immer noch ATTiny 85 mit der Arduino IDE 1.8.19 mit einem Arduino uno als Programmieradapter (Arduino as ISP) programmieren. Mit der Arduino IDE 2.2.1 und sicher auch auch mit den Vorgängerversionen, geht das nicht mehr. Fehlermeldung: „Zum Hochladen ist ein Programmer benötigt“. So steht das da. Ein andere Programmieradapter, wie der USBasp zeigte die selbe Fehlermeldung. Es wird kein Programmieradapter gefunden.
    Ich habe schon versucht in den Foren fündig zu werden, leider nein. In einem Forum bin ich auf den Ordner „extras“ gestoßen, der ist in der 2.2.1. leer. In der 1.8.19 ist da was drin. Das habe ich in der 2.2.1. versuchsweise eingefügt, aber ohne Erfolg (Programm geschlossen, PC NEU gestartet). Nun bin ich erst mal mit meinem Latein am Ende.
    Hast du vielleicht schon eine Lösung für andere und mich ?
    Viele Grüße

    1. Hallo Matthias, da gibt es ein skurriles Phänomen. Wahrscheinlich hast du Shift gedrückt und auf den Upload Pfeil geklickt. Das geht – warum auch immer – nicht. Die gute Nachricht ist: über das Menü Sketch –> Mit Programmer hochladen funktioniert es und ebenso mit Ctrl + Shift + u. War es das?
      VG, Wolfgang

      1. Hallo Wolfgang, es funktioniert wieder. Es hatte aber nichts mit Ctrl + Shift + u. zu tun. Der Punkt „Menü Sketch –> Mit Programmer hochladen“ war mir nicht geläufig. Das Hochladen hatte ich bisher immer über den grünen Pfeil oben links realisiert. Damit gibt es bei der Version 1.8.x auch keine Probleme.
        Wenn es in der Version 2.2.x nun anders ist, kann ich damit leben. Nun ist es mir ja bekannt.
        Vielen Dank für die schnelle Hilfeleistung.
        Viele Grüße, Matthias

  6. Versuche den ATtiny2313 mit USBasp über ISP mit der IDE zu programmieren. Als „Board“ wurde ATtinyCore-ATtiny2313/4313, als Programmer USBasp (ATtinyCore) „zwangsläufig“ gewählt. Es gibt keinen USBasp (einfach). Ganz einfaches Programm getestet und ok. Library in Deinem Text installiert. Beim Hochladen aber Fehlermeldung:
    „avrdude: set SCK frequency to 187500 Hz
    avrdude: warning: cannot set sck period. please check for usbasp firmware update.
    avrdude: error: program enable: target doesn’t answer. 0
    avrdude: initialization failed, rc=-1
    Double check connections and try again, or use -F to override for this check“

    Verbindungen sind überprüft und mit cmd: avrdude -p tiny2313 -c usbasp bekomme ich auch die Meldung, dass der ATtiny unter der korrekten Signatur erkannt wird. Hochladen auf ATmega8 (Board) mit USBasp zeigt ein anderes avrdude Ergebnis:
    „avrdude: auto set sck period (because given equals null)
    avrdude: AVR device initialized and ready to accept instructions
    avrdude: device signature = 0x1e9307 (probably m8)“
    Was mache ich falsch?

    1. Hallo, kurze Antwort: nichts! Lange Antwort: ich habe gerade zwei USBasp Adapter ausprobiert und bekomme mit beiden dieselbe Warnung. Allerdings klappt der Upload trotzdem (zumindest bei mir). Dann habe ich nach „avrdude: warning: cannot set sck period. please check for usbasp firmware update“ gegoogelt und gesehen, dass wir wohl nicht allein sind mit dieser Meldung. Um die Meldung wegzubekommen, muss man tatsächlich die Firmware des Programmers aktualisieren. Hier habe ich eine Anleitung gefunden, die ich allerdings nicht selbst ausprobiert habe:
      https://kopterforum.at/viewtopic.php?t=825
      Ich werde meine Programmer so lassen, wie sie sind und die Warnung ignorieren.
      VG, Wolfgang

      1. Hallo Wolfgang, merci für die rasche Antwort. Bei mir wird beim ATtiny2313 mit ATtinyCore nichts hochgeladen. Nur der Fehler erscheint, dann Abbruch. Ich habe 2 USBasp, einen Selbstgebauten mit der neuesten Firmware 2005 und einen Gekauften V2.0, der m.E. auch eine neue FW haben sollte (gekauft 2021). Beide melden den gleichen Fehler und laden nicht hoch. Beide habe ich mit meinen Boards ATmega8, 168, 328PB ohne Probleme probiert. Auch lässt sich der Tiny2313 prroblemlos über avrdude von der CMD-line aus ansprechen, ebenso mit Studio7 über ISP programmieren. Ich schließe daraus, dass das Problem doch an ATtinyCore hängt. Man müsste halt die Befehlssequenz von avrdude in ATtinyCore kennen, dann wäre man vielleicht weiter.
        Mich wundert z.B. dass „avrdude: set SCK frequency to 187500 Hz“ gesetzt wird. Diese Zeile erscheint bei der Programmierung mit Studio7 oder CMD nicht.
        Falls Du noch eine Idee hast, bin ich sehr dankbar, da ich mich eigentlich mal auf eine IDE konzentrieren und nicht dauernd umlernen will.
        Gruß Werner

        1. Hallo Werner, da ich das Problem bei mir nicht reproduzieren kann, sind meine Möglichkeiten zu helfen begrenzt.

          Du könntest noch probieren, den Bootloader zu brennen. Dabei wird nicht wirklich ein Bootloader gebrannt, sondern nur die geeigneten Fuses gesetzt. Vielleicht ist da irgendetwas im Argen.

          Vielleicht findest du hier noch einen Hinweis:
          https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/avr/extras/Ref_Programming.md

          Ansonsten bleibt noch der Weg, das Problem als Issue direkt auf GitHub zu adressieren.

          Und vielleicht könntest du mir noch einmal die komplette Meldung beim Hochladen zusenden (wolfgang.ewald@wolles-elektronikkiste.de). Vielleicht sehe ich ja doch noch was.
          VG, Wolfgang

          1. Hallo Wolfgang, sitze wieder vor meinem ATtiny2313A und „spiele rum“. Bin jetzt in der Lage den Kleinen zu programmieren (dazu musste ich an meinem USB Hub einen anderen Slot für den USBasp benutzen – warum ???). Also erstes Problem gelöst.
            Nun wollte ich mein Standard Arduino_I2C-LCD anschließen mit kleinem Programm, Wire.h und LiquidCrystal_I2C.h. Hochladen meldet ok (habe vorher die Fuses gesetzt mit BL brennen).

            /* ATtiny2313A Testprogramm */
            #include
            #include
            LiquidCrystal_I2C lcd(0x27, 16, 2);  // Standard

            void setup() {
              Wire.begin();
              lcd.init();
              lcd.backlight();  // Beleuchtung an (
              delay(200);
              lcd.setCursor(0, 0);        // Zeile 1, Spalte 0
              lcd.print(“ ATtiny Test“);  // Reklame
              delay(2000);
            }

            void loop() {
              lcd.clear();
              lcd.setCursor(0, 0);  // Zeile 1, Spalte 0
              lcd.print(„Hallo“);
              lcd.setCursor(0, 1);  // Zeile 2, Spalte 0
              lcd.print(„2te Zeile“);
              delay(3000);
            }

            Ergebnis: LCD wird kurz hell und bleibt dann aus. RESET -> gleiches Ergebnis. Habe versucht, die von Dir empfohlenen Beschreibungen bei Github zu lesen und damit einen Fehler zu erkennen, war aber erfolglos. I2C wird dort ja beschrieben und auf den USI beim ATtiny hingewiesen. Nirgendwo steht, ob mit der LiquidCrystal_I2C.h Library über Wire.h der USI korrekt gesteuert wird. Die Widerstände (wohl das größte Problem) sind im I2C-Baustein eingebaut. Unklar bleibt auch die Einstellungen für das „ATtiny-Board“. Unter Werkzeuge wird von Neopixel auf PORTA geschrieben. PORTA gibt es beim ATtiny2313A nicht. Dann ist mir LTO kein Begriff deshalb habe ich auf „diabled“ gesetzt.
            Ich habe dann das Programm auf dem ATmega8 laufen lassen (natürlich mit dem „ATmega8-Board“). Dort läuft es problemlos.
            Meine Frage: kann ich mit dem ATtinyCore die beiden I2C-Bibliotheken Wire und LiquidCrystal_I2C benutzen? Wird USI von den Bibliotheken unterstütz?
            Gruß Werner

            1. Hallo Werner,

              Hier habe ich etwas zu dem Thema gefunden:

              https://www.instructables.com/Using-an-I2C-LCD-on-Attiny85/

              Dort steht:
              The standard Arduino library cannot be used for I2C on the Attiny because it does a call to ‚Wire.h‘ and that one is not compatible with the Attiny.

              Es gibt also ein generelles Problem. Aber in dem Artikel werden Lösungsmöglichkeiten genannt, sogar explizit für den ATtiny2313.

              Vielleicht geht es ja damit – viel Glück!

              VG, Wolfgang

              1. Hallo Wolfgang,
                zuerst danke für die Mühe. Habe den Link studiert und in mein Programm TinyWireM.h, die „neue“ LiquidCrystal_I2C.h und den Aufruf „TinyWireM.begin()“ eingebaut und die „alte“ LiquidCrystal_I2C.h aus der library entfernt. Dann die IDE neu gestartet und kompiliert. Ergebnis: 1000 Fehler in Bezug auf USI_TWI_Master.cpp:

                ###########################
                c:\Users\w-fre\Documents\Arduino\libraries\TinyWireM\USI_TWI_Master.cpp: In function ‚void USI_TWI_Master_Initialise()‘:
                c:\Users\w-fre\Documents\Arduino\libraries\TinyWireM\USI_TWI_Master.cpp:64:3: error: ‚PORT_USI‘ was not declared in this scope
                PORT_USI |= (1 << PIN_USI_SDA); // Enable pullup on SDA, to set high as released state.
                ^~~~~~~~
                c:\Users\w-fre\Documents\Arduino\libraries\TinyWireM\USI_TWI_Master.cpp:64:3: note: suggested alternative: 'PRUSI'
                PORT_USI |= (1 << PIN_USI_SDA); // Enable pullup on SDA, to set high as released state.
                ^~~~~~~~
                PRUSI
                usw viele viele Male!
                ###########################

                Also habe ich die Bibliotheken untersucht und festgestellt, dass in der USI_TWI_Master.h die PORT-Daten für den ATtiny2313 explizit und korrekt aufgeführt sind (genau wie gefordert). Auch ist die Bibliothek in der TinyWireM.cpp und USI_TWI_Master.cpp korrekt eingebunden.
                Bin mit meinem Latein am Ende. Habe das Gefühl, dass entweder die USI_TWI_Master.h oder die #if defined(__AVR_AT90Tiny2313__) | defined(__AVR_ATtiny2313__) nicht erkannt werden????

                Gruß Werner

                1. Hallo Werner,

                  ich kann aus der Ferne nicht sagen, woran es liegt, zumal ich die Anleitung selbst nicht ausprobiert habe. Vor nächster Woche komme ich auch nicht dazu.

                  VG, Wolfgang

                  1. Hallo Wolfgang,
                    kein Problem. Bin sehr froh, dass Du mir hilfst. Ich habe ja Zeit, selbst daran zu arbeiten. Habe gestern abend noch ein Programm für den ATtiny2313 mit praktisch der gleichen Anzeige aber mit dem Studio7 in Assembler geschrieben (USI statt TWI) und siehe da, alles klappte problemlos und komischerweise konnte ich mit meinem USBasp auch über den USB Hub laden, der mit der IDE nicht funktioniert. Ich werde jetzt mal den Oszi anwerfen und mir die Impulsketten anschauen. Irgendwo hängt das Ganze bei der IDE.
                    Gruß Werner

                    1. Hallo Wolfgang,
                      habe das Problem gelöst. Die „neue“ LiquidCrystal_I2C lib ist nicht in Ordnung. Vergleicht amn nur .h Datei, dann fällt auf, dass für zB den EN Impuls ein anderes Bit benutzt wird wie bei der alten lib. Also habe ich die alte .h durch den Verweis auf TinyWire, wenn die ATtinys benutzt werden, ergänzt und siehe da es läuft. Allerdings belegt die Arduino SW das ganze verfügbare flash (2000Bytes), bei Studio7 nur 840 Byte davon.
                      Mein Schluss: ATtiny2313 nicht mit Arduino programmieren.
                      Gruß Werner

                    2. Hallo, das freut mich zu hören! Viel Spaß und Erfolg noch!
                      VG,Wolfgang

  7. Hallo Wolfgang,

    Danke für die Anleitung. Cool, mit wie wenig Bauteilen man diese kleinen Controller betreiben und programmieren kann. Ich habe allerdings irgendein Timing/Clock-Problem:
    Ich habe folgenden Code in den ATtiny85 (ohne Bootloader) mit einem AVRisp mkII kompatiblen Gerät geflasht. Zum Glück hatte ich das Teil bereits, da ich mien Arduino Nano mit neuem Bootloader bestücken wollte.

    #define OFFTIME 30
    #define ONTIME 10
    #define PAUSE 400
    #define LED_OUT LED_BUILTIN
    #define FLASH_COUNT 8

    int i;

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

    void loop() {
    for (i = 0; i < FLASH_COUNT; i++) {
    digitalWrite(LED_OUT, HIGH); // turn the LED on (HIGH is the voltage level)
    delay(ONTIME);
    digitalWrite(LED_OUT, LOW); // turn the LED off by making the voltage LOW
    delay(OFFTIME);
    }
    delay(PAUSE);
    }

    Auf dem Nano blitzt die LED jeweils nur 8 mal ganz kurz auf, macht eine Pause usw. Hier mit dem ATtiny85 ist das nun deutlich langsamer. Ich würde vermuten, so locker Faktor 6-8. Ich habe keine besonderen Einstellungen vorgenommen, was CPU-Frequenz usw. anbelangt. D.h. die Eistellung ist 8MHz internal und Timer/Clock steht auf CPU-Frequenz und nicht auf 32 bzw. 64MHz. (Eigentlich müsste das dann ja noch langsamer werden, oder?)

    Wo ist da mein Denkfehler?

    Viele Grüße,
    Thomas

    1. Hi Thomas,
      klicke mal auf Booloader brennen. Du willst zwar keinen Bootlader haben, aber wenn du die Option ohne Bootloader ausgewählt hast, dann werden in dem Fall nur die eFuses gesetzt, mit denen u.a. die Taktrate eingestellt wird. Ich vermute dein ATtiny läuft auf 1 MHz.
      VG, Wolfgang

      1. Hallo Wolfgang,

        Danke für den Tipp. Ich konnte im ersten Test zwar nur den Optiboot und nicht den Micronucleus brennen, aber jetzt stimmt das Timing-Verhalten des Chips. In der Arduino-Oberfläche (ich habe mich aus Gründen noch nicht getraut, auf die 2.x zu aktualisieren) steht auch etwas davon. Wäre schön, in der Arduino-IDE ein eFuse-Tool zu haben. Vor diesen Sicherungen habe ich echt Respekt. Ich habe mir vor einigen Jahren mal einen 328P damit geziegelsteint.
        Das mit dem Micronucleus Bootloader muss ich aber auch noch irgendwie hinbekommen, denn ich habe da aus der Bucht so ein paar keine Platinen für den AT85 mit microUSB-Anschluss und dem Dioden-Gedöns, so dass sich der Chip dann darüber programmieren lassen sollte. Im Moment steckt der µC auf einem Breadboard und ist mit 6 Strippen mit dem ISP verbunden. Frickelig halt…

        Viele Grüße,
        Thomas

        1. Huhu, okay, der andere Bootloader für „Digispark“ ist jetzt auch mal gebrannt… Man muss extra noch einmal die Programmiert-Methode auf Fresh/ISP oder ähnlich umstellen. Dann kommt auch kein Timeout… Ich merke, steile Lernkurve…

  8. Hallo Wolfgang,
    ich habe den Sketch zum „USB zu TTL Adapter“ ausprobiert. Die LED blinkt, auch die am Adapter , der serielle Monitor zeigt aber leider nicht den Text an, sondern nur verdrehte Fragezeichen. Als Adapter habe ich einen FTDI232 angeschlossen. Das gleiche Ergebnis hatte ich auch schon vorher bei anderen Versuchen, den Attiny85 mit dem seriellen Monitor zu verbinden, unter anderem mit SoftwareSeriel.h . Zum Programmieren des Attiny verwende ich den Diamex USB-ISP Programmer. Ich bin jetzt ziehmlich ratlos, vielleicht hast du eine Idee was ich ändern sollte.
    Gruß Wolfgang Keller

    1. Hallo Wolfgang,

      umgedrehte Fragezeichen treten meistens auf, wenn die Baudrate im Sketch nicht mit der Baudrate im seriellen Monitor übereinstimmt – kannst du das prüfen?

      VG, Wolfgang

      1. Hallo Wolfgang,
        danke für die schnelle Reaktion. Ja, die Baudraten sind die gleichen. Zur Sicherheit habe ich das Programm mit der IDE 2.1.1 als auch mit der 1.8.16 ausgeführt, mit den gleichen Ergebnissen.

        Gruß
        Wolfgang

        1. Also, du kannst den Sketch über den Adapter hochladen? D. h. du hast den Bootloader (den mit Optiboot) zunächst per ISP gebrannt und dann den Sketch über den Adapter hochgeladen (nicht per ISP) und dann funktioniert die Ausgabe nicht? Das ist recht eigenartig, denn wenn das Hochladen über den Adapter klappt, ist die serielle Verbindung ja prinzipiell in Ordnung. Das macht mich etwas ratlos. Kannst du mir nochmal sagen, welchen ATtiny du verwendest und welchen Bootloader du gewählt hast?

          1. Ich habe den Sketch über den Diamex USB-ISP Programmer hochgeladen. Ich verwende den Attiny85. Außerdem habe ich die Bibliothek AttinyCore installiert und verwende daraus Attiny25/45/85 (ohne bootloader). Nach dem Hochladen des Sketches schließe ich den Attiny85 über den FTDI232 an einen USB-Eingang am PC an (Port 5). Dann ruf ich über die Arduino IDE den seriellen Monitor auf und erhalte das geschilderte Ergebnis.

            1. Ach so, du nutzt den USB zu TTL Adapter nur für den seriellen Monitor. Im Moment fällt mir kein naheliegender Grund ein. Vielleicht ein Treiberproblem? Aber dann würde ich eigentlich erwarten, dass das Modul gar nicht auswählbar ist. Wie du siehst, fange ich an zu spekulieren. Vielleicht schaust du nochmal auf GitHub in der Dokumentation des Boardpaketes oder stellst dort auch nochmal deine Anfrage. Wenn mir noch etwas einfällt, melde ich mich.

              1. Ok, danke! Ich teste auch weiter, mal mit einem neuen Attiny85. Wenn ich den Fehler finde melde ich mich auch.

                  1. Hallo Wolfgang,
                    ich hab den Fehler gefunden. Der Attiny85 war anscheinend auf 1 MHz eingestellt. Ich hab auf 8 MHz eingestellt und “ bootloader brennen“ ausgewählt, jetzt bekomme ich im seriellen Monitor den Text angezeigt.
                    Danke nochmal für deine Unterstützung.
                    Gruß
                    Wolfgang

                    1. Schön, dass du das Problem lösen konntest und danke, dass dich noch einmal gemeldet hast!

  9. Hallo Wolfgang,
    habe gerade einen neuen Rechner aufgesetzt und mußte leider feststellen das der Link

    http://drazzy.com/package_drazzy.com_index.json

    nicht funktioniert. (Webside nicht erreichbar. / mit anderem Programm vom Handy probiert mit dem Ergebnis „Server down for everyone“)

    Hast Du eine Idee wie ich die beiden Files von Spence Konde in die Arduino IDE bekomme ???

    Grüße
    Frank

    1. Hallo Frank, da scheint es ein Server Problem zu geben. Ich gehe nicht davon aus, dass das von Dauer ist. Aber ist natürlich blöd, wenn man loslegen möchte und dann werden einem Steine in den Weg gelegt. Board Packages lassen sich auch manuell installieren. Ausprobiert habe ich es selbst nicht.

      Du kannst das Paket von GitHub herunterladen. Gehe zu:

      https://github.com/SpenceKonde/ATTinyCore

      dann auf Code, Download Zip.

      Dann folge den Anweisungen „Manual Installation“, „Option 1“ hier:

      https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md

      Oder du hast noch ein wenig Geduld…

      1. Hallo Wolfgang,
        danke für die schnelle Antwort. Die „Manual Installation“ funktioniert bei mir leider nur auf meinem bestehenden (alten) Rechner mit installierter älterer Version. Da wird die neue Version 2.0.0 als ATTinyCore(im Sketchbook) angezeigt und das Prüfen / Hochladen funktioniert einwandfrei.
        Auf meinem neuen Rechner wird dies zwar ebenfalls angezeigt, aber wenn ich versuche einen Tiny zu programmieren gibt es jede Menge Fehlermeldungen…
        Nehme an ohne bestehende Installation funktioniert das nicht…
        Habe mal Spence Konde direkt angemailt, mal sehen ob ich eine Antwort bekomme 😉

        Grüße Frank

  10. Hallo Wolfgang,
    Ich habe gerade meinen Digispark Tiny 85 umgesetzt und mal die Geschwindigkeiten gemessen und war absolut erstaunt. Bisher waren die Geschwindigkeiten vom Tiny85 und vom Uno/Nano bei diesem Test in etwa gleich aber jetzt hat es mich fast umgehauen. Folgendes Testprogramm habe ich benutzt:
    const uint8_t LOOP_TEST_PIN = 1;
    uint8_t state = 0;
    void setup(void) {
    pinMode (LOOP_TEST_PIN, OUTPUT);
    digitalWrite (LOOP_TEST_PIN, LOW);
    }
    void loop(void){
    //Option 1:
    state = 1 – state;
    digitalWrite (LOOP_TEST_PIN, state);
    //Option 2:
    PORTB ^= (1<<PB1);
    //Option 3:
    PINB = bit(1);
    }
    Bitte hier nur eine Option wählen zum Nachtesten, dia anderen auskommentieren.
    Ergebnis:
    Option1: Uno/Nano 120 kHz, ATTinyCore 300 kHz
    Option2: Uno/Nano 1,13 MHz, ATTinyCore 1,6 MHz
    Option3: Uno/Nano 1,59 MHz, ATTinyCore 2,73 MHz
    jeweils gemessan am Pin PB1.
    Mit einem Zuwachs an Geschwindigkeit hatte ich eigentlich nicht gerechnet und vor allem nicht in dieser Höhe.
    Vielen Dank für den tollen Beitrag, jetzt werde ich mal I2C testen, da hatte ich mit den bisher verfügbaren Bibliotheken keinen Erfolg.
    Gruß
    Günter

    1. Hi Günter, das ist ja ein Ding! Ich hätte solche Unterschiede auch nicht erwartet. Warum das so ist – keine Ahnung, da muss ich mal nachforschen. Vielen lieben Dank! VG, Wolfgang

  11. Hallo Wolfgang,
    auf der Suche nach einer Anleitung zum Programmieren/Flashen von ATTinys über Arduino, bin ich auf deiner Seite gelandet. Es ist wirklich super erklärt und auch für einen Noob wie mich sehr verständlich. Ich habe alle Schritte befolgt, baute die „normals“ ISP Schaltung auf und konnte den Bootloader auch „brennen“, bis dahin hat alles funktioniert, nur dann beim Hochladen des Sketches kam immer der Fehler
    „Zum Hochladen ist ein Programmer benötigt“
    Ich bin bald verückt geworden, habe 10x alles überprüft, neu gesteckt, sämtliche Einstellungen versucht…
    Immer kam der gleiche Fehler. Kurz vorm hinschmeißen und ISP Programmer kaufen habe ich mich dann an das Arduino.CC Forum gewendet. Am nächsten Tag waren dann die Fehlerqellen eingekreist und wir haben den Fehler gefunden.
    Ich als Noob habe mir vor ein paar Tagen die Arduino IDE installiert, aber nicht beachtet, das es nun eine neue IDE 2.0 gibt – die gab es auch zum Zeitpunkt deines Beitrags auch noch nicht, oder? Naja, auf jeden Fall funktioniert der ATTinyCore nicht mit der IDE 2.0 oder anderst herum – das hatte icht schlichtweg nicht gewußt und beachtet (steht aber auch im der ATTinyCore Doku). IDE 1.8.19 installiert und voilà es funktioniert.

    Meinst du du könntest die Info mit in deinen Beitrag nehmen, es gibt bestimmt den einen oder anderen Anfänger der das nicht beachtet und einfach die neuste IDE installiert und sich dann wundert warum das nicht funktioniert.

    Viele Grüße
    Dennis

    1. Hallo Dennis,

      ich habe die Programmierung gerade noch einmal ausprobiert. Einmal mit einem gekauften Programmer und einmal mit einem Arduino als ISP Programmer. Ziel war ein ATtiny85. Beides hat sowohl mit der Arduino IDE 2.0.4 wie auch mit der Version 1.8.19 funktioniert. Allerdings gibt es einen kleinen Unterschied: Mit der Arduino IDE 1.8.19 funktioniert das einfache Hochladen (Pfeilsymbol o. Strg + u), in der neueren Version 2.0.4 ist das Hochladen über das Menü (Sketch -> Hochladen per Programmer) oder über Strg + Shift + u vorzunehmen.

      Danke für den Hinweis. Das werde ich ergänzen.

      VG, Wolfgang

      1. Hallo Wolfgang,

        Vielen Dank für die Info, ich habe es bei mir auch noch mal mit dem Menü (Sketch -> Hochladen per Programmer) versucht und siehe da, es funktioniert. Hätte ich das nur mal gewußt bzw.versucht, dann hätte ich mir viel Zeit gespart. So lernt man halt dazu 😉

        Vielen Dank und mach weiter so mit deinem Blog
        Grüße
        Dennis

      1. Danke Wolfgang,
        für die prompte Antwort. Versuche RPI Sense HAT LEDs zu aktivieren. PD 1…2 sind leider belegt.
        Hoffe das ich weiterkomme.
        VG Peter

      2. Hallo Wolfgang,
        zunächst einmal herzlichen Dank für Deine Tutorials!
        Aber hier gleich mal eine Frage:
        Ich bin Deiner Anleitung zum Programmieren eines ATtiny85 gefolgt, Hardware wie abgebildet + 3 zusätzliche LEDs für „Heartbeat, Error und Programming“.
        Nach dem Laden des ArduinoISP – Beispiels pulst die Heartbeat – LED langsam vor sich hin.
        Alle Einstellungen für den ATtiny sind wie von der IDE vorgegeben.
        Wenn ich den Bootloader brennen will, erscheint die Fehlermeldung:

        Arduino: 1.8.19 (Windows 10), Board: „ATtiny25/45/85 (No bootloader), Enabled, CPU (CPU frequency), ATtiny85, 8 MHz (internal), EEPROM retained, B.O.D. Disabled (saves power), Enabled“

        avrdude: Yikes! Invalid device signature.

        Double check connections and try again, or use -F to override

        this check.

        Fehler beim Brennen des Bootloaders.

        Ich habe sowohl die IDE 2.04 als auch die IDE 1.8.19 probiert und mit 2 ATtinys gearbeitet.
        Kannst Du bitte einen Blick in Deine Kristallkugel werfen und mir einen Tip zur Lösung geben?

        Gruß,
        Armin

        1. Hallo Armin, du schreibst, dass die LED nach Upload von ArduinoISP langsam für sich hinpulst. Also bekommst du Sketche auf den ATtiny85 geladen? Oder leuchten schon LEDs am ATtiny85, wenn du nur den ArduinoISP Sketch hochlädst? Aber der ATtiny85 sollte doch zu dem Zeitpunkt noch gar nicht am programmierenden Nano oder UNO hängen!? Und drei LEDs würden ja auch (zu dem Zeitpunkt gar nicht passen, da nur PB3 und PB4 frei sind. Du müsstest noch mal genauer erklären, was du wann wie verbunden hast.
          So sollte die Reihenfolge sein:
          1) Nur den Nano oder UNO an den Computer hängen. Nano oder UNO als Board auswählen, AVRISP_mkII als Programmer einstellen, ArduinoISP hochladen.
          2) Den ATtiny85 wie oben abgebildet mit dem Nano oder UNO verbinden. Kondensator zwischen Reset und GND am Nono/UNO nicht vergessen, Polung des Kondensators beachten.
          3) Den ATtiny als Board auswählen, Programmer: Arduino as ISP, Bootloader brennen.
          4) Einstellungen lassen, wie sie sind und Sketche hochladen.

          x-fach erfolgreich geprüft!

          VG, Wolfgang

          1. Hallo Wolfgang,
            danke für die superschnelle Antwort!
            Zur Erklärung meines Aufbaus:
            Ich habe mir einen Programmier-Adapter gebaut, der zusätzlich zu den notwendigen Leitungen noch Status-LEDs hat:
            D7: Programming
            D8: Error
            D9: Heartbeat
            Ich bin so vorgegangen wie von Dir geschrieben und habe beim „Bootloader brennen“ die Fehlermeldung „Failed chip erase“ bekommen.
            Nach weiteren Versuchen gabs die Meldung „Bootloader flashen failed: Device Signature
            = 0x000000“.
            Irgendwann kam dann die „Yikes!Invalid device signature!“
            Ich habe dannnach weiteren Versuchen endlich die Meldung „Bootloader geflashed “
            bekommen – leider ist mein UNO jetzt auch ausser Gefecht.
            Ich habe bei „Instructables“ einen Vorschlag für einen „Fuse Doctor“ gefunden, um die ATtinys wiederzubeleben – mal sehen.
            Wenn ich den Eintrag von Dennis früher gelesen hätte, wäre mir vielleicht viel Stirnrunzeln erspart geblieben.
            VG Armin

            1. Hallo Armin,
              die Prozedur zum Brennen des Bootloaders ist bei den Arduino Versionen identisch. Ein bisschen merkwürdig, denn warum weiß die Arduino IDE beim Bootloader brennen, dass ein Programmer vorhanden ist, aber beim Programmupload nicht!? Nicht die einzige Merkwürdigkeit der neuen IDE, aber das ist ein anderes Thema.

              Auch wenn ich mich wiederhole: die Prozedur funktioniert – im Prinzip! Wenn es bei dir nicht funktioniert, dann ist irgendetwas anders, was nicht notwendigerweise bedeutet, dass du irgendetwas falsch gemacht hast. Updates von IDEs (wie gerade gesehen), Bibliotheken, Änderungen in der Hardware, Wechselwirkungen mit anderen Bibliotheken und und und… manchmal ist auch nur ein Kabel kaputt. Und das herauszufinden ist die Herausforderung.

              Je mehr Informationen ich habe, desto höher sind die Erfolgschancen. Falls du noch motiviert bist: Fotos vom Aufbau wären evtl. aufschlussreich (an: Wolfgang.Ewald@wolles-elektronikkiste.de). Ebenso alle Meldungen beim Kompilieren und Hochladen bzw. Brennen des Bootloaders, die die Arduino IDE ausspuckt. Dazu solltest du in den Voreinstellungen alle Kompilerwarnungen aktivieren und die Häkchen bei „Ausführliche Ausgabe während….“ setzen.
              VG, Wolfgang

              1. Hallo Wolfgang,
                nochmals Dank für Deine Mühe!
                ich habe für den Moment folgende Entscheidungen getroffen:
                * zurück zur „alten“ IDE, mit Dark Scheme wegen der besseren Lesbarkeit
                * zunächst bei der ATtiny-Brennerei pausieren und erstmal nachdenken
                * „Rettung“ meiner verfuseten ATtinys mit dem hier:

                https://www.instructables.com/Simple-and-cheap-Fuse-Doctor-for-Attiny

                beschriebenen Tool.

                Ich habe Dir die Details des Programmier-Shields per Mail zugeschickt.
                VG Armin

                1. Hallo Armin,

                  ich weiß nicht, ob du schon dazu gekommen bist meine e-mail anzuschauen.

                  Ich denke auch für die anderen Leser, die ggf. verunsichert sind, ist es wichtig zu wissen, dass hier anscheinend der von dir verwendete Programmer einen Designfehler hat (jedenfalls mein Fazit). Die zugrundeliegende Schaltung scheint richtig, aber das Platinen-Layout passt nicht zur Schaltung. Solltest du mal dort reklamieren, wo du das Layout her hast – damit kannst du vielleicht anderen viel Zeit und Ärger ersparen.

                  VG, Wolfgang

  12. Hallo Wolfgang,
    habe ATTiny88 mit ATMEL-ICE und Arduino IDE 2.0.2 mit Hilfe des ATTinyCore Pakets programmiert.
    Beim Test funktionierte die Pin Notation im og. Blink Beispiel nicht.

    // ändern von int ledPin = 4 in…
    const int ledPin=PIN_PA3; // hier beispielsweise für Port A3 Pin 6

    void setup() {
    pinMode(ledPin, OUTPUT);
    }
    void loop() {
    digitalWrite(ledPin, HIGH);
    delay(500);
    digitalWrite(ledPin, LOW);
    delay(500);
    }

    jetzt blinkt es 😉
    VG Peter

  13. Guten morgen Wolfgang,
    ich habe nun ein größeres Projekt laufen, bei demich doch debuggen möchte.
    Ich habe mich daher für Upload mit Optiboot Bootloader enschieden. Den Bootloader habe ich gebrannt. Der Beispielsketch läuft und die serielle Ausgabe passt. Nun möchte ich den ATTiny nicht jedes mal auf den Ardunio-ISP umstecken, sonder den komfort des Upload mittels USB-zu-TTL Adapter nutzen. Also habe ich auch den Ground zu RST Taster eingefügt und es probiert. Leider scheint es ein Problem zu geben das
    avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x80
    Ein wenig gegoogelt habe ich schon der Bootloader ist offenkundig drauf, sonst hätte ich keine serielle Ausgabe.
    Ich bin etwas ratlos… notfalls müsste ich nochmal einen TTL Adapter mit DTS kaufen, oder müsste es mit dem Taster von Ground zu RST in jedem falle funktionieren?
    Danke für die tolle Arbeit!
    VG
    Leif

    1. Hallo Leif,
      ich kann natürlich kein Garantien geben, dass das mit jedem USB-zu-TTL Adapter funktioniert, der auf dieser Welt erhältlich ist, aber es sollte gehen. Die Tatsache, dass du eine serielle Ausgabe hast, heißt nicht dass du den Bootloader drauf hast. Der Bootloader sorgt nur dafür, dass die Programme über RX/TX hochgeladen werden. Die Funktion der seriellen Schnittstelle als Ein-/Ausgabe ist auch so vorhanden. Also falls du es nicht getan hast dann brenne den Optiboot Bootloader für ATtiny 45/85. Du bekommst eine Rückmeldung ob es geklappt hat oder nicht. Kannst dich ja nochmal melden, wenn es trotzdem nicht geht.
      VG, Wolfgang

  14. Hallo „Wolle“ 🙂

    Wollte Dir nur mal sagen, dass Du hier echt einen guten Job mit Deiner Seite machst ….
    Lese ich immer wieder gerne und es hilft mir immer 🙂

    Danke !! Mach weiter so 🙂

  15. Hallo Herr Ewald,

    ich habe Variante 1, Nano zum Programmer gemacht, dann mit Attiny verbunden, Bootloader „gebrannt“ und dies alles ohne Fehlermeldung. Im letzten Schritt, Sketch Blink laden erhalte ich dann jedoch die Meldung, es ist ein Programmer notwendig. Wo liegt möglicherweise mein Fehler. Vielen Dank! Thomas

    1. Hallo Thomas,

      ich sage mal „Du“ – umgekehrt natürlich auch gerne! Immerhin, der Bootloader wird schon mal gebrannt. Das heißt an den Verbindungen kann es schon mal nicht liegen. Als Board ist „ATtiny25/45/85 (no Bootloader)“ und als Chip „ATtiny85“, richtig? Als Programmer muss „Arduino as ISP“ ausgewählt sein. Und hast du beim Hochladen „Hochladen per Programmer“ (oder Strg+Umschalt+U oder Umschalt mit Klick auf den Hochladepfeil) gewählt? Wenn es das alles nicht ist, dann gehe bitte in die Voreinstellungen und wähle Compilerwarnungen „Alle“ und sende mit mir die Meldungen zu (wolfgang.ewald@wolles-elektronikkiste.de).

      VG, Wolfgang

  16. Hallo Herr Ewald.
    Vielen Dank für den ATtiny Beitrag. Die ATtiny sind sind meine kleinen Favoriten, weil ATtiny +LED passt in ein Matchbox Auto, dafür ist selbst der Arduino nano zu groß. Ich habe einen ATtiny84, der mit einem RFM95 Funkmodul über SPI kommuniziert. Dazu benötige ich die RFM95.h und tiny_SPI.h Bibliothek.
    Habe ich das richtig verstanden, daß wenn ich den Boardverwalter ATTinyCore von Spence Konde verwende, daß ich auch auf die tiny_SPI.h Bibliothek verzichten kann, weil der ATtiny das von Hause aus schon versteht? Bekommt er das über „Bootloader brennen “ beigebracht?
    Danke für die vielen Erklärungen in deinen Beiträgen, das hilft, denn ich frickel öfter was zusammen, ohne zu verstehen.
    Gruß,
    UKnopf.

    1. Hallo Herr Knopf,
      Meine Formulierung im Beitrag muss ich nochmal ändern. Die ist im Moment missverständlich. SPI.h muss trotzdem eingebunden werden. Es funktioniert aber ohne dass weitere bzw. andere Bibliotheken benötigt werden.
      VG, Wolfgang Ewald

  17. Guten Abend Wolfgang,
    ich habe mich die letzten Wochen durch genau die von Dir beschriebenen Wege zu quälen versucht und bin an Option2 Optiboot leider gescheitert. Ich hatte die Hoffnung eine seriell Monitorausgabe zu bekommen, die aber am Ende nur mit software serial lief. Software serial hat unglücklicherweise die Funktion implementiert, die bei einem PCINT oder INT0 aufgerufen wird (ich weiß gerade nicht mehr welche von beiden, faktisch brauche ich sie aber beide, da INT0 im Sleep Mode sehr limitiert ist und andererseits PCINT kein Rising oder Falling unterscheiden kann)
    Jedenfalls ist Software serial nicht parallel mit interrupts nutzbar. Verstehe ich es jetzt richtig, dass AIN0 und AIN1 auch ohne software serial eine Monitorausgabe liefern?
    Lohnt es sich also zu meinem Gescheiterten Versuch zurückzukehren, statt einen ATMEL-ICE zu kaufen, den ich praktisch schon im Warenkorb hatte alsDein heutiger Beitrag erschien?

    Guter Beitrag übrigens, abermals vielen vielen Dank

    1. Hallo Leif,

      ja, das ist richtig. AIN0 und AIN1 brauchen kein SoftwareSerial, aber nur, wenn der Optiboot Bootloader zuvor gebrannt wurde. Genau so wie ich es beschrieben habe, funktioniert es. Stellt sich die Frage was bei deinen gescheiterten Versuch nicht geklappt hat. Vielleicht versuchst du nochmal meine Anleitung. Und wenn es nicht funktioniert, dann kannst du mir ja nochmal im Detail mitteilen an welcher Stelle de Dinge nicht geklappt haben, was nicht geklappt hat und ggf. welche Fehlermeldungen es gab.

      Ansonsten ist vielleicht noch die Methode ganz unten mit dem modifizierten ArduinoISP Sketch interessant.

      Viel Erfolg!

      VG, Wolfgang

      1. Also: Warum ich gescheitert bin. Weil ich zuviele unsortierte Informationen ungefiltert zu verschiedenen Möglichkeiten hatte.
        Es ist immer ungemein Hilfreich Deine Beiträge zu lesen weil Du die Informationen so strukturiert aufbereitest. Das gefällt mir unheimlich gut und ich wähle daher Deine Anleitung immer vor Gadetronix und mikrocontroller.net weil ich erst nach dem Lesen Deiner Beiträge die anderen Beiträge verstehe.
        Was ich falsch gemacht habe? Ich habe mich mit softserial auseinandergesetzt und dann gemerkt, dass es zwar funktioniert, im aktuellen Projekt aber die Bibliothek mit meinem eigenen Code collidiert, da beide auf die gleichen ISR Vektoren nutzen.
        Dann bin ich auf „TinyDebugSerial“ gestoßen – auch ohne Erfolg.

        Ich habe es heute nach deiner Anleitung versucht. Einen CO2102 drangedängelt den ich liegen hatte und: Läuft. Mir fehlte die Info, dass Optiboot mir eine Ausgabe auch ohne softserial ermöglicht.

        Ich weiß nicht wie schnell Optiboot startet, werde es daher nur beim Entwickeln, nicht aber im Endprodukt einsetzen, da ich sehr sehr schnelle Watchdog resets benötige von denen der Anwender nichts merken soll.

        Zum debuggen ist es aber genau was ich gesucht habe.

        Frage: Wenn ich statt des billigen CP2102 einen FT232RL mit DTS Anschluss kaufen würde…. Könnte der DTS Pin den Reset Taster ersetzen?

        VG und herzlichen Dank!

        1. Das mit dem DTR habe ich ausprobiert und es funktionierte nicht. Ich will aber nicht ausschließen, dass ich irgendetwas übersehen habe. Ich probiere es nochmal aus aber werde wohl erst in den nächsten Tagen dazu kommen.
          Und danke für das positive Feedback!
          VG, Wolfgang

        2. Es geht auch mit dem DTR Pin. Man muss allerdings 0.1 µF zwischen DTR und Reset setzen und einen Pull-Up Widerstand hinzufügen. Ich habe den Beitrag entsprechend erweitert. Wie ich das herausgefunden habe: Der Arduino Pro Mini hat einen DTR Pin. Da habe ich einfach mal geschaut, wie der verdrahtet ist. Gut, dass du gefragt hast!

  18. Hallo Wolfgang
    Bist du dir sicher, das der Attiny 841 auch damit programmiert werden kann? Dieser Attiny ist beim I2C Bus ganz anders zu programmieren. Da ich schon längere Zeit mit diesem arbeite, hatte ich zu Anfang grosse Probleme damit.
    achim

    1. Hallo Achim,

      generell programmieren geht auf jeden Fall. Auch I2C geht, mit gewissen Beschränkungen.

      Ein großer Vorteil an ATtinyCore ist die hervorragende Dokumentation. Für jeden ATtiny ist beschrieben, was geht und was nicht und mit welchen Einschränkungen. Hier der Link zum Abschnitt über I2C für die ATtinyX41-Reihe:

      https://github.com/SpenceKonde/ATTinyCore/blob/master/avr/extras/ATtiny_x41.md#i2c-support

      Du kannst es ja mal probieren.

      Grüße, Wolfgang

Schreibe einen Kommentar

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