Leonardo als ISP-Programmierer für andere Boards nutzen

Den Arduino Leonardo als ISP-Programmierer für andere Boards zu nutzen, ist eine äußerst praktische Methode, um Bootloader zu brennen, Fuses korrekt zu setzen oder Mikrocontroller direkt zu flashen – ganz ohne teuren externen Programmer. „ISP“ steht für In-System-Programming und bezeichnet das Programmieren über die SPI-Schnittstelle (MOSI, MISO, SCK) plus Reset. Der Leonardo eignet sich dafür besonders gut, weil er zuverlässig über USB angebunden ist und gleichzeitig genügend I/O-Pins für die ISP-Signale bereitstellt. Dennoch unterscheiden sich beim Leonardo einige Details von klassischen AVR-Boards wie dem Uno: Die SPI-Pins liegen nicht auf D11–D13, sondern auf dem ICSP-Header, und das Reset-Verhalten kann bei der Programmierung eine Rolle spielen. Wer diese Besonderheiten kennt, kann den Leonardo als ISP-Programmierer stabil einsetzen – vom kleinen ATtiny bis zum ATmega328P auf einem nackten Breadboard. In diesem Artikel erhalten Sie eine saubere, veröffentlichungsreife Anleitung mit Verdrahtung, IDE-Einstellungen, typischen Fehlermeldungen und bewährten Lösungswegen. Offizielle Hintergründe und Beispiele finden Sie u. a. in der Arduino-Dokumentation zu ArduinoISP sowie im Tutorial Arduino as ISP.

Was bedeutet „Leonardo als ISP-Programmierer“ konkret?

Wenn Sie den Leonardo als ISP verwenden, läuft auf dem Leonardo ein Sketch (meist „ArduinoISP“), der über die serielle USB-Verbindung Kommandos vom PC entgegennimmt und diese in SPI-Programmierbefehle umsetzt. Der Zielcontroller („Target“) wird dabei nicht über USB programmiert, sondern über die ISP-Leitungen:

• MOSI (Master Out Slave In) – Daten vom Leonardo zum Target
• MISO (Master In Slave Out) – Daten vom Target zum Leonardo
• SCK (Serial Clock) – Takt für die SPI-Übertragung
• RESET – versetzt den Target-Controller in den Programmiermodus
• GND – gemeinsame Masse (unbedingt erforderlich)
• VCC – Versorgung, je nach Setup vom Leonardo oder extern

Damit können Sie z. B. einen ATmega328P auf einem „blanken“ Aufbau bootloaderfähig machen oder einen ATtiny direkt flashen. Wichtig ist: „Bootloader brennen“ bedeutet nicht nur, eine Bootloader-Datei zu schreiben, sondern häufig auch, passende Fuse-Einstellungen zu setzen (Taktquelle, Boot-Sektion, Brown-out usw.).

Warum der Leonardo beim ISP besondere Aufmerksamkeit braucht

Beim Uno sind MOSI/MISO/SCK üblicherweise auf D11/D12/D13 bekannt. Beim Leonardo (ATmega32U4) ist das anders: Die SPI-Pins sind primär auf dem ICSP-Header geführt, nicht auf den digitalen Standardpins. Das ist der häufigste Grund, warum eine Verkabelung „wie beim Uno“ am Leonardo nicht funktioniert. Zusätzlich kann das Auto-Reset-Verhalten beim Programmieren stören, wenn der Leonardo beim Start der Programmierung unerwartet neu startet und damit der ArduinoISP-Sketch kurzzeitig nicht verfügbar ist. Diese Punkte sind lösbar, aber sollten von Beginn an eingeplant werden.

Voraussetzungen: Hardware, Software und sinnvolle Vorbereitung

Für ein sauberes ISP-Setup benötigen Sie:

• Arduino Leonardo inkl. USB-Kabel
• Jumper-Kabel (möglichst kurz, um Signalstörungen zu vermeiden)
• Zielboard oder Zielcontroller (z. B. Uno, Nano, ATmega328P, ATtiny)
• Optional: 10 µF Kondensator zum Deaktivieren von Auto-Reset am Programmer
• Arduino IDE (oder CLI), inkl. passender Board-Definitionen

Wenn Sie ATtiny-Controller programmieren möchten, brauchen Sie zusätzlich ein Board-Package (z. B. über den Boardverwalter) und sollten die jeweilige Dokumentation des Pakets beachten.

Verdrahtung: Leonardo (ISP) mit dem Zielboard verbinden

Die sicherste Methode ist die Verdrahtung über die ICSP-Pins. Viele Boards (Uno, Mega, Leonardo) haben einen 2×3-ICSP-Header, auf dem MOSI/MISO/SCK fest definiert sind. Beim Leonardo ist das der bevorzugte Zugriff.

Die wichtigsten Leitungen im Überblick

• Leonardo MOSI → Target MOSI
• Leonardo MISO → Target MISO
• Leonardo SCK → Target SCK
• Leonardo RESET-Pin (festgelegter ISP-Reset-Pin im ArduinoISP-Sketch, häufig D10) → Target RESET
• Leonardo GND → Target GND
• Leonardo 5V oder 3.3V → Target VCC (nur wenn Sie den Target so versorgen möchten)

Der Reset-Pin zum Target ist in der ArduinoISP-Standardkonfiguration typischerweise D10. Prüfen Sie im ArduinoISP-Sketch, welcher Pin als RESET definiert ist, und verdrahten Sie entsprechend. Die SPI-Pins (MOSI/MISO/SCK) holen Sie beim Leonardo zuverlässig vom ICSP-Header.

Spannungspegel beachten (5V vs. 3,3V)

Der Leonardo arbeitet in der Regel mit 5V-Logik. Wenn Ihr Zielcontroller oder Zielboard mit 3,3V betrieben wird, müssen Sie die Pegel prüfen. Viele 3,3V-AVRs sind tolerant, aber das ist nicht garantiert. Im Zweifel nutzen Sie:

• einen Pegelwandler für MOSI/SCK/RESET
• oder betreiben den Programmer und Target auf derselben Spannung (wenn möglich)

Arduino IDE einrichten: ArduinoISP auf den Leonardo laden

Der Ablauf ist in der Regel zweistufig:

• Schritt 1: ArduinoISP-Sketch auf den Leonardo hochladen
• Schritt 2: Leonardo als Programmer auswählen und Target programmieren

Den ArduinoISP-Sketch finden Sie in der IDE unter den Beispielen. Die offizielle Referenz beschreibt den Sketch und typische Anpassungen: ArduinoISP (Built-in Example).

Typische IDE-Einstellungen für Schritt 1

• Werkzeuge → Board: Arduino Leonardo
• Werkzeuge → Port: den Leonardo-Port auswählen
• Datei → Beispiele: ArduinoISP öffnen und hochladen

Wichtig: In dieser Phase programmieren Sie den Leonardo ganz normal über USB. Erst danach wird er zum ISP.

Den Target programmieren: Bootloader brennen oder Sketch per ISP schreiben

Jetzt kommt der eigentliche Nutzen: Der Leonardo übernimmt die Rolle eines ISP-Programmers. In der Arduino IDE wählen Sie dafür den Programmer-Typ und anschließend die Zielplattform.

Bootloader brennen (inklusive Fuse-Settings)

• Werkzeuge → Board: das Zielboard auswählen (z. B. „Arduino Uno“)
• Werkzeuge → Programmer: „Arduino as ISP“ auswählen (nicht „ArduinoISP“ als Board, sondern als Programmer)
• Werkzeuge → Bootloader brennen

Das offizielle Tutorial erläutert diesen Ablauf und die Unterschiede zwischen „Upload“ und „Bootloader brennen“: Arduino as ISP.

Sketch per ISP hochladen (ohne Bootloader)

Wenn Sie einen Sketch direkt per ISP schreiben wollen (z. B. um Platz zu sparen oder weil der Bootloader beschädigt ist), nutzen Sie in der IDE den Upload über Programmer. Das schreibt den Sketch direkt in den Flash und überschreibt ggf. den Bootloader-Bereich.

• Sketch öffnen
• Werkzeuge → Board: Zielboard auswählen
• Werkzeuge → Programmer: „Arduino as ISP“
• Sketch → Hochladen über Programmer

ISP-Takt und langsame Targets: Wenn „Device signature“ nicht lesbar ist

Ein häufiger Grund für Fehler ist ein zu hoher ISP-Takt im Verhältnis zur Taktfrequenz des Zielcontrollers. Ein AVR im Werkzustand läuft oft mit internem 1 MHz-Oszillator (oder 8 MHz geteilt), und dann muss SCK entsprechend langsam sein. Als grobe Regel gilt: ISP-SCK sollte deutlich kleiner als die CPU-Frequenz des Targets sein.

Faustformel für den SCK-Takt

Vereinfacht lässt sich die Beziehung so ausdrücken:

$f_{\mathrm{SCK}}<\frac{f_{\mathrm{CPU}}}{4}$

In der Praxis erreichen Sie „langsameres ISP“ über entsprechende Einstellungen im ArduinoISP-Sketch oder über Programmer-Optionen. Wenn ein Target „tot“ wirkt, liegt es oft nicht am Controller, sondern an Takt/Fuse-Kombinationen.

Auto-Reset vermeiden: Stabiler Leonardo-Programmer unter Windows und macOS

Wenn der PC eine neue serielle Verbindung öffnet, kann der Leonardo resetten. Das ist beim normalen Upload nützlich, beim ISP-Betrieb aber störend: Der ArduinoISP-Sketch ist kurz weg, und der Programmierprozess scheitert. Ein bewährter Workaround ist das Deaktivieren des Auto-Reset am Programmer, häufig durch einen Kondensator (z. B. 10 µF) zwischen RESET und GND am Programmer-Board. In vielen Anleitungen zum Arduino-as-ISP-Setup wird dieses Prinzip beschrieben, weil es gerade bei zuverlässigen Programmierabläufen hilft. Orientieren Sie sich an der offiziellen Anleitung und ergänzen Sie den Kondensator, wenn Sie instabile Verbindungen beobachten: Arduino as ISP.

Typische Fehlermeldungen und schnelle Problemlösungen

Beim ISP-Programmieren tauchen einige Klassiker auf. Entscheidend ist, systematisch vorzugehen: Verdrahtung prüfen, Board/Programmer korrekt wählen, Spannungsversorgung sicherstellen.

„avrdude: stk500_getsync(): not in sync“

• ArduinoISP läuft nicht (falscher Sketch auf dem Leonardo oder Reset-Problem)
• Falscher COM-Port/Port gewählt
• Programmer falsch eingestellt (muss „Arduino as ISP“ sein)

„avrdude: Device signature = 0x000000“ oder „0xffffff“

• MISO/MOSI/SCK vertauscht oder kein gemeinsames GND
• Target erhält keine Versorgung oder falsche Spannung
• ISP-Takt zu hoch für die aktuelle Target-Taktung
• RESET-Leitung nicht korrekt verbunden oder Reset-Pin im Sketch abweichend

„Yikes! Invalid device signature“

• Zielboard in der IDE falsch ausgewählt (z. B. Uno statt ATmega328PB-Variante)
• Clone/abweichender Controller, der andere Signatur hat
• Signalqualität schlecht (zu lange Kabel, fehlende Masseführung)

Praxis-Tipps für zuverlässige ISP-Setups

• Kabel kurz halten: ISP ist empfindlich gegen Störungen, besonders auf Breadboards.
• Gemeinsame Masse zuerst: Viele Probleme sind schlicht fehlendes oder schlechtes GND.
• Target sauber versorgen: Wenn Sie über 5V vom Leonardo speisen, prüfen Sie den Strombedarf des Targets.
• Erst Bootloader brennen, dann testen: Nach dem Bootloader-Brennen kann der Target über USB/Serial leichter überprüft werden (je nach Board).
• Fuses nicht „auf Verdacht“ ändern: Eine falsche Takt-Fuse kann den Controller scheinbar unprogrammierbar machen, bis eine passende Taktquelle anliegt.

Leonardo als ISP im Vergleich zu externen Programmern

Ein externer Programmer (z. B. AVRISP mkII, USBasp oder Atmel-ICE) ist oft komfortabler und robuster, aber für viele Anwendungsfälle reicht der Leonardo vollkommen aus. Wenn Sie gelegentlich Bootloader brennen oder Controller retten möchten, ist der Leonardo eine kostengünstige und flexible Lösung. Für Serienfertigung, sehr häufiges Flashen oder harte Fuse-Recovery ist ein dedizierter Programmer dennoch sinnvoll.

Outbound-Links: Offizielle Anleitungen und vertiefende Quellen

• Arduino Dokumentation: ArduinoISP (Sketch und Hintergrund)
• Arduino Tutorial: Arduino als ISP verwenden (IDE-Ablauf, Bootloader brennen)
• AVRDUDE Projektseite: Programmer-Backend und Fehlerdiagnose
• Microchip: ATmega32U4 Datenblatt/Produktseite (Leonardo-Controller)
• Arduino: Pin-Mapping ATmega32U4 (Hilfreich für SPI/ICSP-Verständnis)

IoT-PCB-Design, Mikrocontroller-Programmierung & Firmware-Entwicklung

PCB Design • Arduino • Embedded Systems • Firmware

Ich biete professionelle Entwicklung von IoT-Hardware, einschließlich PCB-Design, Arduino- und Mikrocontroller-Programmierung sowie Firmware-Entwicklung. Die Lösungen werden zuverlässig, effizient und anwendungsorientiert umgesetzt – von der Konzeptphase bis zum funktionsfähigen Prototyp.

Diese Dienstleistung richtet sich an Unternehmen, Start-ups, Entwickler und Produktteams, die maßgeschneiderte Embedded- und IoT-Lösungen benötigen. Finden Sie mich auf Fiverr.

Leistungsumfang:

• IoT-PCB-Design & Schaltplanerstellung

• Leiterplattenlayout (mehrlagig, produktionstauglich)

• Arduino- & Mikrocontroller-Programmierung (z. B. ESP32, STM32, ATmega)

• Firmware-Entwicklung für Embedded Systems

• Sensor- & Aktor-Integration

• Kommunikation: Wi-Fi, Bluetooth, MQTT, I²C, SPI, UART

• Optimierung für Leistung, Stabilität & Energieeffizienz

Lieferumfang:

• Schaltpläne & PCB-Layouts

• Gerber- & Produktionsdaten

• Quellcode & Firmware

• Dokumentation & Support zur Integration

Arbeitsweise:Strukturiert • Zuverlässig • Hardware-nah • Produktorientiert

CTA:
Planen Sie ein IoT- oder Embedded-System-Projekt?
Kontaktieren Sie mich gerne für eine technische Abstimmung oder ein unverbindliches Angebot. Finden Sie mich auf Fiverr.