8051-microcontroller

Wat het is

De 8051 is geen bord en ook niet echt één chip; het is een architectuur. Intel publiceerde hem in 1980 en licentieerde de kern zo ruim dat het onderdeel dat je vandaag koopt van iemand anders komt. In een praktijkkit is dat vrijwel altijd de AT89S52 van Atmel: een 8051-kern met 8 KB flashgeheugen, 256 bytes RAM, drie timers en in-systeemprogrammering via vier pinnen.

Je krijgt een 40-pins DIP en verder niets. Geen USB, geen spanningsregelaar, geen bootloader, geen pinMode(). Voordat hij zelfs één instructie uitvoert, moet je een kristal, twee lastcondensatoren, een resetnetwerk en een verbinding van EA met +5 V toevoegen. Zonder die kristaloscillator werkt een eerste bord helemaal niet. Die kale opzet is de hele reden dat hij nog in het studieprogramma staat: er is geen laag tussen je code en de siliciumchip die gedrag kan verhullen dat je niet begrijpt.

Hoe het werkt

De 8051 is een Harvard-machine: programmageheugen en gegevensgeheugen hebben gescheiden adresruimtes en worden via verschillende instructies bereikt. Code staat in flashgeheugen; variabelen staan in 256 bytes intern RAM, dat zelf is verdeeld over vier registerbanken, een bit-adressable gebied en de resterende ruimte voor de stack.

Timing is opvallend eenvoudig te doorgronden. Eén machinecyclus is twaalf oscillatorperioden, en de meeste instructies duren één of twee cycli. Bij 11.0592 MHz is dat 1,085 µs per cyclus, zodat je instructies kunt tellen en weet, in plaats van schat, hoe lang een lus duurt. Weinig moderne onderdelen bieden dat.

De 32 I/O-pinnen zijn verdeeld over vier poorten met elk een eigen karakter:

• P1 is de enige rechttoe-recht-aan: acht algemene pinnen met interne pull-upweerstanden.
• P3 heeft voor elke pin ook een alternatieve functie: seriële RXD/TXD, twee externe interrupts, twee timeringangen en de externe lees- en schrijfimpulsen voor geheugen.
• P2 draagt het hoge adresbyte wanneer extern geheugen is aangesloten.
• P0 is open-drain. Zonder externe pull-upweerstanden kan deze poort helemaal geen logisch hoog uitsturen en draagt hij bovendien het gemultiplexte lage adres- en gegevensbyte.

Wat de chip niet heeft is minstens zo belangrijk: geen analoge ingangen en geen PWM-hardware. Een sensorspanning lezen vereist een externe ADC en de snelheid van een motor variëren betekent dat je zelf een golfvorm genereert vanuit een timerinterrupt.

Wanneer je hem gebruikt

Kies de 8051 als het doel is de machine te leren kennen: een cursus microcontrollers, een universitair miniproject of je eigen nieuwsgierigheid naar wat analogWrite() werkelijk doet. Een softwarematige PWM-generator leert meer in een middag dan een jaar lang een bibliotheek aanroepen die dit verbergt.

Kies vrijwel alles anders wanneer de robot het doel is. Een Arduino Uno biedt hardware-PWM, analoge ingangen en een bibliotheek voor elke sensor die je tegenkomt; een ESP32 voegt Wi-Fi en veel meer geheugen toe. Beide kosten ongeveer hetzelfde als een 8051-ontwikkelbord. De 8051 kiezen voor een project dat moet werken in plaats van onderwijzen betekent dat je dingen die alternatieven gratis geven met de hand opnieuw moet bouwen.

Veelvoorkomende valkuilen

• EA moet aan +5 V. Pin 31 kiest intern of extern programmageheugen. Als de pin zweeft of aan aarde ligt, haalt de chip stilzwijgend code op uit extern geheugen dat er niet is en doet hij niets: geen fout, geen lampje, geen aanwijzing. Dit is verreweg de meest voorkomende reden dat een eerste 8051-bord dood lijkt.
• Reset is actief HIGH. Anders dan bij vrijwel elke andere microcontroller die je tegenkomt, reset de 8051 wanneer RST omhoog wordt getrokken. Het standaardcircuit bij inschakelen bestaat uit een condensator van 10 µF tussen +5 V en RST en een weerstand van 10 kΩ tussen RST en aarde.
• Poort 0 heeft externe pull-upweerstanden nodig. De poort is open-drain. Sluit op elke pin een weerstand van 10 kΩ aan op +5 V, anders kan hij nooit betrouwbaar een hoog niveau lezen of uitsturen.
• Pinnen nemen stroom op, maar leveren hem niet. De interne pull-upweerstand levert slechts enkele microampère, terwijl de pull-downtransistor milliampère opneemt. Sluit een LED aan met de anode naar de voeding en de kathode naar de pin; een 0 schakelt de LED in. Andersom aansluiten geeft een zeer zwakke gloed en veel verwarring.
• De stack begint op 08h, boven registerbank 1. De stackpointer wordt teruggezet op 07h. Schakel je over naar registerbank 1 zonder eerst SP te verplaatsen, dan delen je registers en je retouradressen dezelfde bytes.

Waarom 11.0592 MHz van alle getallen

Die kristalfrequentie lijkt willekeurig en is juist een van de meest doelbewuste keuzes in de hele architectuur.

De 8051 bepaalt zijn seriële baudrate door Timer 1 in de 8-bits automatische herlaadmodus te laten overlopen:

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

Met SMOD = 0, een kristal van 11.0592 MHz en 9600 baud als doel:

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

Precies 3. Geen afronding, geen fout. Elke standaardbaudrate — 1200, 2400, 4800, 9600, 19200 — levert een geheel aantal timerherladingen op.

Neem nu een rond kristal van 12 MHz:

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

Seriële verbindingen verdragen ongeveer 2–3% totale fout tussen beide uiteinden. Bij 8,5% loopt de framing binnen één byte uiteen en komt elk teken beschadigd aan. Dit is de reden dat 11.0592 MHz bestaat, waarom het op elk 8051-practicumbord zit en waarom het vervangen van het 12-MHz-kristal in de lade een chip oplevert die perfect werkt totdat je iets probeert af te drukken.

De afweging is dat de timingberekening omslachtig wordt: een machinecyclus duurt 1,085 µs in plaats van een ronde 1 µs. Een kristal van 12 MHz levert exact cycli van 1 µs en onbruikbare seriële communicatie. Kies op basis van wat je project nodig heeft.

Timers en zelf PWM genereren

De 8051 heeft drie 16-bits timers en helemaal geen PWM-hardware. De snelheid van een motor variëren betekent dat je de golfvorm zelf genereert, en juist dat is het beste aspect van leren werken met deze chip.

De timers hebben vier modi; twee zijn belangrijk:

Gebruik modus 2 voor een stabiele tick, want dan gebeurt het herladen in de hardware en komt er geen ISR-jitter in de periode terecht.

Een softwarematige PWM-generator op Timer 0, rond 1 kHz met een resolutie van 100 stappen:

#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 */
}

Twee lessen uit dit voorbeeld. Herlaad altijd eerst: in modus 1 gaat de timer na een overloop verder tellen vanaf nul, dus elke instructie vóór de herlading telt mee in de volgende periode. En de kosten zijn reëel: deze ISR wordt 100.000 keer per seconde uitgevoerd. Bij 1,085 µs per machinecyclus verbruikt een afhandeling van een dozijn instructies een aanzienlijk deel van alles wat de chip kan. Dat budget koop je precies met een hardware-PWM-periferie, en je waardeert het pas wanneer je het zelf hebt betaald.

Het stroombudget van de poorten

Dit overvalt mensen doordat de poorten van de 8051 asymmetrisch zijn op een manier die moderne onderdelen niet hebben.

Zestig microampère is geen typefout. De interne pull-upweerstand is een zwakke weerstand, geen stroomdriver. Een pin die HIGH uitstuurt kan dus ongeveer een duizendste leveren van wat hij kan opnemen.

Daaruit volgen drie directe gevolgen:

Sluit de kathode van een LED aan de pin en de anode via een weerstand op +5 V; schrijf 0 om de LED te laten branden. Andersom aangesloten licht hij heel zwak op, wat eerder lijkt op een dimme of defecte LED dan op een verkeerd inzicht.

Bestuur nooit rechtstreeks iets. Niet een relais, niet een zoemer op hoog volume, niet een motor. Gebruik een transistor, een ULN2003-drivermatrix of een echte motordriver.

Poort 0 heeft externe pull-upweerstanden nodig: 10 kΩ naar +5 V op elke pin die je als I/O wilt gebruiken. Zonder die weerstanden kan de poort geen hoog niveau uitsturen of betrouwbaar lezen, en op veel practicumborden loopt juist deze poort naar de LCD.

Geheugen en bestemming van de 256 bytes

Acht kilobytes flashgeheugen klinkt krap en is zelden het knelpunt. 256 bytes RAM is de werkelijke beperking, en dat is geen vlak blok van 256 bytes:

De stackpointer wordt teruggezet op 07h, waardoor de stack direct boven registerbank 1 begint. Schakel je over naar registerbank 1 zonder eerst SP te verplaatsen, dan delen je registers en je retouradressen bytes. De storing is dan spectaculair: het programma springt naar een willekeurig adres. SP = 0x30; als eerste regel van main() is gangbare praktijk.

Het bit-adressable gebied is de moeite waard om te kennen, want het is werkelijk elegant. Elk bit in 20h–2Fh kan met één instructie worden ingesteld, gewist of getest, waardoor statusvlaggen gratis worden:

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

Acht daarvan kosten één byte en één bit testen kost één machinecyclus. Op een chip met 256 bytes RAM is dat belangrijk.

Problemen oplossen

8051 of een moderne microcontroller?

De eerlijke conclusie: de 8051 is een onderdeel voor onderwijs, en een uitstekend onderdeel. Een softwarematige PWM-generator schrijven, een baudherlading met de hand berekenen en ontdekken dat een poortpin geen stroom kan leveren, laat zien welke taken elke moderne periferie voor je overneemt. Dat begrip blijft behouden, en daarom staat deze architectuur vijfenveertig jaar na de publicatie van Intel nog in studieprogramma’s.

Kies voor een robot die moet werken vrijwel alles anders. Een 8051-lijnvolger bouwen betekent PWM schrijven, een externe ADC toevoegen of sensoren met comparatoruitgangen gebruiken en elke timingconstante met de hand berekenen. Een Uno biedt dat allemaal voor dezelfde prijs. Doe het wanneer het doel is de machine te begrijpen; kies een Uno wanneer de robot het doel is.