Über den Beitrag

In diesem Beitrag zeige ich euch, wie ihr das Boardpaket MiniCore von MCUdude zur Programmierung von ATmega328-, ATmega168-, ATmega88-, ATmega48- und ATmega8-basierten Boards (z. B. Arduino UNO R3) sowie von „nackten“ Mikrocontrollern einsetzen könnt. Der Artikel ist im Grunde eine erweiterte Neuauflage meines früheren Beitrags zum Standalone-Betrieb des ATmega328P. Entsprechend liegt der Fokus hier auf dem Sketch-Upload, während sich der eigentliche Betrieb nur in Details vom Einsatz des klassischen Arduino-Boardpakets unterscheidet.

Folgendes kommt auf euch zu:

• Von MiniCore unterstützte Mikrocontroller
• Warum sollte ich MiniCore nutzen?
• MiniCore installieren
• ISP, Bootloader und Fuses
• Den Minicore-Bootloader (Urboot) brennen
  • Arduino as ISP
  • Bootloader mit einem dedizierten Programmer brennen
  • Bootloader auf Boards brennen
• Sketche hochladen
• Den ATmega328PB nutzen
• Anhang – Programmer
• Anhang – Wire Timeout

Von MiniCore unterstützte Mikrocontroller

Die folgenden Mikrocontroller bzw. die auf ihnen basierten Boards könnt ihr mit MiniCore programmieren:

Sind die hier besprochenen ATmega-Mikrocontroller nicht längst aus der Zeit gefallen? Schließlich kam der ATmega328 bereits vor fast 20 Jahren auf den Markt, und selbst die neuere Variante, der ATmega328PB, ist inzwischen rund 10 Jahre alt. Brandneu sind diese Mikrocontroller also definitiv nicht – und im Vergleich zu moderneren Vertretern wie dem ESP32 oder dem Renesas RA4M1 (Arduino UNO R4) wirken sie leistungsmäßig eher bescheiden.

Und trotzdem: Laut Microchip werden sie (Stand 03/26) bis heute produziert. Vor allem der ATmega328P(B) erfreut sich nach wie vor großer Beliebtheit. Kaum ein anderer Mikrocontroller wurde so häufig in Tutorials und Artikeln behandelt – ein enormer Vorteil, wenn man einmal nicht weiterkommt.

Aus meiner Sicht haben diese „Klassiker“ sogar einen ganz eigenen Reiz: Sie sind ideal für Einsteiger, die die Arduino-Abstraktion hinter sich lassen und tiefer in die Arbeit mit Registern einsteigen möchten. Außerdem schätze ich ihre umfangreichen Optionen zum Energiesparen (siehe hier und hier)

Warum sollte ich MiniCore nutzen?

Zum einen könnt ihr das MiniCore-Paket als Alternative zu den Arduino-Paketen wie etwa für den Arduino UNO R3, den klassischen Arduino Nano oder den Arduino Pro Mini nutzen. Es bietet unter anderem folgende Vorteile:

• Verwendung des schnelleren und schlankeren Urboot-Bootloaders.
• Flexibilität hinsichtlich des Systemtaktes.
• printf() ist implementiert.
• Verschiedene BOD-Optionen (Brown-out detection), also Verhalten bei schwacher Spannung.
• EEPROM-Optionen: Löschen/Nichtlöschen beim Brennen des Bootloaders.
• Wahlfreiheit für Link Time Optimization (LTO). LTO ist eine Compiler-Optimierungstechnik, die unter bestimmten Bedingungen Probleme bereiten kann. 
• Pin-Makros, wie etwa digitalWrite(PIN_PB5, HIGH);
• Vereinfachte Sleep-Funktionen.

Zum anderen eignet sich das Paket für die „Standalone“-Programmierung der hier besprochenen Mikrocontroller. Es ist wesentlich flexibler als das Paket „ATmega328 on a breadboard“, welches ich in dem schon erwähnten, früheren Beitrag verwendet habe. 

MiniCore installieren

Eine detaillierte Anleitung zum Installieren von Third-Party-Boardpaketen findet ihr hier. Ich beschränke mich auf eine Kurzanleitung: 

• Öffnet die Arduino IDE und geht zu Datei → Einstellungen.
• Klickt auf das Zeichen neben „Zusätzliche Boardverwalter-URLs“.
• Tragt Folgendes als zusätzliche Zeile ein: „https://mcudude.github.io/MiniCore/package_MCUdude_MiniCore_index.json“ (ohne die Anführungsstriche).
• Zweimal mit OK bestätigen.
• Öffnet die Boardverwaltung (Symbol auf der linken Seite der IDE) und sucht nach „MiniCore“. 
• Klickt auf Installieren. 

ISP, Bootloader und Fuses

Zunächst ein wenig Theorie. Erfahrene User mögen diesen Teil überspringen!

Es gibt verschiedene Methoden, einen Mikrocontroller zu programmieren. Für AVR-Mikrocontroller sind die Programmierung mittels ISP (In-System-Programming) oder mittels Bootloader die gängigsten Methoden. 

Programmierung per ISP

Bei der ISP-Programmierung wird der Mikrocontroller durch den Programmer im Reset-Zustand gehalten. In diesem Zustand wird kein Sketch gestartet, stattdessen aktiviert der Controller seinen seriellen Programmiermodus. Die Kommunikation erfolgt über die SPI-Pins (MOSI, MISO und SCK).

Der Programmer sendet zunächst ein spezielles Aktivierungskommando. Antwortet der Mikrocontroller korrekt, signalisiert er damit seine Bereitschaft zur Programmierung. Es folgt der Upload in den Flash-Speicher. Nach Abschluss gibt der Programmer den RESET-Pin wieder frei, sodass der Mikrocontroller neu startet und das geladene Programm ausführt.

Programmierung per Bootloader

Nach einem Reset oder Neustart springt der Programmzähler zur Reset-Vektor-Adresse. Diese liegt standardmäßig bei Adresse 0x0000, an der das Anwenderprogramm beginnt. Ist jedoch der Bootloader aktiviert (BOOTRST-Fuse gesetzt), zeigt der Reset-Vektor stattdessen auf den Bootloader-Bereich.

Ein Bootloader ist ein kleines Programm, das am Ende des Flash-Speichers liegt. Der dafür reservierte Bereich ist geschützt und verringert den für das Anwenderprogramm verfügbaren Speicher entsprechend. Wird der Mikrocontroller zurückgesetzt oder neu gestartet, zeigt der Reset-Vektor – sofern die entsprechende Fuse (BOOTRST) gesetzt ist – nicht auf Adresse 0x0000, sondern auf den Beginn des Bootloader-Bereichs.

Der Bootloader prüft dann für kurze Zeit, ob ein Programmupload über eine serielle Schnittstelle (bei Arduino: UART) erfolgen soll. Ist dies der Fall, übernimmt er den Upload des neuen Programms. Andernfalls springt er anschließend zum eigentlichen Anwenderprogramm an Adresse 0x0000.

Der Vorteil der Bootloadermethode ist, dass kein Programmer benötigt wird. Stattdessen muss ein USB-zu-TTL-Adapter vorhanden sein, damit sich eure USB-Schnittstelle mit der UART-Schnittstelle des Mikrocontrollers versteht. Allerdings wird ein solcher Adapter ohnehin benötigt, wenn ihr mit der seriellen Schnittstelle kommunizieren wollt. Zwei Fliegen mit einer Klappe.

Konfusion mit den Fuses

Die schon erwähnten Fuses sitzen in einem nichtflüchtigen Speicherbereich (d. h., sie bleiben bei einem Neustart erhalten) im Mikrocontroller und beherbergen grundsätzliche Einstellungen wie etwa die Taktquelle, die Taktfrequenz oder ob ein Bootloader vorhanden ist. 

Wenn ihr in der Arduino IDE auf „Bootloader brennen“ klickt, wird nicht nur der eigentliche Bootloader hochgeladen, sondern auch die Fuses gemäß den Einstellungen in der Arduino IDE gesetzt. Wenn ihr dagegen – egal, ob per Bootloader oder per ISP – ein Programm hochladet, dann werden die Fuses nicht angepasst. Verändert ihr beispielsweise den Takt in den Einstellungen und ladet ein Blinkprogramm hoch, dann ändert sich die tatsächliche Taktrate nicht, jedoch stimmt die Interpretation, wie lang ein Takt ist, nicht mehr. Und somit stimmt eure Blinkfrequenz nicht. 

Den Bootloader löschen

Das ist einfach: Ihr brennt den Bootloader mit der Option „No Bootloader“. Der Bootloader wird aber auch dann gelöscht, wenn ihr ein Programm per ISP hochladet. Da der dann wird zunächst der gesamte Flash-Speicher gelöscht und damit auch der Bootloader. Sauberer ist es, den Bootloader mit der Option „No bootloader“ zu brennen (s.u.).

Den Minicore-Bootloader (Urboot) brennen

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. Und dazu braucht ihr einen Programmer.

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 Euro. Im Anhang findet ihr eine Liste mit Programmern, die ich erfolgreich ausprobiert habe. 

Arduino as ISP

Aber auch wenn ich zur Nutzung eines Programmers rate, möchte ich hier trotzdem zeigen, wie ihr ein Arduino-Board als AVR-ISP-Programmer nutzt. Es muss sich dabei nicht unbedingt um ein AVR-basiertes Board handeln, aber es ist damit am einfachsten (hier findet ihr Hinweise zu anderen Boards).

Als Anschauungsbeispiel nehme ich den klassischen Arduino Nano und zeige, wie ihr damit einen ATmega328P programmiert. Hier das Pinout-Diagramm des ATmega328P, das übrigens im Wesentlichen auch für die ATmega8/48/88/168 gültig ist (Details hier):

• Schritt 1: Ihr wählt den Arduino Nano (das Programmer-Board) in der Arduino IDE 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 ATmega328P wie folgt:

Ohne den 10-µF-Kondensator würde der boardinterne USB-zu-TTL-Adapter beim Start eines Uploads automatisch einen Reset des Arduino Nano auslösen. Dieses Verhalten ist normalerweise gewünscht, da es den Bootloader startet. Soll der Arduino Nano jedoch selbst als ISP-Programmer dienen, muss der ArduinoISP-Sketch kontinuierlich weiterlaufen und darf nicht durch einen Reset unterbrochen werden.

Der Kondensator zwischen RESET und GND verhindert diesen automatischen Reset, indem er die entsprechenden Impulse des USB-Seriell-Adapters (DTR/RTS) abfängt. Dadurch bleibt der Arduino stabil im laufenden Betrieb und kann zuverlässig als Programmer arbeiten.

Boards ohne USB-zu-TTL-Adapter benötigen diesen Kondensator nicht.

Solltet ihr aus irgendwelchen Gründen den ArduinoISP-Sketch noch einmal hochladen wollen, dann müsst ihr den Kondensator natürlich entfernen. 

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

Beim Bootloader müsst ihr „Yes (UART0)“ wählen, falls ihr eure Sketche später per USB-zu-TTL-Adapter hochladen wollt. Wenn ihr die Sketche per ISP hochladen wollt, dann solltet ihr „No Bootloader“ wählen. Wenn ihr einen ATmega328PB nutzt, dann könnt ihr auch UART1 auswählen.

Bei der Taktrate müsst ihr euch überlegen, was ihr braucht. Externe Quarze sind genauer als der interne Oszillator.

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

Und wenn ihr alles richtig gemacht habt, werdet ihr mit einer Erfolgsmeldung belohnt.

Externen Quarz verwenden

Wenn ihr einen externen Quarz verwenden wollt, dann würde die Schaltung folgendermaßen aussehen (ein Fritzing-Schema wäre zu unübersichtlich):

Solltet ihr aus Versehen einen externen Quarz eingestellt haben, es hängt aber keiner dran, dann habt ihr euch ausgesperrt. Ihr müsst den Quarz nachrüsten. Alternativ nehmt ihr einen Arduino UNO R3 mit ATmega328P im PDIP-Format, tauscht den ATmega328P aus und brennt den Bootloader (natürlich unter Verwendung eines Programmers). 

Programmer Shield

Wenn euch die Verkabelung zu mühsam ist und ihr einen Arduino UNO R3 besitzt, dann könnt ihr solch ein AVR ISP Shield nutzen:

Ihr müsst nur den ArduinoISP-Sketch auf den Arduino laden, den ATmega328P im ZIF-Sockel einspannen, das Shield auf den Arduino setzen und dann könnt ihr den Bootloader brennen. Letzteres natürlich wieder mit den Einstellungen für den ATmega328P. 

Der USB-zu-TTL-Adapter (u.l.) gehört nicht zum Lieferumfang. Ich habe ihn zusätzlich angelötet, um darüber Sketche per Bootloader hochzuladen. 

Wenn es nicht funktioniert

Man kann bei der Nutzung eines Arduino als Programmer viel verkehrt machen. Hier eine kleine Checkliste:

• Verkabelung (auch die Kabel selbst können mal defekt sein).
• Beim Upload von ArduinoISP.ino ist das Programmer-Board auszuwählen. Schaltung ohne den Kondensator an Reset.
• Beim Brennen des Bootloaders auf dem Target sind die Einstellungen für das Target-Board auszuwählen. Schaltung mit Kondensator am Programmer. 
• Wenn ihr den Bootloader nicht brennen könnt, könnte es daran liegen, dass in den Fuses ein externer Quarz eingestellt ist und ihr keinen angeschlossen habt → nachrüsten und gewünschte Einstellungen vornehmen. 
• Bei einigen Programmern, so auch beim Arduino as ISP, müsst ihr den Port einstellen. Es gibt auch Programmer, die nicht als serielles Gerät auftauchen. 

Bootloader mit einem dedizierten Programmer brennen

Wenn ihr des Öfteren Bootloader brennt und Sketche per ISP hochladet, dann würde ich dazu raten, einen „echten“ Programmer zu kaufen. Gegebenenfalls müsst ihr einmalig ein wenig Zeit in die Treiberinstallation stecken, aber danach habt ihr es einfacher. Weiter unten findet ihr eine Auswahl. Die Programmer haben einen 6-poligen und/oder 10-poligen Ausgang. Hier die Pinbelegung: 

In Kombination mit Programmern ist auch das folgende Board (ca. 7 € auf AliExpress) sehr praktisch. Ihr setzt den ATmega328P einfach in den ZIF-Sockel ein und verbindet den Programmer über den ISP-Anschluss (ICSP):

Da es einen USB‑zu‑TTL‑Adapter besitzt, könnt ihr später Programme einfach per USB-Anschluss hochladen. Im Grunde ist dieses Board ein Arduino UNO mit ZIF-Sockel. Natürlich könnte man alternativ gleich einen Arduino UNO nehmen, jedoch ist der Wechsel des Mikrocontrollers mit dem ZIF-Sockel sehr viel einfacher.  

Schaltung/Einstellungen für MiniCore in der Arduino IDE

Das Brennen des Bootloaders mit einem „echtem“ Programmer unterscheidet sich durch zwei Punkte:

• Ihr müsst den entsprechenden Programmer auswählen.
• Der Resetpin des Programmers wird direkt mit dem Resetpin des Mikrocontrollers bzw. des Boards verbunden. Noch einfacher ist es bei Boards mit ISP-Anschluss: Die ISP-Anschlüsse von Programmer und Board verbinden und das war’s.

Hier eine Beispielschaltung mit ISP-Breakout-Adapter (den Programmer müsst ihr euch dazu denken):

Bootloader auf Boards brennen

Wenn ihr anstelle eines ATmega-ICs einen Bootloader auf ein Arduino-Board brennen wollt, dann ist das Prinzip dasselbe. Folgendermaßen würde es für zwei Arduino UNO R3 aussehen:

Hier könnt ihr nicht einfach die ISP-Anschlüsse verninden. 

Sketche hochladen

Sketchupload per ISP

Wenn ihr es geschafft habt, den Bootloader zu brennen, ist das Hochladen von Programmen per ISP kein Problem mehr. Ihr behaltet dieselben Einstellungen in der Arduino IDE und dieselbe Verbindung zum Programmer. Dann wählt ihr entweder Sketch → „Mit Programmer hochladen“ oder die Tastenkombi Ctrl + Shift + U. Der Klick auf das Pfeilsymbol mit Shift funktioniert nicht zuverlässig. 

Ein Nachteil der ISP-Methode ist, dass ihr für die Nutzung des seriellen Monitors zusätzlich einen USB‑zu‑TTL‑Adapter braucht. Hingegen ist der Vorteil, ihr auf einem ATmega328P 384 Bytes mehr Flash zur Verfügung habt.

Und auch wenn ich mich wiederhole: Der Bootloader (falls vorhanden) wird beim Programmupload per ISP gelöscht. 

Sketchupload per Bootloader (seriell)

USB-zu-TTL-Adapter

Für den Programmupload per Bootloader braucht ihr zunächst einmal einen USB-zu-TTL-Adapter. Manchmal heißt er auch FTDI-Adapter, da früher vorwiegend Chips der Firma FTDI (Future Technology Devices International) verwendet wurden. Heute kommen auch viele andere Chips wie der CH340 oder CP2102 zur Anwendung. 

Auf jeden Fall solltet ihr euch ein Modell mit DTR-Pin (Data Terminal Ready) anschaffen. Mithilfe des DTR-Pins wird vor dem eigentlichen Upload ein Reset des Mikrocontrollers ausgeführt. Es geht auch ohne DTR, aber das ist sehr unpraktisch: Ihr zieht den Resetpin des Mikrocontrollers bis kurz vor dem eigentlichen Upload auf GND. Das geht z. B. mit einem Taster, den ihr im richtigen Moment loslasst. Da das Zeitfenster kurz ist, ist es entsprechend schwer zu treffen. 

Das rechte Modell hat keinen DTR-Pin, sondern einen RTS-Pin (Ready to Send). Der Upload mit diesem Teil hat funktioniert, wenn ich RTS direkt mit Reset, also ohne den Kondensator, verbunden habe. Bei einem anderen Modell mit RTS-Pin (hier nicht abgebildet) hat es nur geklappt, indem ich RTS über den Kondensator mit Reset verbunden habe. 

Modelle mit FTDI‑Chip, wie das oben links, haben bei mir bei ca. drei von zehn Uploadversuchen gehakt. Falls das bei euch auch so sein sollte, versucht es ein paar Mal. Den Grund für das Problem kenne ich nicht.

Schaltung

DTR verbindet ihr über einen 100 nF Kondensator mit dem Resetpin des Mikrocontrollers. Außerdem bekommt der Resetpin einen Pullup-Widerstand. RX kommt an TX und TX an RX. GND und VCC verbindet ihr wie gehabt. 

Der Kondensator kann auch größer sein. Bei mir hat es genauso mit einem 10 µF Elko funktioniert (Minus am DTR).

Dann müsst ihr noch den richtigen Port einstellen und uploaden. Diesmal ohne Programmer, also über den grünen Pfeil, per Ctrl + U oder über das Menü.

Den ATmega328PB mit MiniCore nutzen

Der ATmega328PB ist gegenüber dem ATmega328P sicherlich keine große Innovation. Dennoch – seine zusätzlichen UART-, I²C- und SPI-Schnittstellen oder die beiden zusätzlichen 16-Bit-Timer könnten genau die Features sein, die ihr für ein Projekt braucht. 

Wenn ihr mehr über den ATmega328PB und darauf basierende Boards wissen wollt, dann schaut mal in diesen Beitrag von mir. 

Anhang – Programmer

Es gibt Programmer in den verschiedensten Preisklassen. Die teureren Modelle können oft noch mehr als den Upload per ISP. Alle hier aufgeführten Modelle habe ich erfolgreich getestet. Bevor ihr die Programmer einsetzen könnt, müsst ihr für die meisten von ihnen noch einen passenden Treiber installieren.

USBTinyISP

Tiny ISP / USBTinyISP / FabISP

Das ist das wohl kleinste und günstigste Modell. 

USBASP

Hinweis zur Nutzung: der Ausgang ist 10-polig. Meistens wird ein Adapter auf ISP (6-polig) mitgeliefert. 

Pololu USB AVR Programmer V2

Dieses Teil ist sowohl AVR-ISP-Programmer als auch USB‑zu‑TTL‑Adapter. Sehr praktisch ist auch, dass man die Adapterschnittstelle direkt auf einen Arduino Pro Mini stecken kann. 

Diamex AVR-ISP Programmer

Diamex EXA-PROG

Für diesen Programmer sollte man sich auch einen Adapter für 10-polig → 6-polig besorgen. Alternativ könnt ihr auch einen passenden Breadboard-Adapter verwenden. 

Diamex hat weitere Programmer im Angebot. 

ATMEL-ICE

Der ATMEL-ICE ist sicherlich nur etwas für Leute, die sehr viel programmieren. Das Teil ist ausgesprochen schnell und außerdem gut in Microchip Studio integriert. Neben seinem Preis empfinde ich es allerdings als nachteilig, dass er dem zu programmierenden Mikrocontroller nicht die Betriebsspannung zur Verfügung stellt. Die VCC-Leitung dient vielmehr dazu, zu prüfen, ob der Mikrocontroller ein ausreichendes Spannungslevel hat. Außerdem mag ich die kleine 10-polige 50-mil Buchse nicht besonders. Es ist zwar ein Adapterkabel auf das übliche 100-mil-Format dabei, aber das ist sehr filigran und teuer zu ersetzen.

Treiberinstallation mit Zadig

Zadig ist ein kleines Tool, mit dem sich sehr bequem die Treiber für einige der oben gelisteten Programmer installieren lassen. Ihr könnt Zadig hier herunterladen. Das Programm besteht lediglich aus einer EXE‑Datei, für die keine Installationsroutine notwendig ist. Speichert sie einfach irgendwo, wo ihr sie wiederfindet. Und wenn ihr Zadig wieder loswerden wollt, löscht einfach besagte EXE-Datei. 

Nach dem Programmstart seht ihr Folgendes:

Als Erstes geht ihr auf Options → List all Devices. Dann klappt ihr das Drop-Down-Menü auf und seht alles, was an USB angeschlossen ist:

Damit ihr wirklich das Gerät aussucht, für das ihr den Treiber ändern wollt, steckt es am besten ein und aus und schaut, was in der Liste auftaucht bzw. verschwindet. Klickt auf den Eintrag (hier z.B. FabISP): 

Links von dem grünen Pfeil seht ihr, welcher Treiber derzeit installiert ist (ggf. „NONE“), rechts davon könnt ihr den Treiber auswählen, den ihr (stattdessen) installieren wollt. Klickt dann – je nachdem – auf „Install Driver“, „Replace Driver“ oder „Reinstall Driver“. Aber noch einmal: stellt sicher, dass ihr das richtige Gerät auswählt. Ich war so schusselig und habe einmal mit Zadig meinen Maustreiber ersetzt. Es ist gar nicht einfach, den richtigen Maustreiber wieder zurückzuholen – ohne Maus!

Hier noch die Treiberauswahl, die bei mir funktioniert hat:

• USBTinyISP: libusb-win32
• Tiny ISP / USBTinyISP / FabISP: libusb-win32
• USBAsp: WinUSB

Anhang – Wire Timeout

Das Thema passte nicht so recht in den anderen Kontext, deswegen kommt es hier in den Anhang. Die Funktionen setWireTimeout(), getWireTimeoutFlag() und clearWireTimeoutFlag() sind im MiniCore-Paket standardmäßig deaktiviert. Um das zu ändern, müsst ihr in der Datei Wire_timeout.h die Zeile 3 // #define WIRE_TIMEOUT entkommentieren. Wo sich die Datei befindet, hängt von eurer Installation ab. Bei mir ist es unter:

C:\Users\user\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\version\libraries\Wire\src

Abschluss

Wenn euch der Beitrag gefallen hat und ihr mich unterstützen wollt, dann schaut hier.