Samstag, 4. März 2017

Programmierung eines brandneuen ATmega328p mit Arduino UNO

Programmer auf Karton

Programmer auf PCB


Originaler Artikel (englisch)

Einführung

In diesem Artikel erkläre ich, wie ich meine brandneuen ATmega328p-Chips mit meinem Arduino UNO (Rev. 1 oder 2) programmiert habe. Die Informationen sind zwar im Web (englisch) verfügbar, doch es dauerte eine Weile, um Alles zusammmen zu bringen. Hier wird nun alles erklärt, vom Aufbau des Test-Boards bis zum hochladen eines Arduino-Programms auf den Chip.

Ich habe einen Arduino UNO, welcher mit einem ATmega328p-Chip bestückt ist. Ich dachte,  OK, dann bestellen wir mal ein paar von denen. Hier war einfach die Kostenfrage entscheidend: Ein Arduino kostet so um die 30 CHF, der Chip selbst aber "nur" um die 5 CHF.

Hier ist das Pin-Diagramm des ATmega328p nachdem der Arduino-Bootloader auf den Chip geladen wurde:


Man beachte hier die runde Kerbe links. Diese ist auf jedem Chip dieser Bauart, sowie auch auf den Halterungen dazu. Sie zeigt an, in welche Richtung der Chip eingelegt werden muss (Kerbe zu Kerbe).

Liste der benötigten Teile

Im Gegensatz zum Originalartikel werde ich hier einen Link zu jedem Bauteil angeben.
Diese Links werden meist auf ELV.de verweisen, um möglichst nur eine Bestellung machen zu müssen.

Du brauchst die folgenden Dinge:

+ Einen Computer. ;)
+ 1x Arduino UNO (oder Duemilanove oder so, probier es aus.)
+ 1x ATmega328 chip, DIP 28, brandneu, ohne bootloader oder so darauf.
+ Ein Experimentierboard (oder Karton oder PCB und ein Lötkolben ;) )
+ Verbinder-Kabel (Link als Beispiel)
+ 1x 10k Ohm Widerstand (Link als Beispiel)

Diese Dinge habe ich desweiteren gebraucht. Ich weiss nicht, wie man auf den internen Timer (8MHz) programmiert, denn ich wollte unbedingt die volle Leistung herausholen...weiss Gott, warum:

+ 1x 16Mhz Quarz Schwingkreis
+ 2x 22pF Kondensatoren (ACHTUNG: Der Quarz oben hat eine maximale Last von 18pF, der Wert hier ist aus dem Originalartikel und ich habe keine Ahnung, wie ich darauf gekommen bin.)
+ Optional noch 1x On/Off Schalter, um den externen Oszillator aus zu schalten.

Zuletzt die LEDs. Sie werden nicht unbedingt gebraucht, können aber bei der Entdeckung von Fehlern behilflich sein:

+ 1x Blaue LED, welche den Herzschlag des Host-Arduinos repräsentiert.
+ 1x Grüne LED, welche leuchtet, wenn die Software erfolgreich auf den Chip übertragen wurde.
+ 1x Rote LED, welche bei einem Fehler aufleuchtet.
+ 1x Gelbe LED, welche zum Testen des Chips (Blink-Sketch) benutzt wird.
+ 4x 100 Ohm Widerstände.
(Die Links dienen als Beispiel)

Alle Teile da? Dann fangen wir mal an...

Arduino IDE

Um den Arduino und den Chip zu programmieren, benutzen wir die Arduino IDE. Es muss mindestens Version 1.0.1 sein, oder auch tiefer als 1.0.0, doch mit Version 1.0.0 lief der serielle Port mit 9600baud, auch wenn man 19200baud angegeben hat. Die aktuelle Version ist 1.8.x, das sollte also kein Problem sein.

Du findest die neueste Version hier:

Neuerdings gibt es auch eine Online (Web-)Version der Software, doch ich weiss nicht ob und wie das funktioniert.

Den Arduino aufsetzen

Bitte entferne alle Verbindungen zu deinem Arduino um Software darauf hoch zu laden. Dies dient der Sicherheit der Chips (Sowohl des Hosts als auch des Clients.) Um das einfacher zu machen, laden wir die Software schon jetzt auf den Arduino. (Auf die Arduino-Platine, nicht auf den ATmega328-Chip, welchen wir programmieren wollen.) Wenn die Software erst mal installiert ist, brauchen wir daran nichts mehr zu ändern.

Wir brauchen diesen Sketch: ArduinoISP2c.zip (auf meinem Onedrive-Account aber nicht von mir.)

+ Öffne die IDE und verbinde den UNO mit dem Computer.
+ Lade den ArduinoISP2c-Sketch in die IDE.
+ Wähle den richtigen Port im Tools-Menü aus.
+ Drücke nun auf "Upload" und warte bis es fertig ist.

+ Um nun den Chip auf dem Experimentierboard zu programmieren, müssen wir einen anderen Programmer auswählen. Gehe nach Tools->Programmer und wähle "Arduino as ISP" aus. Prüfe das doppelt und dreifach nach, sonst überschreibst du deinen UNO!!

(Im Originalartikel steht: JETZT den Sketch hochladen, und danach den Arduino mit dem Experimentierboard verbinden - das ist unlogisch und ich erwähne es hier nur, falls etwas schief gehen sollte.)

+ Verbinde nun den Arduino mit dem Experimentierboard (Siehe unten)

Dies ist der Schaltplan für das Experimentierboard mit einem verbundenen Arduino:

Und so sieht es auf dem Board selbst aus:

Hier ist nun noch ein Schaltplan, um einen Programmer zu bauen, sowie ein Bild des Platinenentwurfes. Es ist genau das selbe wie oben, nur dass hier die Verbindungen zum Arduino durch eigene Pins ersetzt wurden. (Hier Female, man kann aber auch Males benutzen.)


Nachdem wir nun unser Board verbunden oder unseren Programmer gebaut und verbunden haben, können wir endlich mit dem lustigen Zeug beginnen.

Alle benötigten Dateien findest du auf dem GitHub-Repository zu diesem Artikel:
http://github.com/ben0bi/BATmegaProgrammer

Zuerst mal AVR, dude..

AVRDUDE ist ein Kommandozeilen-Tool, welches mit der Arduino IDE mitgeliefert wird. Da ich es nicht finden konnte, habe ich es separat noch einmal heruntergeladen. Mit diesem Tool werden wir die "Fuses" setzen, welche man mit "Jumpern" oder den ganz kleinen Schaltern vergleichen könnte, welche es früher auf Mainboards gegeben hat...nur, dass die Fuses in Software "verbaut" sind und nicht in der Hardware. ;)

Mit den Fuses stellen wir ein, dass der Chip mit dem externen Oszillator-Quarz laufen soll anstatt mit dem internen.

Wenn du andere Vorlieben hast, kannst du mit diesem Tool die Werte der Fuses kalkulieren:
http://www.engbedded.com/fusecalc

AVRdude ist wie schon beschrieben ein Kommandozeilen-Tool und muss mit einigen Parametern gestartet werden. Wir werden die folgenden Parameter benutzen:

-c: Wähle den Programmer aus. Wir werden hier avrisp benutzen.
-p: Der chip, welcher programmiert werden soll. Hier m328p.
-P: Der Geräte-Port des Arduinos. Es ist com3 auf meinem Windows-Computer.
-b: Die Baud-Rate, welche benutzt werden soll. Wir brauchen 19200 baud.
-U: Führe einen Befehl auf dem Chip (und nicht auf dem Arduino) aus.
-u: Muss mitgegeben werden, wenn man die Fuses setzt. Sagt einfach: JA, ich WILL WIRKLICH die Fuses setzen.

Ok. Erstmal prüfen wir, ob der Chip bereit ist:
avrdude -c avrisp -p m328p -P com3 -b 19200
So etwas wie "All OK sollte nun in der Konsole aufpoppen.

Wenn alles OK ist, werden wir nun die Fuses setzen. Ich weiss nicht genau, was all die Werte genau tun, ich weiss einfach, dass es funktioniert. Ich musste den Wert für die Low-Fuses selbst herausfinden, doch die anderen Werte bekam ich von einer anderen Website (siehe oben).

Erstens wird der Chip auf den externen 16MHz Oszillator vorbereitet, desweiteren wird auch das Lock-Byte auf 0x0F gesetzt (warum auch immer) und ein paar andere Sachen.
avrdude -b 19200 -c avrisp -p m328p -P com3 -U efuse:w:0x05:m -U hfuse:w:0xD2:m -U lfuse:w:0xFF:m -U lock:w:0x0F:m -u

Das ist alles. Um die Fuses zu prüfen, kann dieser Befehl benutzt werden:
avrdude -b 19200 -c avrisp -p m328p -P com3 -U hfuse:r:fusehigh.txt:s -U lfuse:r:fuselow.txt:s -F

Damit werden die Werte der gegebenen Fuses (hier: hfuse und lfuse) in die jeweilige Textdatei geschrieben (hier fuselow.txt und fusehigh.txt).

Den Bootloader brennen

Nun, da alle Fuses gesetzt sind, der Chip OK ist und den externen Quartz benutzt, und der Programmer der Arduino IDE auf "Arduino as ISP" gesetzt ist (!!!), können wir den Bootloader auf den Chip auf dem Experimentierboard brennen.

Wähle einfach Tools->Burn Bootloader in der IDE und warte ein bisschen. Wenn nichts schief gegangen ist, solltest du nun Arduino-Sketches auf den Chip laden können.


Der letzte Test

Lade nun den Blink-Sketch über File->Examples->01. Basics->Blink in der IDE und ändere den Output-Pin (13) auf 8.

Lade den Sketch auf den Chip über Sketch->Upload via Programmer in der IDE. Prüfe aber erst, ob der Programmer immer noch auf "Arduino as ISP" gestellt ist!

Die gelbe LED auf dem Experimentierboard sollte nun blinken.

Ich hoffe, das hilft.

Keine Kommentare:

Kommentar veröffentlichen