Über den Beitrag

In diesem Beitrag möchte ich zeigen, wie ihr das Herzstück des Arduino UNO, den ATmega328P, „standalone“ betreiben könnt. Viele Wege führen nach Rom und ich stelle euch einige davon vor:

• Arduino UNO als Programmer
  
  • Variante 1: Arduino UNO only / 8 MHz
  • Variante 2: Arduino UNO und FTDI232 / 8 MHz
  • Variante 3: Arduino UNO und FTDI232 / 16 MHz
• ATmega328P im Arduino UNO programmieren
• Programmierung mit dem USBtinyISP
• Volle Kontrolle mit Atmel Studio

Jeder dieser Wege hat seine Vor- und Nachteile. Schaut es euch an und entscheidet selbst, was ihr vielleicht mal ausprobieren wollt.

Vorab noch ein paar Punkte

Warum den ATmega328P standalone betreiben?

Arduino Boards sind ohne Frage sehr komfortabel, wenn es darum geht Projekte zu entwickeln. Ihr müsst euch nicht um die Stromversorgung kümmern, ein Oszillator hängt schon dran, ihr benötigt keinen Programmer und ihr habt die beschrifteten Pinbuchsen. Verewigt ihr euer Projekt aber zum Schluss in Lot und Draht, wird der Arduino unhandlich. Dann ist es besser, nur den ATmega328P mit einem Minimum an Peripherie zu betreiben. Neben dem geringeren Platzbedarf sprechen dafür die geringeren Kosten (<2 Euro) und der geringere Stromverbrauch.

Das benötigt ihr für diesen Beitrag

ATmega328P-PU

Um die Beispiele dieses Beitrages nachvollziehen zu können, braucht ihr natürlich zunächst einmal einen ATmega328P, genauer gesagt einen ATmega328P-PU. Das „PU“ beschreibt dabei die Bauform (28 PDIP). Es gibt den ATmega328P nämlich z.B. auch als SMD.

Dann ist wichtig, dass ihr tatsächlich einen ATmega328P kauft und nicht den ATmega328 (ohne „P“). Beide Ausführungen sind fast identisch. Das „P“ steht für Picopower, was bedeutet, dass die P-Variante hinsichtlich des Powermanagements einiges mehr kann. Viel wichtiger ist aber, dass die Modelle unterschiedliche Signaturen haben. Die Signatur ist im Microcontroller unveränderlich festgeschrieben und wird von der Arduino IDE vor dem Hochladen von Sketchen oder dem Brennen des Bootloaders überprüft. Bei der „Nicht-P“ Variante streikt die Arduino IDE.

Der Arduino UNO

Bei dem Arduino UNO ist für einige Abschnitte wichtig, dass ihr eine Variante mit dem ATmega328P-PU habt und nicht eine mit dem ATmega328P als SMD.

Weitere Bauteile

Was ihr sonst braucht, hängt davon ab, welche Wege ihr nachvollziehen wollt. Dass ihr Breadboards, Kabel, LEDs und Widerstände schon habt, setze ich voraus. Auf jeden Fall empfehle ich die Anschaffung von:

• 16 MHz Oszillatoren
• Kondensatoren: 22 pF, 0.1 µF

Es gibt so etwas teilweise als Kit, schaut z.B. mal hier, hier oder hier. Je nachdem, welche Beispiele ihr ausprobieren wollt, braucht ihr noch folgende Bauteile:

• FTDI232 USB-zu-Seriell Adapter
• einen zweiten Arduino UNO oder Arduino Nano
• USBtinyISP Programmer
• ggf. weitere Kondensatoren (100 nF und/oder 10 nF)

Pinout des ATmega328P vs Arduino UNO

Bevor es dann wirklich losgeht, hier noch zur Orientierung der Vergleich der Arduino Pins mit den Pins des ATmega328P:

Der Arduino UNO als Programmer

Ich habe mich bei diesem Teil des Beitrages im Wesentlichen an Anleitungen von Tom Heylen auf den Instructables Seiten (hier) und an einem Tutorial auf den Arduino Seiten (hier) orientiert. Bei Tom Heylen gibt es auch ein gutes Video. Allerdings führe ich die Dinge in meinem Beitrag etwas weiter aus und weise auf Fehlermöglichkeiten hin.

Die Arduino IDE vorbereiten

Zunächst einmal müsst ihr der Arduino IDE beibringen, mit dem „nackten“ ATmega328P umzugehen. Dazu führt ihr folgende Schritte aus:

• ladet diese diese Zip Datei herunter. Sie sollte mit den Arduino IDEs ab Version 1.6 funktionieren. Bei mir ging es mit 1.8.10 problemlos. Sonst schaut auch nochmal hier auf den Arduino Seiten.
• erstellt einen Ordner namens „hardware“ in eurem Arduino Sketchbook Verzeichnis, falls nicht schon vorhanden. Schaut in Datei –> Voreinstellungen, falls ihr nicht wisst, welches Verzeichnis das ist.
• entpackt die heruntergeladene Zip-Datei im hardware Verzeichnis.
• startet die Arduino IDE neu und prüft, ob ihr dort bei den Boards den Eintrag „ATmega328 on a breadboard (8 MHz internal clock)“ findet (aber noch nicht auswählen):

Aus dem Arduino einen ISP Programmer machen

Ladet den ArduinoISP Sketch aus den Beispielen der Arduino IDE auf den Arduino UNO. Dabei muss als Board noch der Arduino UNO eingestellt sein.

Dann baut ihr eine Schaltung entsprechend dem unten abgebildeten Plan auf. Zur Orientierung: die halbkreisförmige Vertiefung auf dem ATmega328P zeigt euch die Seite an, an der sich Pin 1 und Pin 28 befinden (siehe auch Pinout Schema weiter oben). Auf dem Fritzing Plan ist der Pin 1 also unten links. 

AVCC ist die separate Spannungsversorgung für die A/D-Wandler und die Port C Pins. Theoretisch müsste man AVCC in diesem Schritt nicht verbinden. Es wird aber allgemein empfohlen.

Im Menü „Werkzeuge“ wählt ihr als Programmer „Arduino as ISP“ – nicht mit „Arduino ISP“ verwechseln. Jetzt kann der Bootloader per ISP (In-System-Programming) übertragen werden.

Den Bootloader brennen

Was ist ein Bootloader?

Vereinfacht gesagt steuert der Bootloader wie die Sketche in den Speicher des Microcontrollers kommen, also wie sie hochgeladen werden. Mit der Wahl des Boards in der Arduino IDE wird beim Brennen des Bootloaders aber auch die Taktfrequenz festgelegt und ob ein interner oder externer Oszillator verwendet werden soll. Der ATmega328P verwendet in seiner Arduino UNO Umgebung einen externen 16MHz Oszillator. Wir wollen unsere standalone Lösung aber zunächst mit dem internen 8 MHz Oszillator betreiben. Deshalb wählt als Board „Atmega328 on a breadboard (8 MHz internal clock)“.

Der Brennvorgang

Im Menü Werkzeuge wählt ihr „Bootloader brennen“. Die folgende Warnmeldung ignoriert ihr:

Mögliche Probleme

Die folgende Fehlermeldung bekommt ihr, wenn ihr einen falschen Microcontroller verwendet habt, z.B. den ATmega328 („ohne P“).

Einmal habe ich auch folgende Meldung bekommen:

Hier hatte ich zwar den richtigen ATmega eingesetzt, aber leider war bei der gelieferten Charge der falsche Oszillator voreingestellt (8 MHz, extern). Mit Atmel Studio war es kein Problem das zu beheben, in diesem Setup allerdings schon. Falls ihr die Fehlermeldung auch bekommen solltet und kein Atmel Studio habt, dann probiert mal Variante 3.

Variante 1: Arduino UNO only / 8 MHz

Die Sketche selbst könnt ihr nun mithilfe des aufgespielten Bootloaders über die seriellen Pins RXD und TXD des ATmega328P übertragen. Da PCs heute üblicherweise keine serielle Schnittstelle mehr haben (die Älteren, zu denen auch ich gehöre, erinnern sich noch daran…), braucht ihr dazu jedoch einen USB-zu-Seriell-Adapter.

Entfernen des ATmega328P

Die gute Nachricht: der Arduino UNO hat so einen Adapter, da er auf dieselbe Art Sketche auf seinen internen ATmega328P hochlädt. Bei dem Adapter handelt es sich übrigens um den quadratischen IC oberhalb des Oszillators bzw. links neben den RX/TX LEDs. Die schlechte Nachricht: Der ATmega328P, der auf dem Arduino UNO sitzt, stört und muss entfernt werden. What??? Ja, richtig gelesen. Ist aber weniger dramatisch als man denkt. Am besten nehmt ihr dazu eine solche IC Zange, die es für ein paar Euro zu kaufen gibt:

Das Wichtigste ist dabei, den ATmega328P gleichmäßig herauszuziehen, damit die Beinchen nicht verbiegen. Aber selbst wenn ihr eins verbiegen solltet, bekommt man es meistens wieder hingebogen. Und wenn euch der ATmega328P dabei doch kaputtgehen sollte, ist das auch nicht dramatisch. Ich werde nachher noch zeigen, wie man einen frischen ATmega328P für den Gebrauch im Arduino UNO vorbereitet.

Schaltung und Sketch

Jetzt baut die Schaltung wie unten abgebildet auf. Die LED an PD7 (entspricht Arduino Pin 7) benötigen wir für den Beispielsketch.

Dann ladet den folgenden Blink Sketch hoch. Dabei lasst ihr als Board „ATmega328 on a breadboard (8 MHz internal clock)“ eingestellt. Die Auswahl des Programmers ist irrelevant.

void setup() {
  pinMode(7, OUTPUT);
}

void loop() {
  digitalWrite(7, HIGH);   
  delay(1000);                       
  digitalWrite(7, LOW);    
  delay(1000);                      
}

 

Geschafft. Der Sketch ist drauf, ihr könnt den Arduino UNO entfernen und das Miniprojekt mit einer geeigneten Spannungsquelle autark betreiben.

Variante 2: Arduino UNO und FTDI232 / 8MHz

Wenn euch die Prozedur mit dem Ziehen des ATmega328P aus dem UNO doch zu heikel oder auf Dauer zu nervig ist, dann könnt ihr euch einen separaten USB-zu-Seriell Adapter wie den FTDI232 besorgen. Den gibt es für wenige Euro z.B. hier. Wichtig ist, dass das Teil einen Pin namens „DTR“ hat, denn dieser steuert den Reset.

Den FTDI232 Adapter installieren

Bevor ihr den FTDI232 benutzen könnt, braucht ihr noch einen Treiber dafür. Den bekommt ihr zum Beispiel hier bei FTDI (Future Technology Devices International). Wenn ihr Windows benutzt, dann wählt, nachdem ihr dem Link gefolgt seid, „setup executable“:

Ladet die Installationsdatei herunter und führt sie aus. Nach Abschluss der Installation und Anschluss des Adapters sollte er im Gerätemanager so oder ähnlich auftauchen:

Schaltung und Hochladen

Auch bei Nutzung des FTDI232 kommt ihr um den ersten Schritt aus Variante 1, dem Brennen des Bootloaders per ISP, nicht herum. Aber danach könnt ihr mit dem Adapter munter Sketche hochladen, ohne die Prozedur wiederholen zu müssen. Ihr verbindet den Adapter wie folgt:

Beachtet, dass diesmal RX an TX und TX an RX kommt. DTR verbindet ihr über einen 100 nF Kondensator mit RESET. Wenn es Probleme gibt, versucht einen kleineren Kondensator, z.B. 10 oder 1 nF. Sonst wie gehabt GND an GND und VCC (Adapter) an VCC / AVCC des ATmega328P.

Zum Hochladen wählt ihr wieder „ATmega328 on a breadboard (…)“. Der Programmer spielt keine Rolle. Und nicht vergessen den richtigen Port zu wählen.

Variante 3: Arduino UNO und FTDI232 / 16 MHz

Vielleicht braucht ihr doch 16 MHz? Kein Problem. Für das Brennen des Bootloaders verwendet ihr folgende Schaltung (hier fand ich den Schaltplan übersichtlicher als das Breadboard Schema):

Gegenüber Variante 2 ist folgendes hinzugekommen:

• ein 16 MHz Oszillator an XTAL1 (PB6 / Pin 9) und XTAL2 (PB7 / Pin 10)
• XTAL1 und XTAL2 werden jeweils mit einem 22 pF Kondensator mit GND verbunden
• zwischen VCC und GND sitzt noch ein 100 nF Kondensator (muss aber nicht unbedingt, sofern ihr eine stabile Spannungsquelle habt)

Brennen des Bootloadersfunktioniert dann so:

• wie gehabt den ArduinoISP Sketch aus den Beispielen auf den Arduino UNO hochladen
• dann als Board den Arduino UNO wählen (bzw. dabei bleiben)
• als Programmer wählt „Arduino as ISP“
• Dann Werkzeuge –> Bootloader brennen

Sketche hochladen

Danach könnt ihr dann problemlos Sketche mit dem FTDI232 hochladen. Dazu verwendet ihr folgende Schaltung:

Zu beachten: hier wieder TX an RX und RX an TX. Außerdem kommt wieder zwischen DTR und RESET ein 100 nF. Auch hier wieder zu einem kleineren Kondensator wechseln, falls es Probleme beim Hochladen gibt. Als Board wählt ihr den Arduino UNO, der Programmer ist irrelevant. Und wieder nicht vergessen ggf. den Port zu wechseln.

Im Betrieb

Im Betrieb ohne den FTDI232 müsst ihr dann natürlich den 16 MHz Oszillator beibehalten:

Den ATmega328P im Arduino UNO programmieren

Noch eine pragmatische Idee: warum nicht den ATmega328P direkt im Arduino UNO programmieren? Dort habt ihr ja die bequemen Pinleisten und müsst euch zumindest während der Projektentwicklung nicht mit dem Oszillator und der Resetverdrahtung herumschlagen. Erst wenn das Konzept steht, baut ihr den ATmega328P aus und fügt die notwendige Peripherie, z.B. Spannungsversorgung und Oszillator, hinzu. 

Aber dann habe ich doch keinen funktionierenden UNO mehr!?

Kein Problem. Setzt einen neuen ATmega328P in den Arduino UNO ein. Dann nehmt ihr zweiten UNO oder ein anderes Board und brennt damit den Arduino UNO Bootloader. In diesem Beispiel nehme ich einen Arduino Nano als Programmiereinheit:

Was ihr machen müsst, dürfte keine Überraschung mehr sein:

• das Board, das als Programmiereinheit dient, bekommt den ArduinoISP Sketch hochgeladen
• dann wie oben abgebildet verkabeln; nur die Programmiereinheit kommt per USB an den PC
• In der Arduino IDE als Board „Arduino UNO“ wählen
• Programmer: „Arduino as ISP“
• dann Werkzeuge –> Bootloader brennen

Fertig, der UNO ist wieder hergestellt. Alternativ könnt ihr den Bootloader natürlich auch wie weiter oben bei Variante 3 brennen und den ATmega328P dann in den UNO einsetzen.

Programmierung mit dem USBtinyISP

Vorbereitung

Das Schöne an dieser Variante ist, dass ihr für das Brennen des Bootloaders und das Hochladen der Sketche nicht die Verkabelung wechseln müsst. Alles läuft per ISP Programmierung. Der Nachteil liegt auf der Hand: ihr braucht erstmal einen USBtinyISP. Den gibt es aber für <10 Euro bei Amazon, eBay und Co. Etwas gravierender ist, dass mangels serieller Verbindung auch der serielle Monitor nicht funktioniert.  

Nützliche Helfer

Ein weiterer Nachteil ist der nicht so übersichtliche, 6-polige ISP Anschluss. Da kann man sich bei der Verkabelung leicht vertun:

Besorgt euch deshalb am besten auch noch einen Breadboard Adapter und das passende Verbindungskabel dazu:

Für den Adapter sucht in Online-Shops nach „ISP Breadboard Adapter“. Das Kabel findet ihr z.B. unter dem Suchbegriff „IDC Kabel 6 polig Pfostenbuchsen“.

Treiberinstallation

Dann braucht ihr noch einen Treiber für den USBtinyISP. Den findet ihr z.B. hier auf den Adafruit Seiten. Startet die Installation und setzt den Haken bei der Treiberauswahl wie folgt:

Der USBtinyISP sollte dann so oder so ähnlich im Gerätemanager auftauchen:

Schaltung und Hochladen

Als Board stellt ihr den Arduino UNO ein, als Programmer USBtinyISP. Stört euch nicht daran, dass Port ausgegraut ist – das gehört so. Dann brennt den Bootloader. 

Beim Hochladen der Sketche gibt es einen wichtigen Punkt zu beachten. Das Hochladen Symbol (Pfeil nach rechts) und „Hochladen“ über das Menü funktioniert nicht. Ihr müsst „Hochladen mit Programmer“ im Menü wählen.

Damit sollte es dann funktionieren. Wenn ihr den ATmega328P mit 8 MHz betreiben wollt, müsst ihr einfach nur wieder „Atmega328 on a breadboard…“ als Board auswählen und den Bootloader neu brennen.

Volle Kontrolle: Atmel Studio

Die volle Kontrolle über den ATmega328P erlangt ihr erst mit der kostenlosen Software Atmel Studio. Vor einiger Zeit habe ich einen Beitrag zu diesem Thema veröffentlicht. Ihr findet ihn hier. Ich habe den Beitrag zwar am Beispiel der Programmierung eines ATtiny85 verfasst, aber da könnt ihr schauen, ob das überhaupt etwas für euch sein könnte. Die Software ist etwas gewöhnungsbedürftig, man braucht einen Programmer und man verwendet typischerweise „C“ als Sprache. Ihr werdet allerdings auch reichlich belohnt, z.B. mit:

• Kontrolle über die Fuse Bits
• Erweiterte Oszillatoreinstellungen
• Ihr könnt praktisch jeden AVR Microcontroller programmieren
• Die „C“ Programme sind meist wesentlich schneller als ihre Arduino Pendants
• Debugging Funktion

Danksagung

Der Hintergrund des Beitragsbildes, in den ich den ATmega328P hineingebastelt habe, stammt von Harut Movsisyan auf Pixabay.