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.

46 thoughts on “ATmega328P standalone betreiben

  1. Hallo Wolle,
    ich hab zwar keine Ahnung, von welchem Mikrocontroller du das Layout veröffentlicht hast, aber von einem Atmega328p stammt es definitiv nicht.
    Gruß
    Glenn

  2. Hallo Wolfgang,
    erst einmal herzlichen Dank für Dein Tutorial. Ih bin zwar kein „Newbie“ in Sachen Arduino, doh hatte ich noch nie einem „Arduino“ oder dazugehöriges Board programmiert. Ich konnte den Bootloader wohl richtig nach deiner Anleitung brennen, doch als ich dann meinen Sketch in den Standalone ATMEGA328P brennen wollte, bekomme ich die Fehlermeldung, dass nach 10 Versuchen keine Kommunikation aufgebaut werden konnte. Nach dem Vertauschen der RX/TX- Leitungen kommt diese Meldung sofort. Ich habe einen USB-seriell- Konverter mit FTDI- und mit CH340- Chip probiert. Auch kleinere Kondensatoren in der Reset- Leitung haben nichts gebracht.

    Wenn ich die Option „Hohladen mit Programmer“ und den Programmer, den ih zum Brennen des Bootloaders verwendet habe, konnte ich meinen Sketch hohladen. Ich möchte aber gerne den Bootloader verwenden, denn dann kann ich später den ATMEGA „in circuit“ brennen.

    Hast Du noch eine Idee, was ich noh ausprobieren könnte?

    Liebe Grüße

    1. Hallo Mathias,

      wenn du den Bootloader brennen kannst, dann sollten die Sketche eigentlich kein Problem sein. Ich schließe aus dem, was du schreibst, dass du einen Programmer zum Brennen des Bootloaders verwendet hast, also nicht den Arduino als Programmer. Wenn du dann Sketche mit dem Programmer hochladen willst, dann musst du auf jeden Fall die Option „Hochladen mit Programmer“ wählen. Dadurch wird aber kein Bootloader überschrieben. Aber du möchtest lieber den USB-seriell Konverter verwenden? Sollte eigentlich funktionieren. Aber mit dem „eigentlich“ ist das immer so eine Sache. Wichtig ist, dass du beim Brennen des Bootloaders und beim Hochladen „Atmega328 on a breadboard (8 MHz internal clock)“ als Board auswählst. Wenn du das nicht tust und die 16 MHz haben willst, dann musst du einen Oszillator installieren. Beim Hochladen per USB-zu-Seriell sollten nichts anderes an TX und RX hängen, das könnte stören.
      Weiß nicht, ob das irgendwie weiterhilft. Falls nicht, dann müsste ich ganz genau im Detail und Schritt für Schritt wissen, was du gemacht hast. Welcher Programmer, wie angeschlossen, was eingestellt, usw.
      VG, Wolfgang

      1. Hallo Wolfgang,
        danke für deine schnelle Rückmeldung
        Nun, folgendes habe ich gemacht:
        1. Ein Arduino „boarduino“ als Programmer hergestellt.
        2. Einen „nackten“ ATMEGA328P-PU aus der Verpackung genommen und mit dem Programmer „verdrahtet“.
        3. Programmer „ARDUINO as ISP“ gewählt und in den nackten ATMEGA den Bootloader gebrannt (Atmega328 on a breadboard (8 MHz internal clock). Das hat funktioniert, denn die LED auf meinem Programmer- Board an D13 blinkt.
        4. „Nackter“ ATMEGA von Programmer gelöst und den USB/seriell- Adapter verdrahtet. USB/seriell- Adapter in den PC gesteckt und COM-Port gewählt.
        5. Einen Sketch geladen und versucht mit dem Adapter den Sketch hochzuladen. Schlägt wie beschrieben fehl.
        6. eine LED an den nackten ATMEGA angeschlossen (D13). Die LED blinkt -> Bootloarder ist wohl noch intakt.
        7. ATMEGA wieder in den Programmer und „meinen Sketch“ mit „mit dem Programmer hochladen“ hochgeladen -> funktioniert.

        Später möchte ich mit der ARDUINO- Oberfläche meinen Sketch weiterentwickeln und der Schaltung hochladen. Leider habe ich die Ports für die ISP- Schnittstelle schon verwendet, daher wäre die Programmierung über den USB/seriell- Adapter charmant.

        Gruß
        Mathias

        1. Hallo Mathias,

          da mir das keine Ruhe gelassen hat, habe ich es gerade noch einmal ausprobiert und es funktioniert. Deine detaillierte Beschreibung zeigt keine Abweichung. Eine Fehlerquelle könnte noch in Schritt 5 liegen. Das Hochladen erfolgt dort durch einfaches Hochladen und nicht durch Hochladen mit Programmer. Vielleicht sollte ich das noch einmal explizit schreiben. Die Einstellung des Programmers sollte in diesem Schritt eigentlich keine Rolle spielen (ich habe verschiedene Einstellungen probiert) , aber stelle trotzdem mal AVRISP mkrII ein. Und wenn ein Versuch nicht funktioniert hat, dann schalte den ATmega328P zwischendurch stromlos.
          Und wird der USB zu TTL Adapter richtig erkannt (Gerätemanager)?
          Sonst fällt mir im Moment nicht mehr ein.
          Ich hoffe es klappt noch. Viel Erfolg.
          VG, Wolfgang

          1. Hallo Wolfgang,
            Ja, der USB- Adapter wird erkannt und befindet sich an einer anderen „COM“- Schnittstelle als der Programmer. Der Download des Sketches erfolgt mittels dieses Adapters. Es muss die „richtige“ COM- Schnittstelle sein, denn, wenn ich RX und TX vertausche, erhalte ich sofort eine Fehlermeldung und nicht erst nach zehn Versuchen. Ich vermute, dass der Bootloader nicht „der richtige“ ist, oder dass der Controller nicht mit acht MHz betrieben wird.
            Wie dem auch sein, ich habe erst einmal das „Bootloader- Projekt“ eingestellt und lade jetzt die Sketches über die Programmierschnittstelle. Blöd ist nur, dass ich die I/O-Pins für die Programmierschnittstelle (D9 bis D12) belegt habe, das musste ich ändern.
            Vielen Dank auf jeden Fall für deine Mühe.

            Gruß
            Mathias

  3. Hallo Wolfgang,
    ich habe erfolgreich auf 5 China Atmegas 328P-PU mit einem selbstgebauten Uno den Bootloader gebrannt.
    Jetzt hatte ich die Idee, mal einen von ihnen nach deiner Anleitung standalone mit internen 8 MHZ zu betreiben.
    Aber das Brennen des Bootloaders funktioniert absolut nicht. Leider habe ich keinen „jungfräulichen Chip z.Zt. zur Verfügung, um das mit ihm auszuprobieren. Eigentlich müsste doch der Bootloader überschreibbar sein, oder?
    Wie ist deine Ansicht dazu?
    Vielen Dank im Voraus,
    und viele Grüsse,
    August

    1. Hallo August, ja, der Bootloader ist überschreibbar. Allerdings hast du den Atmega328P auf 16 MHz eingestellt, wenn der Arduino Bootloader drauf ist. Genau genommen hat das nichts mit dem Bootloader, sondern den Fuse Bits zu tun. Wenn du also nun versuchst den „Standalone Bootloader“ zu brennen, geht gar nichts. Also muss für diesen Schritt ein 16MHz Oszillator angeschlossen werden. Ist es das? Oder hattest du den Quarz schon dran? Würde mich freuen zu hören, ob es funktioniert. VG, Wolfgang

      1. Hallo Wolfgang,
        Nein, ich hatte ihn nicht dran.
        Also den 16MHz Oszillator am Breadboard-Atmega verdrahten und dann trotzdem als Zielsystem den Breadboard Atmega mit 8MHz intern anklicken? Okay, ich probiere das aus. Läuft er denn dann auch später bei den Uploads und in der Anwendung mit 8MHz? Oder muß für jeden Upload der 16MHz Schwinger angeschlossen werden?
        Viele Grüsse, August

        1. Genau, wenn der Atmega328P wieder auf 8MHz umgestellt ist, dann kann man den Oszillator wieder entfernen. Wenn man ihm „sagt“ er habe einen externen Oszillator, dann wartet er geduldig, dass Taktsignale kommen. Und wenn nix kommt, dann wartet er ewig. Und ohne Takt passiert nichts.

          1. Hallo Wolfgang, es hat alles auf Anhieb funktioniert, Bootloader brennen und dann Blink-Sketch per FTD1232 hochladen. Jetzt blinkt der Käfer endlich friedlich vor sich hin.
            Ich hatte erwartet, dass sich die Blinkfrequenz wegen der internen 8MHz halbieren würde. Ist aber erstaunlicherweise nicht der Fall.
            Herzlichen Dank für Deine Hilfe,
            August
            PS:
            Schon länger stöbere ich in deinem Blog. Dabei fällt mir die wirklich professionelle Gesamtgestaltung auf. Die Blogstruktur, die geschliffene, schlüssige und verständliche Aufmachung jedes einzelnen Posts und nicht zuletzt die schnelle und freundliche Kommunikation mit deinen Lesern: toller Blog, herausragend im World Wide Web.

            1. Vielen Dank für da Feedback!
              Dass man die Frequenz nicht im Programm berücksichtigen muss, ist wirklich ganz bequem. Wenn man z.B. mit Atmel Studio arbeitet, muss man nach Änderung der Frequenz das auch nochmal extra angeben. Viel Spaß noch!

  4. Hallo Wolfgang,
    nun stehe ich als Maschinenbauer auf natüriche Art und Weise mit der Elektrik auf Kiregsfuss – von der Elektronik ganz zu schweigen. Mit deiner Anleitung komme ich spitzenmäßig zurecht. 1000 Dank dafür! damit komme ich der Realisierung meines Projektes ein gehöriges Stück weiter. Nur das Brennen des Bootlaoders klappt nicht. Fehlermeldung: Invalid Device Signature. Hast du zufällig eine „Anleitung“, wie ich das mit ATMEL einstellen kann? (Du hattest erwähnt, das dies über ATMEL kein Problem ist).
    Was habe ich vor:
    Für mein Projekt möchte ich den ATmega328P stand alone betreiben. Wegen Platz- und Eergiebedarf reichen mir auch die 8MHz (Möchte keine zusätzlichen Bauteile auf die Platine Löten…)

    Danke und Gruß
    Matthias

    1. Hallo Mathias,

      die schlechte Nachricht zuerst: außer Atmel Studio brauchst du einen Programmer, z.B. diesen hier:

      https://smile.amazon.de/ISP-Programmer-ATMEL-STK500-ATmega-ATtiny/dp/B0068M158K/ref=sr_1_2?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=USB+ISP+Programmer+Tremex&qid=1612810688&sr=8-2

      Mit dem kommst du dann an die Microcontroller Einstellungen. Das macht du in Atmel Studio (neuerdings übrigens Microchip Studio) im Bereich Device Programming. Wie du da hinkommst, habe ich hier beschrieben:

      https://wolles-elektronikkiste.de/atmel-studio-7-ein-einstieg

      Und dann wählst du da den 8 MHz / Interner Oszillator.

      Bevor du Geld ausgibst prüfe aber nochmal alles. Sind alle Kabel OK, alle Einstellungen richtig? Hast du z.B. wirklich einen ATmega328P-PU (also mit dem „P“ nach der 328)?

      Wenn du mehr mit den „nackten“ Microcontrollern und mit Atmel Studio machen willst, kann ich alternativ auch den ateval 2.0 empfehlen: https://wolles-elektronikkiste.de/ateval-2-0-das-universalwerkzeug. Der kostet 30 Euro, aber dafür brauchst du keinen extra Programmer und das Teil ist super flexibel.

      Viel Erfolg und vor allem viel Spaß, Wolfgang

      1. Hallo Wofgang,

        so schnell habe ich nicht mit einer Antwort gerechnet – Danke!
        Deine Links bestätigen meine Theorie: Die ganze Welt verdient Geld mit Adaptern. :))
        Werde mich wohl nicht an ein ateval heranwagen, sondern probiere mal „Variante 3: Arduino UNO und FTDI232 / 16 MHz“. Ich denke das bekomme ich dann hin.

        Nochmal Danke!
        Matthias

      2. Hi Wolfgang,

        habe nun die Schaltung mit einem 16MHz Oszilator nachgeabaut.
        Leider bekomme ich den Bootloader nicht gebrannt. 🙁
        Ich erhalte stets folgende Fehlermeldung:

        avrdude: Device signature = 0x000000
        avrdude: Yikes! Invalid device signature.
        Double check connections and try again, or use -F to override
        this check.

        Ist dir diese Meldung auch schon einmal untergekommen?
        Ich verwende definitv den Richtigen Chip (328P). Auch „Adruino as ISP“ ist eingestellt.

        Gruß
        Matthias

        1. Und welchen Programmer nimmst du? Mit dem FTDI232 kannst du keinen Bootlooader brennen. Das geht nur über ISP (also die Varianten mit MISO/MOSI/SCK Verbindung).

          1. Als Programmer habe ich die Arduino IDE genommen.
            Nach einem Neustart des Rechners hat alles Einwandfei funktioniert. Manchmal hilft eben nur AEG (auschalten, einschahlten, geht).

  5. Ich hab jetzt auch mal nach einem AVR-Dragon gesucht, die werden aber anscheinend nicht mehr produziert und ein atmel ice ist ganz schön teuer für im Moment…..muss ich mich eben erstmal anders durchschlagen solange muss ich dann eh C lernen……

  6. https://www.amazon.de/ARCELI-AVRISP-AVRISP-System-Programmer-unterst%C3%BCtzt/dp/B07R6LVVZW/ref=sr_1_6?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=atmel-ice+programmer&qid=1612284713&sr=8-6

    ist dieser Programmer eine Option? Da ich meine Projekte ja Platzsparender machen möchte und somit nur den ATmega 328P-PU benutzen möchte z.B.

    verzeih das ich so nerve….

    habe gestern noch die Arduino IDE neu installiert, dabei nicht darauf geachtet das ich meine Sketche und die libs sichere……jetzt ist alles weg was ich in den letzten 4 Jahren geschrieben und an libs gesammelt hatte…..
    somit muss ich Komplett neu anfangen und dachte ich steige direkt auf standalones um….

    Danke für Infos…

    Thorsten

    1. Ach du liebes bisschen – große Katastrophe! Mein Beileid zu den verlorenen Sketchen….

      Also der Programmer sollte funktionieren. Ich sage „sollte“ und nicht „wird“, weil ich ihn nicht ausprobiert habe. Hauptsache er kann ISP. Günstiger ist der von mir beschriebene USBtinyISP. Bei den Programmern solltest du dir nur bewusst sein, dass der Serielle Monitor nicht funktioniert. Ich würde immer in der bequemen Arduino Umgebung entwickeln und dann zum Schluss die Dinge auslagern.

      1. Danke….aber was solls….dann muss ich eben nochmal neu lernen……kann ich dich bei Programmierproblemen auch anschreiben?

        Hatte mir jetzt einen FTDI bestellt, werde mir aber den USBtinyISP auch holen mit allem was du da so dazulegst….

        Danke nochmal……

        Bin im Moment doch etwas durch den Wind wegen der Sketche und libs…sry

  7. Ich habe jetzt die zip Datei nochmal neu installiert in Arduino > Sketchbook > hardware > breadboard-1-6-x > breadboard > avr > bootloaders > atmega

    da hab ich dann nur diese HEX-Datei

    ATmegaBOOT_168_atmega328_pro_8MHz.hex

    der Ordner variants unter avr ist leer….

    und im Ordner avr hab ich noch boards.txt

    das war alles was in dieser zip.Datei vorhanden ist….

    Gruss
    Thorsten

    1. Ich glaube, wir kommen der Sache näher. Lege keinen Ordner namens „sketchbook“ an, sondern lege den Ordner „hardware“ in deinem Sketchbook Ordner an. Wie der heißt findest du in den Voreinstellungen. Da steht ganz oben „Sketchbook-Speicherort“. Zum Beispiel ist mein Sketchbook Ordner:

      C:\Users\Ewald\Documents\Arduino

      Also habe ich dort den Ordner hardware angelegt und darin die Zip Datei entpackt, so dass es am Ende so aussieht:

      C:\Users\Ewald\Documents\Arduino\hardware\breadboard\avr\bootloaders\atmega\ATmegaBOOT_168_atmega328_pro_8MHz.hex.

      1. So….nachdem ich jetzt die Arduino IDE noch 2 mal deinstalliert und neu installiert habe funktioniert es jetzt….ATmega328 on breadbord ist jetzt da.

  8. Hallo….bei mir funktioniert auch die Variante mit neuem ATmega im UNO und NANO als Programmiereinheit nicht…

    1. Der Hilferuf ist angekommen…ich brauche aber schon mehr Informationen, sonst kann ich nichts machen. Die Fehlermöglichkeiten sind sonst zu vielfältig.

      1. Hallo….danke für die schnelle Rückmeldung…..ich muss das die nächsten Tage nochmal ausprobieren und melde mich dann nochmal

        Gruss
        Thorsten

  9. Hallo…..ich habe alles ausprobiert, bekomme aber das „ATmega328 on a breadbord (8 MHz internal clock)“ nicht in die Boardverwaltung….wo liegt mein Fehler…..

    liebe Grüsse

    Thorsten

    1. Hallo Thorsten, ich würde am ehesten tippen, dass das hardware Verzeichnis nicht dort ist wo es sein soll. Kannst du das nochmal prüfen?
      Oder du hast alles richtig gemacht und nur nicht gefunden weil die Boards in den neuesten Arduino IDE Versionen ein bisschen anders angeordnet sind. Findest du den Eintrag breadboard-avr (in sketchbook)? Dahinter ist dann ATmega328 on a breadbord (8 MHz internal clock).

  10. Zunächst einmal musst du den Bootloader auf jeden Fall brennen, wenn der Atmega328P schon mal auf dem Board war und du ihn mit 8 MHz betreiben möchtest. Denn auf dem Board wird der Atmega328P mit externen 16 MHz betrieben. Und wenn du ihn dann auf das Breadboard setzt, dann sucht er den Taktgeber und findet ihn nicht. Und wenn du das ganze wieder rückgängig machst, also einen Atmega, der 8 MHz lief, zurück auf ein Arduino Board bringst, musst du auch erst wieder den Bootloader brennen (weiter unten im Beitrag steht wie).
    Aber ich gehe mal davon aus, dass im Arduino selbst ein funktionierender ATmega328P sitzt (richtig?). Ich gehe auch davon aus, dass du den ArduinoISP Sketch erfolgreich auf deinen Arduino laden konntest (auch richtig?). Wenn das passiert ist, wählst du „Arduino as ISP“ als Programmer und als Board „ATmega328 on a breadboard (8MHz internal clock)“. Wie ist die Fehlermeldung, wenn du dann den Bootloader brennen willst? Sagt er dann auch, dass er den Programmer nicht findet? Ich würde sonst auch mal alle Kabel tauschen. Ich hatte mal ein defektes Steckbrückenkabel und habe stundenlang nach anderen Fehlern gesucht. Und du könntest mir noch ein Foto von deinem Aufbau per e-mail schicken. Vielleicht sehe ich ja irgendeinen Fehler.

    1. Hallo Wolfgang,

      Ich habe die Schaltung nun ohne Bootloader brennen mit einem externen 16MHz Quarz realisiert und einfach das Beispielprogramm hochgeladen. Schaltung sieht dann aus wie in dem Link von Arduino unter „Uploading Using an Arduino Board“ beschrieben. In der Arduino IDE habe ich allerdings „Arduino Uno“ als Board ausgewählt. Funktioniert jetzt alles!! Ist auch besonders gut, wenn man (wie ich) nur einen einzigen Atmega zur Verfügung hat 😀

      Vielen Dank für die super Erklärungen und deine schnelle Hilfe!
      Viele Grüße und schönes Wochenende
      Lea

  11. Hallo Wolfgang,
    danke für die ausführliche Erklärung. Ich versuche für ein Projekt die Variante „Arduino Uno only/8MHz“ zu realisieren. Leider bekomme ich immer die Fehlermeldung „Programmer not responding“… Ich habe „ATmega328 on a breadboard“ ausgewählt, nachdem ich der Anleitung zur Einstellung der IDE gefolgt bin. Gesteckt auf dem Steckbrett ist auch alles richtig und der Atmega selbst ist auch funktionsfähig. Kannst du mir einen Hinweise geben, was ein Problem sein könnte? Meiner Meinung nach habe ich alles so gemacht wie in deiner Anleitung…
    Vielen Dank und Gruß
    Lea

    1. Hallo Lea,

      welche „Untervariante“ hast du gewählt? Die mit dem Arduino Board als Programmer (mit entferntem ATmega328P) oder die mit dem mit dem FTDI232 Adapter? Oder klappt schon die Vorbereitung nicht, nämlich das Brennen des Bootloaders? Wenn ich das weiß, dann kann ich etwas zielgerichteter antworten. Bis dahin: nicht verzweifeln – das wird schon.

      Schöne Grüße, Wolfgang

      1. Hallo Wolfgang,
        ich habe versucht den Bootloader nach dieser Anleitung zu brennen (die hast du oben auch als Referenz angegeben): https://www.arduino.cc/en/Tutorial/BuiltInExamples/ArduinoToBreadboard
        Das klappt auch nicht leider. Das steht zwar, dass man das angeblich nicht braucht, wenn der Atmega schon einmal auf dem Arduino Board programmiert wurde, aber ich wollte es sicherheitshalber trotzdem machen… Ich möchte die Variante mit dem Arduino als Programmer also mit entferntem Atmega verwenden.
        Viele Grüße und Danke
        Lea

  12. 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.

  13. 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

  14. 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.

Schreibe einen Kommentar

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