8051 Microcontroller

Was es ist

Der 8051 ist kein Board und nicht wirklich ein einzelner Chip – er ist eine Architektur. Intel veröffentlichte sie 1980 und lizenzierte den Kern dann so breit, dass das Bauteil, das du heute kaufst, von jemand anderem kommt. Im Laborkoffer ist das fast immer Atmels AT89S52: ein 8051-Kern mit 8 KB Flash, 256 Byte RAM, drei Timern und In-System-Programmierung über vier Pins.

Was ankommt, ist ein 40-Pin-DIP und sonst nichts. Kein USB, kein Regler, kein Bootloader, kein pinMode(). Bevor er eine einzige Instruktion ausführt, musst du ihm einen Quarz, zwei Lastkondensatoren, ein Reset-Netzwerk und eine Verbindung von EA nach +5 V geben. Diese Nacktheit ist der ganze Grund, warum er noch auf dem Lehrplan steht: Es gibt keine Schicht zwischen deinem Code und dem Silizium, die Verhalten wegerklärt, das du nicht verstehst.

Wie es funktioniert

Der 8051 ist eine Harvard-Maschine: Programm- und Datenspeicher sind getrennte Adressräume, erreicht über verschiedene Instruktionen. Code lebt im Flash; Variablen leben in 256 Byte internem RAM, das selbst in vier Registerbänke, ein bitadressierbares Fenster und den Rest für deinen Stack geteilt ist.

Timing ist ungewöhnlich leicht nachzuvollziehen. Ein Maschinenzyklus sind zwölf Oszillatorperioden, und die meisten Instruktionen brauchen einen oder zwei davon. Bei 11,0592 MHz sind das 1,085 µs pro Zyklus, also kannst du Instruktionen zählen und wissen – nicht schätzen –, wie lange eine Schleife dauert. Sehr wenige moderne Bauteile lassen dich das tun.

Die 32 I/O-Pins sind in vier Ports mit eigenem Charakter gruppiert:

• P1 ist der einzige unkomplizierte – acht Allzweck-Pins mit internen Pull-ups.
• P3 doppelt jeden Pin mit einer Alternativfunktion: seriell RXD/TXD, die zwei externen Interrupts, die zwei Timereingänge sowie die Lese- und Schreibstrobes für externen Speicher.
• P2 trägt das hohe Adressbyte, wenn externer Speicher angeschlossen ist.
• P0 ist Open-Drain. Ohne externe Pull-up-Widerstände kann er gar kein logisches High ausgeben, und er trägt auch das gemultiplexte niedrige Adress- und Datenbyte.

Was der Chip nicht hat, zählt ebenso: keine Analogeingänge und keine PWM-Hardware. Für eine Sensorspannung braucht es einen externen ADC, und für variable Motordrehzahl musst du die Wellenform selbst per Timer-Interrupt erzeugen.

Wann man ihn verwendet

Greife zum 8051, wenn der Punkt das Lernen der Maschine ist – ein Mikrocontroller-Kurs, ein Uni-Miniprojekt oder deine eigene Neugier, was analogWrite() wirklich tut. Einen Software-PWM-Generator zu schreiben lehrt an einem Nachmittag mehr als ein Jahr Aufrufe einer Bibliothek, die ihn versteckt.

Wähle fast alles andere, wenn der Punkt der Roboter ist. Ein Arduino Uno gibt dir Hardware-PWM, Analogeingänge und eine Bibliothek für jeden Sensor, dem du begegnest; ein ESP32 fügt WLAN und weit mehr Speicher hinzu. Beide kosten etwa so viel wie ein 8051-Entwicklungsboard. Den 8051 für ein Projekt zu wählen, das funktionieren statt lehren muss, heißt, Dinge von Hand nachzubauen, die dir die Alternativen gratis geben.

Typische Fallstricke

• EA muss auf +5 V. Pin 31 wählt internen oder externen Programmspeicher. Offen oder auf Masse holt der Chip lautlos aus externem Speicher, der nicht da ist, und tut gar nichts – kein Fehler, kein Licht, kein Hinweis. Das ist der häufigste Grund, warum ein erstes 8051-Board tot wirkt.
• Reset ist High-aktiv. Anders als fast jeder andere Mikrocontroller, dem du begegnest, startet der 8051 neu, wenn RST hoch gezogen wird. Die Standard-Einschalt­schaltung ist ein 10-µF-Kondensator von +5 V nach RST und ein 10-kΩ-Widerstand von RST nach Masse.
• Port 0 braucht externe Pull-ups. Er ist Open-Drain. Verdrahte 10-kΩ-Widerstände nach +5 V, sonst treibt oder liest er nie ein High.
• Pins ziehen nach Masse, sie treiben nicht nach oben. Der interne Pull-up liefert nur Dutzende Mikroampere, während der Pull-down-Transistor Milliampere versenkt. LEDs kommen mit Anode an Versorgung, Kathode an Pin, und eine 0 schaltet sie ein. Andersherum verdrahtet gibt es ein sehr schwaches Glimmen und viel Verwirrung.
• Der Stack startet bei 08h, auf Registerbank 1. Der Stackpointer startet bei 07h. Wenn du auf Bank 1 umschaltest, ohne SP vorher zu verschieben, belegen deine Register und Rücksprungadressen dieselben Bytes.

Warum 11,0592 MHz, ausgerechnet

Diese Quarzfrequenz sieht willkürlich aus und ist eine der bewusstesten Entscheidungen der ganzen Architektur.

Der 8051 erzeugt seine serielle Baudrate, indem Timer 1 im 8-Bit-Auto-Reload-Modus überläuft:

baud = (2^SMOD / 32) x (oscillator / 12) / (256 - TH1)

Mit SMOD = 0 und 11,0592-MHz-Quarz, Ziel 9600 Baud:

TH1 = 256 - (11059200 / (12 x 32 x 9600)) = 256 - 3 = 253 = 0xFD

Genau 3. Kein Runden, kein Fehler. Jede Standard-Baudrate – 1200, 2400, 4800, 9600, 19200 – geht als ganze Zahl von Timer-Reloads auf.

Nun ein runder 12-MHz-Quarz:

TH1 = 256 - (12000000 / 3686400) = 256 - 3.26 -> must round to 3
actual baud = 10417, against a target of 9600 -> 8.5% error

Serielle Verbindungen vertragen etwa 2–3 % Gesamtfehler zwischen beiden Enden. Bei 8,5 % driftet das Framing innerhalb eines Bytes und jedes Zeichen kommt zerstört an. Deshalb existiert 11,0592 MHz, deshalb ist es auf jedem 8051-Laborboard, und deshalb produziert der 12-MHz-Quarz aus der Schublade einen Chip, der perfekt funktioniert, bis du etwas ausgeben willst.

Der Preis ist unbequeme Timing-Arithmetik: Ein Maschinenzyklus sind 1,085 µs statt runder 1 µs. Ein 12-MHz-Quarz gibt exakt 1-µs-Zyklen und unbrauchbares Seriell. Wähle danach, welches dein Projekt braucht.

Timer, und PWM von Hand erzeugen

Der 8051 hat drei 16-Bit-Timer und gar keine PWM-Hardware. Motordrehzahl zu variieren heißt, die Wellenform selbst zu erzeugen, und das zu tun ist wirklich das Beste am Lernen auf diesem Chip.

Die Timer haben vier Modi; zwei zählen:

Modus 2 ist der Griff für einen ruhigen Takt, weil das Nachladen in Hardware passiert und kein ISR-Jitter in die Periode kriecht.

Ein Software-PWM-Generator auf Timer 0, bei grob 1 kHz mit 100 Stufen Auflösung:

#include <reg52.h>

sbit MOTOR_L = P1^0;
sbit MOTOR_R = P1^1;

volatile unsigned char dutyL = 0, dutyR = 0;   // 0..99
volatile unsigned char tick  = 0;

void timer0_isr(void) interrupt 1 {
    /* Mode 1 is not self-reloading: put the value back first, before
       anything else, or the period stretches by the ISR's own length. */
    TH0 = 0xFF; TL0 = 0xA4;                    /* ~10 us at 11.0592 MHz */

    if (++tick >= 100) tick = 0;               /* 100 ticks = ~1 ms period */

    MOTOR_L = (tick < dutyL) ? 1 : 0;
    MOTOR_R = (tick < dutyR) ? 1 : 0;
}

void main(void) {
    TMOD = (TMOD & 0xF0) | 0x01;               /* Timer 0, mode 1 */
    TH0  = 0xFF; TL0 = 0xA4;
    ET0  = 1;                                  /* enable timer 0 interrupt */
    EA   = 1;                                  /* global interrupt enable */
    TR0  = 1;                                  /* start */

    dutyL = 70; dutyR = 70;
    while (1) { }                              /* PWM runs entirely in the ISR */
}

Zwei Dinge sind daraus mitzunehmen. Immer zuerst nachladen – in Modus 1 zählt der Timer nach Überlauf von null weiter, also verlängert jede Instruktion vor dem Nachladen die nächste Periode. Und die Kosten sind real: Diese ISR feuert 100.000-mal pro Sekunde, und bei 1,085 µs pro Maschinenzyklus frisst ein Handler mit einem Dutzend Instruktionen einen spürbaren Anteil all dessen, was der Chip kann. Genau dieses Budget kauft dir eine Hardware-PWM-Peripherie, und du schätzt sie erst, wenn du sie von Hand bezahlt hast.

Das Port-Strombudget

Das erwischt Leute, weil die Ports des 8051 asymmetrisch sind, wie moderne Bauteile es nicht sind.

Sechzig Mikroampere sind kein Tippfehler. Der interne Pull-up ist ein schwacher Widerstand, kein Treiber, also liefert ein Pin mit HIGH-Ausgang grob ein Tausendstel dessen, was er versenken kann.

Drei Folgen direkt daraus:

LEDs kommen mit Kathode an den Pin, Anode über Widerstand an +5 V, und Schreiben von 0 leuchtet sie. Andersherum leuchten sie sehr schwach, was sich wie eine dunkle oder defekte LED statt wie ein Missverständnis liest.

Treibe niemals etwas direkt. Kein Relais, keinen Buzzer auf Lautstärke, keinen Motor. Nutze einen Transistor, ein ULN2003-Treiberarray oder einen echten Motortreiber.

Port 0 braucht externe Pull-ups – 10 kΩ nach +5 V an jedem Pin, den du als I/O nutzen willst. Ohne sie kann er kein High ausgeben oder verlässlich lesen, und es ist der Port, den die meisten Laborboards zum LCD routen.

Speicher, und wohin die 256 Byte gehen

Acht Kilobyte Flash klingen knapp und sind es selten. 256 Byte RAM sind die echte Grenze, und es sind keine flachen 256 Byte:

Der Stackpointer startet bei 07h, was den Stack direkt auf Registerbank 1 legt. Wenn du auf Bank 1 umschaltest, ohne SP vorher zu verschieben, teilen sich deine Register und Rücksprungadressen Bytes, und der Fehler ist spektakulär: Das Programm kehrt an eine zufällige Adresse zurück. SP = 0x30; als erste Zeile von main() ist Standardpraxis.

Die bitadressierbare Region lohnt sich zu kennen, weil sie wirklich elegant ist. Jedes Bit in 20h–2Fh lässt sich in einer einzigen Instruktion setzen, löschen oder testen, was Zustandsflags gratis macht:

bit lineDetected;      /* the compiler allocates this in 20h-2Fh */
bit motorEnabled;      /* one bit each, one instruction to test */

Acht davon kosten ein Byte, und eines zu testen ist ein Maschinenzyklus. Auf einem Chip mit 256 Byte RAM zählt das.

Fehlerbehebung

8051 oder ein moderner Mikrocontroller?

Die ehrliche Position: Der 8051 ist ein Lehrbauteil, und ein exzellentes. Einen Software-PWM-Generator zu schreiben, einen Baud-Reload von Hand zu rechnen und zu entdecken, dass ein Port-Pin keinen Strom liefern kann, lehrt dich, was jede moderne Peripherie wirklich für dich tut. Dieses Verständnis bleibt dauerhaft, und deshalb steht die Architektur fünfundvierzig Jahre nach Intels Veröffentlichung noch auf Lehrplänen.

Für einen Roboter, der arbeiten muss, wähle fast alles andere. Einen 8051-Linienfolger zu bauen heißt, das PWM zu schreiben, einen externen ADC zu ergänzen oder Sensoren mit Komparatorausgang zu nutzen und jede Timing-Konstante von Hand zu rechnen – was ein Uno für dasselbe Geld liefert. Tu es, wenn der Punkt die Maschine verstehen ist. Greife zum Uno, wenn der Punkt der Roboter ist.