Minimalbeschaltung eines Mikrocontrollers

Ein Arduino Uno ist für ein fertiges Gerät oft zu groß und zu stromhungrig. Der eigentliche Rechner darauf, der ATmega328P, läuft mit einer Handvoll Bauteile auch allein: auf dem Steckbrett oder auf deiner eigenen Platine. Diese Handvoll heißt Minimalbeschaltung. Sie besteht bei fast jedem Mikrocontroller aus denselben vier Teilen: Versorgung mit Abblockkondensatoren, Reset, Takt und einem Weg, das Programm aufzuspielen.

Hier baust du die Minimalbeschaltung für einen ATmega328P mit 16 MHz an 5 V auf, also einen „Arduino auf dem Steckbrett“, der dieselben Sketche ausführt wie der Uno. Danach folgt dasselbe für ein ESP32-Modul an 3,3 V.

Schaltplan

• IC1, ATmega328P-PU: der Controller im DIP-28-Gehäuse, steckbrettfreundlich. Er hat zwei Versorgungspaare: VCC/GND (Pin 7/8) für den Digitalteil und AVCC/GND (Pin 20/22) für den AD-Wandler und Port C.
• C3, C4, 100 nF: je ein Keramikkondensator direkt an jedem Versorgungspaar. Sie liefern die kurzen Stromspitzen beim Schalten.
• C5, 100 nF: stabilisiert die Referenzspannung des AD-Wandlers an AREF.
• R1, 10 kΩ: hält RESET im Betrieb sicher auf High.
• D1, 1N4148: eine Diode von RESET nach +5 V, Kathode an +5 V. Sie kappt Spannungsspitzen über die Versorgung hinaus.
• S1: Taster für den Neustart.
• Q1, 16 MHz, mit C1, C2 (22 pF): der Schwingquarz gibt den Takt vor, die beiden Kondensatoren sind seine Lastkapazität.
• R2, LED1: eine Test-LED an PB5. Der Pin heißt in der Arduino-Welt D13, genau wie die eingebaute LED des Uno.
• RXD, TXD (Pin 2/3): Anschluss für einen USB-Seriell-Wandler, über den der Bootloader das Programm empfängt.

So funktioniert die Schaltung

Versorgung und Abblockung. Bei jedem Takt zieht der Controller Stromspitzen von einigen zehn Milliampere, die nur Nanosekunden dauern. Die Induktivität der Zuleitung lässt sie nicht schnell genug nachfließen; der Kondensator direkt am Pin springt ein (Abblockkondensator). Wichtig: Beide Versorgungspaare brauchen ihren eigenen Kondensator, und AVCC muss angeschlossen sein, auch wenn du den AD-Wandler nie benutzt. Port C wird aus AVCC versorgt.

Reset. Solange RESET auf Low liegt, steht der Controller still. Lässt du den Pin los, startet das Programm von vorn. Im Chip steckt zwar ein Pull-up von 30 bis 60 kΩ, doch der ist schwach und fängt Störungen auf langen Leitungen schlecht ab. R1 mit 10 kΩ ist stärker und erlaubt trotzdem noch die Fehlersuche über debugWIRE, die einen Pull-up von mindestens 10 kΩ verlangt. Beim Einschalten selbst brauchst du kein RC-Glied: Der Power-on-Reset im Chip hält den Controller fest, bis die Spannung steht. Wann ein externes Reset-Glied doch sinnvoll ist, erklärt Power-on-Reset.

Takt. Ab Werk läuft der ATmega328P mit seinem internen RC-Oszillator: 8 MHz, durch eine Teiler-Fuse geteilt durch 8, also 1 MHz. Den Quarz nutzt er erst, wenn die Fuses umgestellt sind. Mit dem Inverter im Chip und den Lastkondensatoren bildet er einen Pierce-Oszillator.

Programmieren. Einen frischen Chip versiehst du einmal über die ISP-Schnittstelle (Pin 17, 18, 19 und RESET) mit dem Bootloader, etwa mit einem zweiten Arduino als Programmer und Bootloader brennen. Das setzt auch die Fuses für den Quarz. Danach lädst du wie beim Uno über RXD und TXD hoch.

Dimensionierung

1. Versorgung. Laut Datenblatt verlangt der ATmega328P für 16 MHz mindestens 3,78 V; erlaubt sind 1,8 bis 5,5 V, aber die höchste Taktrate wächst mit der Spannung. Bei 5 V und 16 MHz braucht er etwa 10 mA, dazu kommen die Ströme der Ausgänge. Ein USB-Anschluss oder ein Festspannungsregler 78xx reicht. An 3,3 V nimmst du einen 8-MHz-Quarz.

2. Abblockkondensator. Angenommen, der Chip zieht für 10 ns eine Spitze von 50 mA. Die Ladung dafür und der Spannungseinbruch am 100-nF-Kondensator:

5 mV sind harmlos. Entscheidend ist der Abstand: Jeder Zentimeter Leitung zwischen Kondensator und Pin bringt rund 10 nH Induktivität, und an 10 nH erzeugt ein Anstieg von 50 mA in 5 ns schon L · ΔI / Δt = 10 nH · 50 mA / 5 ns = 100 mV. Deshalb sitzt C3 so nah wie möglich zwischen Pin 7 und 8, C4 zwischen Pin 20 und 22.

3. Lastkondensatoren des Quarzes. Ein 16-MHz-Quarz im HC-49-Gehäuse ist typisch für eine Lastkapazität C_L = 18 pF spezifiziert. Aus Sicht des Quarzes liegen C1 und C2 in Reihe (Reihenschaltung von Kondensatoren), dazu kommt die Streukapazität von Pins und Leitungen, auf dem Steckbrett etwa 5 pF:

Der nächste Wert der E-Reihe ist 27 pF. Die verbreiteten 22 pF ergeben C_L = 11 pF + 5 pF = 16 pF. Der Quarz schwingt dann um einige zehn ppm zu schnell, das sind bei 16 MHz einige hundert Hertz. Für die serielle Schnittstelle, die bis zu 2 % Abweichung verträgt, spielt das keine Rolle; für eine genaue Uhr nimmst du den passenden Wert.

4. Reset. Drückst du S1, fließen 5 V / 10 kΩ = 0,5 mA durch R1 – vernachlässigbar. D1 hält RESET auf höchstens 5 V + 0,7 V. Ohne sie könnte eine Spitze, etwa über den Kondensator der Auto-Reset-Leitung, den Pin weit über die Versorgung treiben. Ab etwa 11,5 V schaltet der Pin in den Hochvolt-Programmiermodus.

5. Test-LED. Mit einer roten LED (U_F ≈ 2,0 V) an 5 V:

Das liegt weit unter den 40 mA, die ein Pin höchstens verträgt, und reicht für eine gut sichtbare Anzeige. Mehr dazu unter LED am Mikrocontroller-Pin.

Der erste Sketch prüft gleich den Takt. Blinkt die LED 16-mal zu langsam, sind die Fuses noch auf den internen 1-MHz-Takt gestellt:

const int LED = 13;              // PB5, Pin 19 am DIP-28

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(115200);          // TXD an Pin 3
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
  delay(500);
  Serial.println(millis());      // sollte um rund 1000 pro Zeile steigen
}

Bauteilliste

Varianten

Auto-Reset beim Hochladen. Verbinde den DTR-Ausgang des USB-Seriell-Wandlers über einen 100-nF-Kondensator mit RESET. Die fallende Flanke von DTR zieht RESET kurz auf Low, R1 lädt den Kondensator danach wieder auf. So startet der Bootloader genau dann, wenn die Arduino-IDE das Programm schickt. Wie RX und TX gekreuzt werden, steht unter UART, USB-Seriell und RS-232.

Ohne Quarz. Der interne 8-MHz-Oszillator (ab Werk ±10 %) spart Q1, C1, C2 und zwei Pins, reicht aber nicht immer für eine zuverlässige serielle Verbindung. Ein Keramikresonator mit eingebauten Kondensatoren schafft ±0,5 %.

ESP32-Modul. Ein ESP32-WROOM-32E bringt Quarz, Flash und Antenne schon mit. Außen bleiben nur Versorgung, das Freigabesignal EN und der Boot-Taster:

Das Modul läuft nur an 3,3 V; 5 V an einem Pin beschädigen es. Beim Senden über WLAN zieht es Spitzen bis etwa 500 mA, die der Regler liefern muss. Und EN braucht ein RC-Glied: Mit 10 kΩ und 1 µF erreicht EN die Schaltschwelle von 0,75 · 3,3 V erst nach τ · ln 4 = 10 ms · 1,39 ≈ 14 ms. Bis dahin steht die Versorgung. Fehlt C3, startet das Modul bei langsam steigender Spannung oft gar nicht. IO0 ist ein Strapping-Pin: Ist er beim Start low, wartet der ESP32 auf neue Firmware.

Typische Fehler

• AVCC offen gelassen: Port C und der AD-Wandler arbeiten dann nicht oder unzuverlässig. AVCC gehört immer an die Versorgung.
• Abblockkondensatoren fehlen oder sitzen weit weg: Der Controller stürzt sporadisch ab, etwa sobald ein Relais schaltet. Steck sie direkt über den Chip.
• Sketch läuft 16-mal zu langsam: Der Chip läuft noch mit 1 MHz; Bootloader brennen setzt die Fuses richtig. Schwingt der Quarz gar nicht, sind oft die Steckbrettleitungen zu lang.
• Hochladen schlägt fehl: RX und TX nicht gekreuzt, DTR-Kondensator fehlt, oder der Wandler steht auf 3,3 V statt 5 V.
• ESP32 startet ständig neu: Die Versorgung bricht beim Senden ein. Größeren Elko vors Modul, kräftigeren Regler nehmen und die Leitung zur Versorgung kurz halten.

Selbsttest