Über den Beitrag

Dieser Beitrag über das Boardpaket TinyCore von MCUDude ist mittlerweile mein dritter Beitrag über Boardpakete für die klassischen ATtinys. Warum also noch einer? 2019 hatte ich hier über das Boardpaket attiny von David A. Mellis berichtet. Es funktioniert wunderbar, deckt allerdings nur einen Teil der klassischen ATtiny-Familie ab. Im Jahr 2022 habe ich dem großartigen Boardpaket ATtinyCore von Spence Konde einen Beitrag gewidmet. Hier gibt es leider ein Problem mit der neuesten Version des Paketes und der Arduino IDE 2.x. Außerdem scheint das Paket zumindest derzeit nicht gepflegt zu werden. Gute Gründe, eine Alternative zu besprechen.

TinyCore basiert auf ATtinyCore und bringt dabei einige Verbesserungen mit. Nachteilig ist, dass TinyCore (noch?) keine Digispark/Micronucleus-Boards unterstützt, was aber das einzige Manko ist, das ich bisher gefunden habe.

Das erwartet euch im Detail:

• Die klassischen ATtinys
• Pinout / Pinmapping
• TinyCore in der Arduino IDE installieren
• Bootloader brennen
  • Bootloader mit einem „Arduino as ISP“ brennen
  • Bootloader mit einem dedizierten Programmer brennen
• Sketche hochladen
  • Sketche per ISP hochladen
  • Sketche mit USB-zu-TTL-Adapter hochladen
  • Hochladen per ISP und seriellen Monitor nutzen
• Weitere Features des TinyCore Boardpaketes

Der Beitrag wiederholt vieles von dem, was ich schon in meinem letzten Beitrag über das MiniCore-Paket geschrieben habe. Das mag langweilig für regelmäßige Leser sein, die Beiträge sollen aber unabhängig voneinander verständlich sein. 

Die klassischen ATtinys

TinyCore deckt die folgenden, klassischen ATtinys bzw. die auf ihnen basierenden Boards ab:

Die ATtinys wirken mit ihren zum Teil winzigen Arbeits- und Flashspeichern etwas aus der Zeit gefallen, erfreuen sich aber immer noch hoher Beliebtheit. Technisch gesehen dürften die neueren Modelle der tinyAVR®-Reihen 0 bis 3 fast immer die bessere Wahl sein (Beitrag dazu hier). Für die klassischen ATtinys sprechen jedoch ihre enorme Verbreitung und die damit verbundene hohe Zahl an Artikeln, Tutorials und Forenbeiträgen. Hinzu kommen ihre Verfügbarkeit in PDIP-Bauform und ihre vergleichsweise schlichte und damit verständliche Architektur. Auf jeden Fall sind sie es meiner Sicht nach immer noch wert, ihnen einen Beitrag zu widmen. 

Pinout / Pinmapping

In diesem Beitrag ist der ATtiny85 mein Standardbeispiel. Hier das zugehörige Pinout-Diagramm der PDIP-Variante, welches auch für den ATtiny45 und den ATtiny25 gültig ist:

Zu einem Teil sind die Pinfunktionen hardwareseitig festgelegt, zu einem anderen Teil sind sie über das Boardpaket zugeordnet („gemappt“). Die Pinout-Diagramme der anderen ATtinys findet ihr hier.

TinyCore in der Arduino IDE installieren

Die Installation ist in zwei Minuten erledigt:

• Geht auf Datei → Einstellungen und klickt auf das grüne Symbol neben „Zusätzliche Boardverwalter-URLs“.
• Dort tragt ihr dann Folgendes als separate Zeile ein:
  • https://mcudude.github.io/TinyCore/package_MCUdude_TinyCore_index.json
• Bestätigt zwei Mal, indem ihr auf „OK“ klickt.
• Dann geht ihr über das Board-Icon auf der linken Seite des Programmfensters in die Boardverwaltung. Alternativ navigiert ihr über Werkzeuge → Board → Board-Verwaltung dorthin.
• Tragt „TinyCore“ in das Suchfeld ein und sucht nach „TinyCore von MCUdude“ unter den Treffern.
• Klickt auf „Installieren“ – und das war’s auch schon.

Probleme? Dann findet ihr hier eine ausführliche Anleitung für das Installieren von Boardpaketen.

Bootloader brennen

In meinem letzten Beitrag über das MiniCore-Boardpaket habe ich recht detailliert über die Grundlagen der Bootloader, der Fuses und der Programmiermethoden berichtet. Bei Bedarf oder Interesse schaut hier. In diesem Beitrag möchte ich nur noch einmal kurz zusammenfassen:

• Für das Hochladen von Programmen auf einen „nackten“ ATtiny könnt ihr einen ISP-Programmer verwenden oder ihr nutzt einen USB-zu-TTL-Adapter. 
• Für den Weg über den USB-zu-TTL-Adapter müsst ihr zunächst einen Bootloader brennen. Dafür wiederum braucht ihr einen ISP-Programmer. Mit anderen Worten: Am Programmer führt kein Weg vorbei.
• Das „Bootloader brennen“ in der Arduino IDE bedeutet mehr als nur das Hochladen des Bootlaoder in den Programmspeicher. Ihr setzt damit auch die sogenannten Fuses, die unter anderem die Taktrate und die Taktquelle festlegen.
  • Deswegen: Bei Änderung grundsätzlicher Einstellungen ist das Brennen des Bootloaders auch dann erforderlich, wenn ihr Programme per ISP hochladen wollt. 
• Ladet ihr ein Programm per ISP hoch, dann wird ein ggf. vorhandener Bootloader gelöscht.

Also, egal welches Board oder welchen Mikrocontroller ihr mit MiniCore nutzen wollt, und egal ob mit Bootloader oder nicht: Als Erstes müsst ihr den Bootloader brennen.

Die gute Nachricht: Ihr könnt ein Arduino-Board zum ISP-Programmer machen. Die schlechte Nachricht: Das Ganze ist ziemlich fummelig und man kann sich an vielen Stellen vertun. Ich empfehle daher, in einen Programmer zu investieren. Es gibt welche schon für wenige Euros. Hier findet ihr eine Liste mit Programmern, die ich im Rahmen meines letzten Beitrages erfolgreich ausprobiert habe.

Bootloader mit einem „Arduino as ISP“ brennen

Im Folgenden zeige ich, wie ihr einen klassischen Arduino Nano zum ISP-Programmer macht. Das geht genauso mit einem Arduino UNO R3 und vielen anderen Arduino Boards. Bei einigen Boards gibt es im Detail ein paar Unterschiede. Auf den Arduino-Seiten gibt es dazu einen Artikel, dessen Lektüre ich aber auch so empfehlen kann.

Schritt 1: Ihr wählt den Arduino Nano (das Programmer-Board) in der Arduino IDE als Board aus und verbindet ihn mit dem PC. Stellt auch den richtigen Port ein. Macht das Ganze am besten, ohne dass ihr den Arduino mit irgendetwas anderem verbindet.
Schritt 2: Geht auf Datei → Beispiele → Mitgelieferte Beispiele, öffnet den Sketch ArduinoISP und ladet ihn hoch.
Schritt 3: Verbindet den Arduino Nano mit dem ATtiny85 wie folgt (die LED braucht ihr hier noch nicht):

Falls ihr einen anderen ATtiny verwendet, sucht die MISO-, MOSI-, SCK-, RESET-, VCC- und GND-Pins im jeweiligen Pinout-Schema und verkabelt ihn entsprechend. 

Schritt 4: Jetzt wählt ihr das TinyCore-Paket und nehmt die folgenden Einstellungen für den ATtiny85 (euer Target) vor:

Falls ihr später Programme per USB‑zu‑TTL‑Adapter hochladen wollt, dann wählt ihr für den Bootloader die Option „Yes“.

Schritt 5: Klickt auf „Bootloader brennen“ bzw. „Burn Bootloader“.

Externen Quarz verwenden

Falls ihr einen externen Quarz verwenden wollt, dann verbindet ihr den ATtiny wie unten abgebildet, und wählt beim Brennen des Bootloaders die entsprechende Option für „Clock“. Mit einer zusätzlichen LED wird es hier schon eng am ATtiny85. Da müsst ihr euch einen Pin mit MISO, MOSI oder SCK teilen.

Bootloader mit einem dedizierten Programmer brennen

Wie zuvor erwähnt, ist das Brennen des Bootloaders und das spätere Hochladen von Programmen per ISP mit einem „echten“ Programmer sehr viel einfacher. 

Die Programmer haben einen 6- und/oder 10-poligen Ausgang:

Verbindet die Pins mit ihren Pendants am ATtiny. 

Da man sich mit den Pins leicht vertun kann, empfehle ich euch, bei Breadboardschaltungen einen Adapter zu verwenden:

Bei der obigen Anleitung zum Brennen des Bootloaders beginnt ihr mit Schritt 4 und stellt den passenden Programmer ein. Für einige Programmer müsst ihr den richtigen Port auswählen, andere Programmer tauchen nicht unter „Port“ in den Einstellungen auf. Für die meisten Programmer müsst ihr einen Treiber installieren. Mehr zu diesem Thema gibt es hier in meinem letzten Beitrag.

Sketche hochladen

Sketche per ISP hochladen

Das Hochladen per ISP ist einfach. Sowohl den Anschluss des ATtiny als auch die Einstellungen in der Arduino IDE lasst ihr so wie beim Brennen des Bootloaders. Ihr startet den Upload über die Tastenkombination STRG/Shift/U oder über Sketch → „Mit Programmer hochladen“. Es ging bei mir auch mit dem „normalen“ Hochladen (also Pfeilsymbol oder STRG/U), aber ich kann nicht garantieren, dass das mit jedem Programmer so funktioniert. 

Zum Testen eignet sich ein Blink-Sketch. Damit seht ihr auch, ob alles mit dem Takt in Ordnung ist.

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

void loop() {
  digitalWrite(PB4, HIGH); // PB4 or 4 or A2
  delay(1000);                      
  digitalWrite(PB4, LOW); 
  delay(1000);              
  // Serial.println("Hello World");
}

Der Vorteil der ISP-Methode ist, dass ihr den Platz für den Bootloader im Flash spart. Der von TinyCore verwendete Urboot-Bootloader ist mit 256 Bytes schon vergleichsweise schlank, aber das ist immer noch ein Achtel des Programmspeichers der ATtiny2xx. Nachteilig ist hingegen, dass ihr über den ISP-Anschluss in der Regel keine Verbindung zum seriellen Monitor habt (ein Trick für den „Arduino as ISP“ kommt weiter unten). Wenn ihr die Zeilen 2 und 11 entkommentiert, seht ihr keine Ausgabe. 

Und nicht vergessen: Das Hochladen eines Sketches per ISP überschreibt einen evtl. vorhandenen Bootloader.

Sketche mit USB‑zu‑TTL‑Adapter hochladen

Zunächst einmal braucht ihr für das Hochladen einen USB-zu-TTL-Adapter, den es für wenige Euro zu haben gibt. Ich rate zu Modellen, die einen DTR-Pin haben. Es geht im Prinzip auch ohne, aber das ist unbequem. In meinem letzten Beitrag habe ich etwas mehr zu den Adaptern geschrieben. 

Voraussetzung für das Hochladen per USB-zu-TTL-Adapter ist das Vorhandensein des Bootloaders auf eurem ATtiny. Ihr könnt den Bootloader nicht mit dem USB-zu-TTL-Adapter brennen, sondern nur mit einem Programmer und der zuvor beschriebenen Prozedur. Dabei wählt ihr die Option „Bootloader: Yes“. Wenn das erledigt ist, verbindet ihr den USB-zu-TTL-Adapter mit dem ATtiny wie folgt: 

Für den Kondensator am Reset-Pin werden im Allgemeinen 100 nF empfohlen. Falls ihr keinen haben solltet, könnt ihr einen größeren probieren. Bei mir ging es auch mit 10 µF.

Wenn ihr keinen DTR-Pin habt, dann lasst den Kondensator und den Pull-Up-Widerstand an Reset weg. Beim Hochladen wartet ihr, bis die Meldung „Warning: Attempt x of 10: not in sync“ kommt und zieht den Reset-Pin dann kurz auf GND. 

Der USB-zu-TTL-Adapter erlaubt euch Ausgaben auf dem seriellen Monitor. Um das zu testen, entkommentiert ihr die Zeilen 2 und 11 in blink_serial_test.ino. 

Hochladen per ISP und seriellen Monitor nutzen

Natürlich könnt ihr eure Sketche auch per ISP hochladen und mit einem zusätzlichen USB-zu-TTL-Adapter den seriellen Monitor nutzen. Vom USB-zu-TTL-Adapter verbindet ihr lediglich die Pins GND, RX und TX. VCC verbindet ihr, falls der ATtiny nicht schon über den Programmer mit Strom versorgt wird. Programmer und Adapter konnte ich problemlos gleichzeitig anschließen. Beim Wechsel zwischen Hochladen und serieller Ausgabe müsst ihr die richtigen Ports auswählen. 

SRAM sparen

Falls ihr auf dem seriellen Monitor nur ausgeben, aber nichts eingeben wollt, dann könnt ihr in den Einstellungen unter Serial die Option „TX only“ auswählen. Das spart immerhin 36 Bytes SRAM, die sonst für den RX-Puffer reserviert würden. Und nutzt – sofern ihr ausreichend Flash habt – das F-Makro: Serial.print(F("......"));.

Den TX-Pin ändern

Ihr könnt TX mittels Serial.setTxBit(PBn);⁣ einem anderen Pin zuordnen. Der Aufruf erfolgt vor Serial.begin(). Für den Programmupload ist das aber irrelevant. Für diesen Schritt liegt TX am voreingestellten Pin. Nach dem Upload könnt ihr „umstöpseln“.

Seriellen Monitor über „Arduino as ISP“ nutzen

Ich bin kein Fan des „Arduino as ISP“, aber möchte euch trotzdem eine Variante dieser Methode, mit der ihr auch den seriellen Monitor nutzen könnt, nicht vorenthalten. Dabei nutzt der Programmer SoftwareSerial.

Gefunden habe ich diese Variante hier im deutschen Arduino-Forum. Zunächst müsst ihr die modifizierte Version des ArduinoISP-Sketches von dort herunterladen (alternativ: hier von GitHub). Die SoftwareSerial-Verbindung erfordert eine zusätzliche Datenleitung. Das RX des Programmers (also des Arduino-Boards) ist auf Pin D4 voreingestellt. Das könnt ihr in den ersten Zeilen des modifizierten ArduinoISP-Sketches ändern. TX des Programmers ist auf den fiktiven Pin 99 voreingestellt. Falls ihr Nachrichten vom seriellen Monitor zum Target (dem ATtiny) schicken wollt, dann müsst ihr das auf einen realen Pin ändern und noch eine Datenleitung einrichten.

Zu beachten ist, dass die Serial-Baudrate des Programmers auf 19200 Baud voreingestellt ist. Diese Baudrate müsst ihr im seriellen Monitor einstellen – oder ihr ändert die Voreinstellung im ArduinoISP-Sketch in setup().

Und so könnte dann ein Test-Sketch für euren ATtiny aussehen: 

#include<SoftwareSerial.h>
SoftwareSerial softSerial(99, 4); // RX, TX - we don't need RX

void setup() {
  softSerial.begin(9600); // set Baud 19200 in Serial Monitor!!!
  pinMode(PB3, OUTPUT);
}

void loop() {
  digitalWrite(PB3, HIGH); 
  delay(1000);                      
  digitalWrite(PB3, LOW); 
  delay(1000);              
  softSerial.println("Hello World");
}

 

Beachtet, dass hier RX auf den fiktiven Pin 99 voreingestellt ist.

Der Nachteil an dieser Methode ist ein etwas höherer Bedarf an Arbeitsspeicher (SRAM) für den RX- und TX-Puffer. Hinzu kommt ein wenig zusätzlicher Bedarf für den Programmspeicher. 

Weitere Features des TinyCore Boardpaketes

Eigentlich war das bis hierher erst der Anfang, denn bis jetzt ging es lediglich um grundsätzliche Einstellungen und den Programmupload. Auf Serial bin ich schon ein wenig eingegangen, nicht aber auf I2C und SPI. Weitere wichtige Themen sind Timer/PWM, der ADC, der EEPROM und Servo oder Tone. Die Mitglieder der Familie der klassischen ATtinys unterscheiden sich hinsichtlich dieser Funktionen zum Teil recht deutlich. Es würde den Rahmen dieses Beitrages sprengen, darauf im Detail einzugehen.

Die gute Nachricht: TinyCore abstrahiert viele der Funktionen. So merkt ihr – beispielsweise – in den meisten Fällen gar nicht, ob ein ATtiny über eine „echte“ UART- oder I2C-Schnittstelle verfügt oder nicht. Außerdem ist TinyCore hervorragend dokumentiert. Auf GitHub findet ihr nicht nur allgemeine Informationen zu den genannten Funktionen, sondern auch detaillierte Beschreibungen der einzelnen Vertreter. Besonders hilfreich sind darüber hinaus die zahlreichen mitgelieferten Beispielsketche.

Weitere Besonderheiten des TinyCore Paketes, auf die ich hinweisen möchte, sind:

• Unterstützung von printf().
• Implementierung von Pin-Makros, z.B. digitalWrite(PIN_PB0, HIGH).
• Einstellungen für Brown-Out Detection (BOD).
• Nicht-Löschen Option des EEPROM beim Programmupload per ISP oder beim Brennen des Bootloaders.
• Kalibrierung des Oszillators (OSCCAL).

Unterstützung

Wenn euch der Beitrag gefallen hat und ihr mich unterstützen wollt, dann schaut hier, wie ihr das tun könnt. Damit könnt ihr dazu beitragen, dass diese Seite weiterhin frei von Werbung bleibt.