Atmel ATmega328P-DIP28 nackt als Einzelchip betreiben

Arduino-Mikrocontroller kennen wir in den unterschiedlichen Bauformen: Die große Platine heißt Arduino Uno, die winzige Arduino Nano.

Auf beiden Vertretern werkelt als Mikrocontroller-Chip der Atmel ATmega328P. Bei neueren Käufen dieser Platinen aus Fernost sind dort meistens die winzigen, quadratischen Chips in SMD-Bauform TQFP-32 verlötet. Die Beinchen sind allerdings dermaßen klein und eng beieinander, dass das Löten hier keinen Spaß macht. Die sind mehr auf maschinelle Fertigung ausgelegt.

Ältere UNO-Boards, oder wenn man darauf achtet, zeigen aber, dass es auch eine benutzerfreundliche Bauform dse ATmega328P gibt, nämlich die DIP-28:

Unter sieht man den länglichen Chip mit 28 Beinchen, der wunderbar auf einem Breadboard Platz findet und sogar praktischerweise schmal ist. Man nennt diese Bauform auch DIP-28 narrow.

Diese ATmega328P-Chips kann man auch nackt, also stand-alone ohne das ganze Drumherum auf der Platine benutzen. Dann verliert man natürlich den Spannungswandler, den USB-Port, die Programmiermöglichkeit über USB, die interne LED, den Reset-Taster etc. pp.

Aber auf der anderen Seite braucht man natürlich sehr viel weniger Platz. Einen ATmega "nackt" zu betreiben kann also durchaus Sinn machen. Ein paar Zusatzkomponenten an Hardware braucht der ATmega natürlich trotzdem, aber das hält sich in Grenzen.

Pinout ATmega328P

Bevor wir uns aber an den Aufbau auf einem Breadboard machen, wollen wir erstmal klären, wie die 28 Pins verschaltet sind. Denn die netten Buchsen und Beschriftungen von einem Uno haben wir ja dann nicht mehr. Ich habe dazu mal wieder ein kleines Pinout gezeichnet:



Download als PDF


Wie wir sehen, finden wir unseren ganzen GPIO-Pins wieder: die digitalen von D0 bis D13 und die analogen von A0 bis A5. Die kennen wir ja alle schon von Arduino.

Neu ist vielleicht AREF. Das ist der Pin für die analoge Referenzspannung für den Analog-Digital-Konverter. Mit dieser Spannung wird verglichen und wenn analogRead 1023 zurückgibt, dann ist diese Referenz-Spannung voll erreicht. AVCC ist die Spannung für die Analog-Digital-Wandler und sollte einfach mit VCC verbunden werden.

PC6/RESET führt je nach Konfiguration (RSTDISBL Fuse) einen Reset aus, wenn auf Low gezogen oder kann auch als I/O Pin benutzt werden. Wir bevorzugen natürlich eine RESET-Leitung. Diese können wir realisieren, indem wir über einen Pullup Widerstand (z. B. 10 kOhm) die Spannung auf High ziehen und durch einen Taster kurzzeitig auf GND ziehen.

Bleiben noch PB6/OSC1/XTAL1 und PB7/OSC2/XTAL2 an Pin 9 und 10. Hier wird ein Quartz mit 16 MHz über zwei Kerkos angeschlossen, um den ATmega mit einem Takt zu versorgen.

Und wie jetzt die Firmware flashen?

Wenn man einen ATmega328p ganz frisch kauft, kann es sein, dass dieser ohne Bootloader kommt. Die ist auch dafür zuständig, über den TX/RX UART-Port Daten entgegenzunehmen und dann in den Flash-Bereich des Chips zu schreiben. Ohne Bootloader wird das allerdings nichts. Dann braucht man einen Eprommer, mit dem man kurzerhand das Image aus einen ATmega328P aus einem vorhanden Uno-Board nimmt und dann auf den neuen Chip schreibt/kopiert.

Sicher kann man sich auch jedesmal die Binary-Image-Files heraussuchen, die mit jedem Build-Vorgang mit der Arduino IDE oder Visual Studio Code mit Platform IO erzeugt werden und diese dann im Eprommer laden und flashen, aber einfacher ist es, ein Uno-Board zu nehmen und dort den ATmega einzusetzen und ganz normal die Firmware hochzuladen und dann den ATmega aus der Fassung zu nehmen und mit der neuen Firmware zu verwenden.

Wenn man dann noch einen 28-poligen ZIF-Sockel in die IC-Fassung einsetzt, dann hat man ein komfortables Flash-Gerät, bei dem die Chips ohne großen Aufwand eingesetzt und entnommen werden können.



Leider hat bei mir der ZIF-Sockel so nicht in den IC-Sockel gepasst. Denn der ZIF-Sockel ist etwas breiter und geht über die Kanten des ursprünglichen Sockels und dort ist dann ein Kondensator auf der Platine im Weg. Also musste ich ihn auf "Stelzen stellen". Das heißt, ich habe unten einfach zwei 14-polige Stiftleisten angelötet. Dafür schwebt der ZIF-Sockel jetzt über der Platine und kommt nichts in den Weg. Außerdem hält er so noch besser im IC-Sockel.

Während des Programmierens ist der ATmega im Uno und man kann dort auch Serial.Print und dergleichen benutzen, um das Programm zu debuggen bis es fertig ist. Ist alles fertig, entnimmt man den Chip und verbaut ihn in eine kleine kompakte Schaltung, die nur das nötigste enthält. Wir programmieren erst einmal etwas ganz einfaches, nämlich eine Blickschaltung, um dann zu testen, ob unser ATmega328P später dann auch richtig funktioniert.

Als blinkende LED nehmen wir die interne des Uno, die an Pin D13 hängt. Bei unserer nackten Schaltung müssen wir dann natürlich eine eigene LED anschließen, damit wir etwas blinken sehen. #include <Arduino.h> #define PinLed 13 void setup() { pinMode(PinLed, OUTPUT); } void loop() { delay (500); digitalWrite(PinLed, !digitalRead(PinLed)); }

Nachdem der ATmega328P jetzt weiß, was er tun soll, nämlich blinken, setzen wir ihn aufs Breadboard und stellen ihm noch folgende Gesellen zur Seite: Wie der Quartz richtig anzuschließen ist, zeigt uns der Schaltplan, den wir im Datenblatt zum ATmega328P finden:



Empfohlen werden laut Datenblatt Kondensatoren mit 12...22 pF.

Die Versorgungsspannung muss laut Datenblatt zwischen 1.8 und 5.5 Volt liegen. Es gehen also zwei AA Batterien (3V), eine Knopfzelle mit 3V, ein Li-Ion Akku mit 3.6V, eine USB-Powerbank oder ein USB-Netzteil mit 5V. Ich habe mich erstmal für 5 Volt entschieden, weil das so die Standardspannung für die Arduino-Peripherie ist. Aber natürlich kann man auch 3.3V-Komponenten bei 3.3V Versorgungsspannung benutzen. Der ATmega ist da sehr flexibel. Es muss halt zum Schluss alles zusammenpassen.



Die aufgebaute Blink-Schaltung findet auf einem Mini-Breadboard Platz. Mein Labornetzteil zeigt an, dass die Schaltung zwischen 10 mA und 30 mA Strom bei 5 Volt zieht, je nachdem, ob die LED gerade an ist oder nicht. Das ist doch schön sparsam. Es sind ja auch keine stromfressenden Spannungswandler dazwischen.



Unten links kommt die Stromversorgung vom Labornetzteil: links plus, rechts minus. Minus oder Ground wird dann auf Pin 8, Pin 22 und die ganz rechte Spalte des Breadboards verteilt (blaue bzw. schwarze Kabel). Plus, also 5V gehen an Pin 7 und Pin 20 (rote Kabel). Zwischen GND und 5V kommt , natürlich richtig herum gepolt, der 10 µF Elko, der etwaige Stromanforderungsspitzen abfedern soll. Damit ist die Stromversorgung erledigt.

Als nächstes die Taktung: hier kommt der Quartz zwischen Pin 9 und Pin 10. Dann wird je ein 22 pF-Kerko zwischen Pin 9 / 10 und GND (auf dem Breadboard ganz rechts) gesetzt.

Damit der ATmega nicht in der Dauer-Reset-Schleife festhängt, wird der Pin 1 über einen 10 kOhm Widerstand auf High gezogen. Den Taster, der die Resetleitung temporär auf Ground zieht und dann einen Reset ausführt, habe ich mal weggelassen. Strom aus und wieder an tut es genauso.

Nur noch die Payload, die Blink-LED: die kommt mit Plus an D13, also Pin 19 und mit dem Minuspol über einen 220 Ohm Vorwiderstand an Ground.

Fertig ist die Schaltung. Noch einen kleinen Test zum Abschluss, um zu sehen, ob alles läuft.



Die LED blinkt im Sekundentakt. Unser ATmega328P tut also das, was er soll. Wunderbar.

Nun stehen uns die ganzen anderen GPIO-Ports direkt an den Pins des ATmega328P zur Verfügung und wir können genauso Schaltungen aufbauen wie mit einem Entwicklungsboard wie dem Arduino Uno.

Auf einer Lochrasterplatine und mit gekürzten Beinen würde das Ganze natürlich noch einmal ordentlicher und kompakter werden.

Ich habe allerdings erst einmal etwas anderes mit dieser Schaltung vor. Ich will meinem 8Bit-Breadboard-Computer mit 6502 CPU einen Coprozessor spendieren, um zum Beispiel Zufallszahlen zu generieren. Da ist die stromsparende, kompakte Atmega-stand-alone-Variante natürlich willkommen.