ATmega328P standalone betreiben

Ü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:

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?

ATmega328P
Der ATmega328P (PU)

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:

Pinbelegung ATmega328P vs. Arduino UNO
Pinbelegung ATmega328P-PU vs. Arduino UNO

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):
„ATmega328 on a breadboard“ 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.

ArduinoISP aus den Beispielen wählen

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. 

ATmega328P : Bootloader mit dem Arduino UNO brennen
ATmega328P: Bootloader mit dem Arduino UNO brennen

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:

Warnmeldung in der Arduino IDE ignorieren
Warnmeldung ignorieren

Mögliche Probleme

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

Fehlermeldung: falscher Microcontroller

Einmal habe ich auch folgende Meldung bekommen:

Fehlermeldung: Invalid Device Signature – tritt auch bei falscher Clock-Einstellung auf

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:

IC Zange

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.

ATmega328P mit Arduino UNO als Programmer
ATmega328P mit Arduino UNO als Programmer

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.

FTDI232 USB-zu-Seriell Adaper
FTDI232 USB-zu-Seriell Adaper

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“:

FTDI232 Treiber für Windows
FTDI232 Treiber für Windows

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:

Der FTDI232 Adapter im Windows Geräte Manager
Der FTDI232 Adapter im Windows Geräte Manager

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:

ATmega328P mit FTDI232 programmieren

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):

Schaltung zum Brennen des Bootloaders für den 16 MHz Betrieb

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:

Schaltung zum Hochladen der Sketche mittels FTDI232

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:

Standalone Schaltung für den ATmega328P

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:

Schaltung zum Brennen des Bootloaders auf dem ATmega328P

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.  

Der USBtinyISP Programmer

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:

Treiberauswahl für den USBtinyISP

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

Schaltung und Hochladen

Schaltung für den 16 MHz Betrieb

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. 

USBtinyISP als Programmer wählen

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.

Ganz wichtig: nur „Hochladen mit Programmer“ funktioniert

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.

7 thoughts on “ATmega328P standalone betreiben

  1. Super Anleitung! Lässt sich die Schaltung für den USBtinyISP eigentlich vereinfachen, wenn man die interne 8 MHz Clock benutzten möchte und nicht die externe 16 MHz? Grüße

    1. Hi Martin, es geht zumindest nicht, wenn du dabei den Arduino UNO als Board wählst. Dann wird der ATmega328P auf 16 MHz eingestellt. Was du mal ausprobieren könntest, ist die Auswahl „ATmega328 on a breadbord (8 MHz internal clock)“ und dann mit dem USBtinyISP als Programmer (ich selbst habe das nicht ausprobiert). Dafür muss der ATmega328P allerdings vorher mit einer der oben beschriebenen Methoden auf 8 MHz umgestellt worden sein. Wenn das geht, dann kannst du den Oszillator und die beiden 22pF Kondensatoren weglassen. Der 100 nF Kondensator wird sowieso nicht unbedingt benötigt, wenn du eine stabile und saubere Spannungsversorgung hast.

  2. Hallo Wolfgang,

    da ich keinen Uno habe, kann ich den ATmega328P direkt mit einem Nano verdrahten und programmieren, so wie im Abschnitt „Den ATmega328P im Arduino UNO programmieren“ beschrieben?
    Ich habe nur einen Nano und eben den ATmega328P.
    Vielen Dank!
    Michael

  3. Hallo Wolfgang,
    Ich habe Deine Artikel zu Atmel Studio 7 und den standalone Artikel gelesen. Sehr hilfreich, vielen Dank,
    Mittlerweile programmiere ich in der Arduino Umgebung (weil so schön einfach) und schreibe dann aut einen atmega 328p (in system, also eingebaut in meine Hardware). Das hat bis jetzt gut geklappt. Dummerweise benötigt mein Programm jetzt etwas mehr als 29kByte. Der Nano ist da noch willig. Wenn ich für den atmega328p kompiliere, ist dar Programm allerdings deutlich zu groß > 34k.
    Hast Du eine Erklärung und am besten noch einen Tipp?
    Erzeugt das Atmel Studio einen kleineren Coder?
    Gruß Frank

    1. Hallo Frank, du verwendest dann als „Board“: Atmega328 on a breadboard? Warum das Programm dann mehr Platz braucht als auf einem Nano ist mir nicht ganz klar. Ist ja beides letzten Endes ein ATmega328P. Mit einem nackten ATmega328P könntest du noch das ateval Board ausprobieren, da kann man den Atmega328P per ISP programmieren und spart sich schon mal den Bootloader. Da habe ich auch mal drüber geschrieben. Aber man setzt dort den Microcontroller eigentlich rein. Ich habe noch nicht ausprobiert, ob man damit einen Microcontroller extern programmieren kann. Atmel Studio macht schlanke Programme, aber normalerweise übernimmt man nicht einfach so die Arduino Programme sondern schreibt sie um. Mittlerweile kann man auch Arduino Programme importieren, ich weiß aber nicht, wie sich das auf die Größe auswirkt. Müsste man ausprobieren. Bleibt noch das Programm selbst – hast du da schon alles ausgeschöpft? Brauchst du wirklich so viel Platz? Es gibt da u.U. ein paar Möglichkeiten. Z.b. Variablen als Referenzen an Funktionen übergeben. Mehr fällt mir spontan erstmal nicht ein.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.