English
Ein Arduino Nano ist beispielsweise bei Amazon ab 9,99 € zu bekommen. Günstiger geht das direkt aus China. Oft haben diese Boards aber noch einen alten Bootloader an Bord. In diesem Artikel wird erklärt, wie man mit Hilfe eines weiteren Arduinos den Bootloader des Nanos neu flasht.
Ist der alte oder neue Bootloader installiert?
Zu Beginn solltest du herauszufinden, ob der alte oder bereits der neue Bootloader installiert ist.
Blink-Sketch als Test
Schließe deinen Arduino Nano per USB-Kabel an deinen Computer an und öffne die Arduino IDE.
- Wähle dort unter Datei → Beispiele → 01.Basics den Beispiel-Sketch
Blinkaus. - Unter Werkzeuge → Board wählst du
Arduino Nanound unter Werkzeuge → Port den entsprechenden Port deines Arduino Nano. - Unter Werkzeuge → Prozessor wählst du nun zunächst
ATmega328Paus (und nichtATmega328P (Old Bootloader)). - Starte dann den Upload des Sketches.
Upload erfolgreich?
Wenn der Sketch-Upload erfolgreich war, dann ist bereits der neue Bootloader auf deinem Arduino Nano installiert und du kannst an dieser Stelle aufhören zu lesen 🙂
Upload fehlgeschlagen?
Erhältst du eine Fehlermeldung, die ähnlich der folgenden aussieht, dann ist auf deinem Arduino Nano der alte (oder gar kein) Bootloader installiert.
Using Port : COM16
Using Programmer : arduino
Overriding Baud Rate : 115200
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00
avrdude done. Thank you.
Beim Hochladen des Sketches ist ein Fehler aufgetretenIn der Fehlermeldung können auch andere Codes hinter „resp“ stehen, z.B.:
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x85Gegen-Check
Wähle nun unter Werkzeuge → Prozessor den Eintrag ATmega328P (Old Bootloader) aus und starte den Upload des Sketches erneut. Diesmal sollte der Upload erfolgreich sein und die LED auf dem Arduino Nano sollte blinken. Im Ausgabefenster der Arduino IDE steht dann Hochladen abgeschlossen und weitere Details zum Upload-Vorgang, beispielsweise:
Using Port : COM16
Using Programmer : arduino
Overriding Baud Rate : 57600
AVR Part : ATmega328P
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PC2
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
[...]
Programmer Type : Arduino
Description : Arduino
Hardware Version: 2
Firmware Version: 1.16
Vtarget : 0.0 V
Varef : 0.0 V
Oscillator : Off
SCK period : 0.1 us
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.00s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: reading input file "C:\Users\user\AppData\Local\Temp\arduino_build_372348/Blink.ino.hex"
avrdude: writing flash (924 bytes):
Writing | ################################################## | 100% 0.29s
avrdude: 924 bytes of flash written
avrdude: verifying flash memory against C:\Users\user\AppData\Local\Temp\arduino_build_372348/Blink.ino.hex:
avrdude: load data flash data from input file C:\Users\user\AppData\Local\Temp\arduino_build_372348/Blink.ino.hex:
avrdude: input file C:\Users\user\AppData\Local\Temp\arduino_build_372348/Blink.ino.hex contains 924 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.22s
avrdude: verifying ...
avrdude: 924 bytes of flash verified
avrdude done. Thank you.Damit wissen wir jetzt, dass auf dem Arduino Nano der alte Bootloader installiert ist. Diesen können wir ohne Probleme mit dem neuen Bootloader überschreiben, da es sich nur um eine andere Software handelt. Die Hardware eines Arduino Nanos mit altem Bootloader unterscheidet sich nicht von einem mit neuem Bootloader. Aber warum sollten wir das überhaupt machen?
Unterschiede des neuen gegenüber des alten Bootloaders
Der alte Bootloader ist der „ATmegaBOOT“, der neue Bootloader heißt „optiboot“ und wird auch in anderen Arduino-Modellen genutzt.
In diesem StackExchange-Beitrag werden die beiden Haupt-Vorteile genannt:
- Wird der Arduino Nano durch den Watchdog resettet, dann führt ein Bug in ATmegaBOOT dazu, dass der Arduino Nano unendlich oft neu startet. Diesen Fehler gibt es in optiboot nicht.
- Beim Sketch-Upload arbeitet ATmegaBOOT mit einer baud-Rate von 57600. Der Bootloader optiboot hingegen ist doppelt so schnell mit einer baud-Rate von 115200. Sketches können mit dem neuen Bootloader also schneller auf den Nano geladen werden. Da unterschiedliche baud-Raten verwendet werden, muss beim Sketch-Upload in der Arduino-IDE auch immer der korrekte Bootloader ausgewählt werden. Aus Sicht des Bootloaders würden nämlich sonst keine sinnvollen Daten empfangen werden, da der Sketch zu langsam bzw. zu schnell übertragen wird.
Ein weiterer, kleiner Vorteil des neuen Bootloaders ist, dass man die Default-Einstellung der Arduino-IDE nutzen kann und nicht daran denken muss, den Bootloader im Menü „Prozessor“ entsprechend zu wechseln.
Was wird benötigt?
Um einen Bootloader auf einen Arduino zu flashen, braucht man einen „Programmer“. Das kann entweder ein spezielles Board genau für diesen Zweck sein oder man nutzt einen weiteren Arduino für diese Aufgabe. Wenn man einen zweiten Arduino herumliegen hat, empfiehlt es sich, diesen als Programmer zu nutzen, da man dann nicht noch extra ein (selten genutzes) Programmer-Board kaufen muss.
Du brauchst folgendes Material und Tools:
⚙️ Hardware & Material
Arduino als Programmer: In der Regel kann jedes Arduino-Modell als Programmer verwendet werden: Arduino Nano, Mega, Pro Mini usw. Es sollte also insbesondere auch mit einem Arduino Nano mit altem Bootloader klappen!
Wir nutzen im Folgenden einen Arduino Uno als Programmer. Habt ihr erfolgreich einen anderen Arduino als Programmer benutzt, dann gebt gerne in den Kommentaren ein kurzes Feedback 🙂
Arduino Uno
![Arduino UNO Rev3 SMD [A000073] - Entwicklungsboard mit ATmega328P-Mikrocontroller, SMD-Version, ideal f�r elektronische Projekte, Robotik, Automatisierung und DIY-Anwendungen IDE.](https://m.media-amazon.com/images/I/41l98hhGiHL._SL160_.jpg)
Arduino Uno (Original)
Jumper-Kabel: Um die beiden Arduinos zu verkabeln benötigst du sechs male-to-female (M2F) Jumper-Kabel.
Set mit unterschiedlichen Jumper-Kabeln
Kondensator: In dem verlinkten Konsensator-Sortiment sind viele unterschiedliche Werte vorhanden. Für den Flash-Vorgang benötigst du daraus einen 10 µF Kondensator.
Sortiment von Kondensatoren, beinhaltet 10 µF Kondensatoren
👨💻 Software & Tools
Arduino IDE: Die Software muss auf deinem Computer installiert sein.
Hinweis: Den Arduino Cloud Editor (Web-App) kannst du nicht zum Flashen des Bootloaders verwenden.
Neuen Bootloader auf den Arduino Nano flashen
Arduino als Programmer vorbereiten
Als erstes bereiten wir den Arduino als Programmer vor. Er wird dadurch zum sogenannten ISP, also einem In-System Programmer. Dazu laden wir eine spezielle Software auf den Arduino Uno, über die wir nachher den Bootloader des Arduino Nano flashen werden.
- Wichtig: Schließe jetzt noch keine Jumper-Kabel und keinen Kondensator (!) an den Arduino Uno an.
- Verbinde den Arduino Uno per USB-Kabel mit dem Computer.
- Öffne die Arduino IDE und lade den Sketch
ArduinoISPüber das Menü Datei → Beispiele → 11.ArduinoISP →ArduinoISP- Hinweis: Arduino Cloud Editor (Web-App) hat die Funktionen fürs Bootloader-Flashen nicht eingebaut!
- Setze die Board- und Port-Einstellungen entsprechend dem verwendeten Arduino-Modell für den Programmer:
- Werkzeuge → Board →
Arduino Uno - Werkzeuge → Port → Port-Nummer des Arduino Uno auswählen
- Werkzeuge → Board →
- Lade den Sketch auf den Arduino Uno.
- Ist alles erfolgreich hochgeladen, dann ist dein ISP-Arduino bereit!
- Trenne den Arduino Uno (Programmer) vom Computer.
Kommunikation verstehen
Damit der ISP/Programmer (Arduino Uno) das Bootloader-Zielgerät (Arduino Nano) flashen kann, müssen beide Arduinos verkabelt werden.
ArduinoISP SketchWie läuft die Kommunikation zwischen den beiden Arduinos ab?
- Zum einen muss das Zielgerät (Arduino Nano) mit Strom versorgt werden – in der Regel über 5V und GND.
- Ein Blick in den Code des
ArduinoISPSketch verrät uns, dass die Kommunikation zwischen den Arduinos per SPI (Serial Peripheral Interface) abläuft. Die entsprechenden Signalleitungen sind:- MISO (auch
POCIoderCIPOgenannt1) - MOSI (auch
PICOoderCOPIgenannt) - SCK (auch
SLKgenannt)
- MISO (auch
- Außerdem muss der Programmer-Arduino den Ziel-Arduino für den Flashvorgang neustarten bzw. zurücksetzen, was über dessen RST/RESET-Pin passiert.
Pinbelegung beim Zielgerät (Pinout)
Auf Seite des Zielgeräts (Arduino Nano) benötigen wird also folgende Pins:
- Stromversorgung (empfangend): 5V und GND
- Kommunikation: MISO/POCI/CIPO, MOSI/PICO/COPI und SCK/SLK
- Reset (empfangend): RST/RESET
Wo finden wir diese Pins? Dabei hilft ein Blick in das sogenannte Pinout des Arduino Nano, ein spezielles Dokument, das die Pinbelegung des konkreten Arduino-Modells beschreibt. Dabei zeigt sich: Alle oben genannten Pins sind am Arduino Nano doppelt vorhanden – sowohl am ICSP-Pinblock, als auch an den normalen, seitlichen Pin-Headern. Wir können uns also frei für eine der beiden folgenden Varianten entscheiden.
Variante 1: Verkabelung mittels ICSP-Pinblock
Der ICSP-Pinblock besteht aus 2 x 3 Pins, die auf der Boardplatine mit ICSP bezeichnet sind.
Hinweis: Die ICSP-Pins sind übrigens standardisiert und sollten bei jedem Arduino-Modell die selbe Pinbelegung haben, falls du statt einem Arduino Nano ein anderes Arduino-Modell flashen willst.
[Ausschnitt aus „Arduino Nano Pinout“ von Arduino.cc, Lizenz: CC BY-SA 4.0; bearbeitet (beschnitten, gedreht, vereinfacht), lizenziert unter CC BY-SA 4.0]
Variante 2: Verkabelung über normale, seitliche Pins
In den Kommentaren wurde darauf hingewiesen, dass man statt des ICSP-Pinblocks ohne Probleme auch die normalen, seitlichen Pins des Arduino Nano für den Anschluss nutzen kann. Zuf besseren Übersicht, sind in folgendem Pinout-Schaubild ausschließlich die benötigten Pins eingetragen:
[Ausschnitt aus „Arduino Nano Pinout“ von Arduino.cc, Lizenz: CC BY-SA 4.0; bearbeitet (beschnitten, vereinfacht), lizenziert unter CC BY-SA 4.0]
Pinbelegung beim Programmer (Pinout)
Beim Programmer (Arduino Uno) werden folgende Pins benötigt:
- Stromversorgung (ausgehend): 5V und GND
- Kommunikation: MISO/POCI/CIPO, MOSI/PICO/COPI und SCK/SLK
- Reset (sendend/Trigger): D10
Wo finden wir diese Pins? Dabei hilft ein Blick in das sogenannte Pinout des Arduino Nano, ein spezielles Dokument, das die Pinbelegung des konkreten Arduino-Modells beschreibt. Dabei zeigt sich: Alle oben genannten Pins sind am Arduino Nano doppelt vorhanden – sowohl am ICSP-Pinblock, als auch an den normalen, seitlichen Pin-Headern. Wir können uns also frei für eine der beiden folgenden Varianten entscheiden.
Welche Pins werden auf Seite des Programmers (Arduino Uno) verwendet?
- Das Zielgerät (Arduino Nano) wird über den Programmer mit Strom versorgt – in der Regel über 5V und GND. Die entsprechenden Pins sind auf dem Board auch exakt so beschriftet.
- Aus dem Quellcode des
ArduinoISPSketch wissen wir schon, dass die Kommunikation per MISO, MOSI und SCK stattfindet. Auf dem Arduinoboard sind meistens aber nur Pinnummern aufgedruckt. Die Zuordnung zwischen diesen Nummern und den Hardwarefunktionen der einzelnen Pins gibt dir ein sogenanntes „Pinout“ für dein Arduinomodell. Die Pinbelegung des Arduino Uno lautet beispielsweise so:- MOSI: 11
- MISO: 12
- SCK: 13
- Der Quellcode verrät uns schließlich, über welche Pin-Nummer der Programmer-Arduino den Reset des Ziel-Arduinos triggert:
- Reset-Trigger: 10
Verkabelung: Arduino Uno (Programmer) an Arduino Nano (Bootloader-Zielgerät) anschließen
[Schaltplan erstellt mit Fritzing, Lizenz: CC BY-SA 3.0]
[Schaltplan erstellt mit Fritzing, Lizenz: CC BY-SA 3.0]
In diesem Schritt werden wir den Arduino Uno mit den sechs Jumper-Kabeln an den Arduino Nano anschließen.
In der folgenden Tabelle sind beide Anschlussmöglichkeiten aufgeführt. Der Arduino Uno wird also auf eine der beiden folgenden Arten mit dem Arduino Nano verbunden:
| Arduino Uno (Programmer) | <-> | Arduino Nano (Bootloader-Zielgerät) ICSP-Pinblock | oder: normale Pins |
| 5V | – | 5V (ICSP-Pin 2) | 5V |
| GND | – | GND (ICSP-Pin 6) | GND |
| D13 | – | SCK (ICSP-Pin 3) | D13 (SCK) |
| D12 | – | MISO (ICSP-Pin 1) | D12 (MISO) |
| D11 | – | MOSI (ICSP-Pin 4) | D11 (MOSI) |
| D10 | – | RST (ICSP-Pin 5) | RST |
Kondensator
Auf der Arduino-Seite zu ISP wird darauf hingewiesen, dass beim Arduino Uno als Programmer (und auch beim Mega, Mini und Nano) zusätzlich ein 10 µF Kondensator (capacitor) mit den Pins GND (minus (-), kurzes Bein) und RST (plus (+), langes Bein) verbunden werden muss. Der Kondesator darf erst aufgesteckt werden, nachdem der ArduinoISP-Sketch auf das Board geladen wurde. Im Foto sieht man den zusätzlich aufgesteckten Kondensator.
Der Kondensator verhindert den automatischen Reset des programmierenden Arduino, damit der ArduinoISP-Sketch während des Flash-Vorgangs weiterläuft.
Hinweis: Bei mir funktionierte der Flashvorgang (siehe unten) jedoch auch ohne den zusätzlichen Kondensator. Allerdings klappte es bei zwei unserer Leser nicht ohne Kondensator. In einem Fall war ein 0,1µF Kondensator ausreichend. Im anderen Fall führte ein 10µF-Kondensator zum Erfolg.
Flash-Vorgang starten
Jetzt können wir den neuen Bootloader auf den Arduino Nano flashen.
- Ändere dazu in der Arduino-IDE die Einstellungen im Menü
Werkzeuge:- ändere
ProgrammerzuArduino as ISP(wähle genau diesen Eintrag und nicht „ArduinoISP“ oder „ArduinoISP.org“) - unter
Portwählst du die Port-Nummer des Arduino Uno (Programmer) - unter
BoardundProzessorsetzt du die Parameter für den „Ziel-Arduino“, bei dem wir den Bootloader neu flashen wollen, also in diesem Fall:Board: Arduino NanoProzessor: ATmega328P(und nicht „ATmega328P (Old Bootloader)“)
- ändere
- Im Menü
Werkzeugeklickst du nun aufBootloader brennen. (Da hier ja kein Sketch upgeloaded wird, sondern der Bootloader über das ArduinoISP-Programm des Arduino Uno übertragen wird, ist es egal, was für ein Sketch währenddessen geöffnet ist.)
Der Flash-Vorgang dauert in der Regel nur wenige Sekunden. Wenn der Bootloader erfolgreich geflasht wurde, bekommst du eine Meldung, die in etwa so aussieht:
Using Port : COM16
Using Programmer : stk500v1
Overriding Baud Rate : 19200
AVR Part : ATmega328P
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PC2
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
[...]
Programmer Type : STK500
Description : Atmel STK500 Version 1.x firmware
Hardware Version: 2
Firmware Version: 1.18
Topcard : Unknown
Vtarget : 0.0 V
Varef : 0.0 V
Oscillator : Off
SCK period : 0.1 us
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.02s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "C:\Users\user\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.2/bootloaders/optiboot/optiboot_atmega328.hex"
avrdude: writing flash (32768 bytes):
Writing | ################################################## | 100% 0.00s
avrdude: 32768 bytes of flash written
avrdude: verifying flash memory against C:\Users\user\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.2/bootloaders/optiboot/optiboot_atmega328.hex:
avrdude: load data flash data from input file C:\Users\user\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.2/bootloaders/optiboot/optiboot_atmega328.hex:
avrdude: input file C:\Users\user\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.2/bootloaders/optiboot/optiboot_atmega328.hex contains 32768 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.00s
avrdude: verifying ...
avrdude: 32768 bytes of flash verified
avrdude: reading input file "0x0F"
avrdude: writing lock (1 bytes):
Writing | ################################################## | 100% 0.02s
avrdude: 1 bytes of lock written
avrdude: verifying lock memory against 0x0F:
avrdude: load data lock data from input file 0x0F:
avrdude: input file 0x0F contains 1 bytes
avrdude: reading on-chip lock data:
Reading | ################################################## | 100% 0.01s
avrdude: verifying ...
avrdude: 1 bytes of lock verified
avrdude done. Thank you.Viel Spaß mit deinem frisch geflashten Arduino Nano! 🙂
Titelbild: by Nizzah Khusnunnisa on Unsplash, modified with Canva
Schreibe einen Kommentar