Neusten Bootloader flashen auf Arduino Nano China clone

Ein Arduino Nano ist sehr günstig direkt aus China zu bekommen. 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?

Um das herauszufinden, schließe deinen Arduino Nano per USB-Kabel an deinen Computer an und öffne die Arduino IDE. Wähle dort als Beispiel-Sketch unter Datei -> Beispiele -> 01.Basics -> Blink aus. Unter Werkzeuge -> Board wählst du „Arduino Nano“ und unter Werkzeuge -> Port den entsprechenden Port deines Arduino Nano. Unter Werkzeuge -> Prozessor wählst du nun zunächst „ATmega328P“ (und nicht „ATmega328P (Old Bootloader)“ aus und startest 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 aufgetreten

In 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=0x85

Wähle nun unter Werkzeuge -> Prozessor „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.

Neuen Bootloader auf den Arduino Nano flashen

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.

Wir nutzen im Folgenden einen Arduino Uno als Programmer. Außerdem brauchen wir sechs male-to-female Jumper-Kabel und die Arduino IDE muss installiert sein; denn Bootloader flashen über den Web-Editor ist nicht möglich.

Arduino als Programmer vorbereiten (ISP = In-System Programmer)

Als erstes laden wir die Software auf den Arduino Uno, mit dem wir nachher den Bootloader des Arduino Nano flashen werden.

• Schließe erst mal noch keine Jumper-Kabel an den Arduino Uno an.
• Verbinde den Arduino Uno per USB-Kabel mit dem Computer.
• Öffne die Arduino IDE (Hinweis: Arduino create Web-Editor hat die Funktionen fürs Bootloader-Flashen nicht eingebaut!) und lade den Sketch „ArduinoISP“ über das Menü Datei -> Beispiele -> 11.ArduinoISP -> ArduinoISP
• 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
• Lade den Sketch auf den Arduino Uno.
• Ist alles erfolgreich hochgeladen, dann ist dein ISP-Arduino bereit!

Verkabelung: Arduino Uno (Programmer) an Arduino Nano (Bootloader-Zielgerät) anschließen

Im nächsten Schritt werden wir den Arduino Uno mit den sechs Jumper-Kabeln an den Arduino Nano anschließen.

• Trenne den Arduino Uno (Programmer) vom Computer.
• Für die Verkabelung des Arduino Nano (Bootloader-Zielgerät) gibt es zwei Möglichkeiten: den ICSP-Pinblock oder die normalen, seitlichen Pins.

Verkabelung mittels ICSP-Pinblock

• Der ICSP-Pinblock besteht aus 2×3 Pins, die auf der Boardplatine mit „ICSP“ bezeichnet sind. An diese sechs Pins werden wir den Arduino Uno (Programmer) anschließen, um den Bootloader des Arduino Nanos zu flashen. Die ICSP-Pins sind standardisiert und sollten bei jedem Arduino-Modell die selbe Pinbelegung haben.
• Ein Blick in den Code des „ArduinoISP“-Sketch verrät uns, wie wir den Arduino Uno (Programmer) jetzt mit dem Arduino Nano (Bootloader-Zielgerät) verkabeln müssen:

• Mit dem Symbol “ ° “ ist hier markiert, welcher der Pin 1 ist, der auch auf der Platine mit einer „1“ beschriftet sein sollte.
• Auf dem fünften, unbeschrifteten Pin (im Sketch-Kommentar) liegt normalerweise RST (Reset).
• Diese sechs Pins des Arduino Nano müssen wir nun mit entsprechenden Pins auf dem Arduino Uno verbinden. Der Quellcode verrät uns die Pin-Nummer für den Reset.

• Der Reset wird über Pin 10 getriggert.
  • Reset: 10
• Welche sind aber die Standard-Hardware-Pins für MOSI, MISO und SCK beim Arduino Uno? Die Pinbelegung des Arduino Uno, auch „Pinout“ genannt, verrät es uns:
  • MOSI: 11
  • MISO: 12
  • SCK: 13
• Darüber hinaus müssen wir den Arduino Nano noch mit Strom versorgen über die Pins GND und 5V.

Alternative: 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. In einem entsprechenden Pinout-Schaubild findet man schnell heraus, welche die benötigten Pins 5V, GND, SCK, MISO, MOSI und RST sind. 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:

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 folgenden Foto sieht man den zusätzlich aufgesteckten Kondensator:

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 Programmer zu Arduino as ISP (wähle genau diesen Eintrag und nicht „ArduinoISP“ oder „ArduinoISP.org“)
  • unter Port wählst du die Port-Nummer des Arduino Uno (Programmer)
  • unter Board und Prozessor setzt du die Parameter für den „Ziel-Arduino“, bei dem wir den Bootloader neu flashen wollen, also in diesem Fall:
    • Board: Arduino Nano
    • Prozessor: ATmega328P (und nicht „ATmega328P (Old Bootloader)“)
• Im Menü Werkzeuge klickst du nun auf Bootloader 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 (bei mir) 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! 🙂