Bouw een lijnvolgerrobot met een 8051-microcontroller
Een werkende lijnvolger op een kale 8051 — en een helder begrip van elke laag die een Arduino anders zou verhullen, van het resetcircuit tot de PWM-golfvorm.
Vrijwel elke engineeringopleiding die microcontrollers behandelt, eindigt met dezelfde opdracht: bouw een lijnvolger op een 8051. Er is een goede opdracht om een reden die meestal niet wordt uitgesproken — de chip geeft je niets. Geen analogWrite() om een motorsnelheid in te stellen, geen analogRead() voor de sensoren en geen bibliotheek voor het driverbord. Elke laag die je normaal gesproken zou aanroepen, bouw je zelf.
Dat is het verschil tussen dit bouwpad en de Arduino-lijnvolger. De robot is dezelfde; de diepgang niet. Je schrijft zelf de generator voor pulsbreedtemodulatie (PWM) die in een Arduino in silicium zit, leert waarom een 8051-pin een LED alleen laat oplichten als je die omgekeerd aansluit, en ontdekt — voordat je iets koopt — precies hoeveel CPU je motorbesturing je kost.
De 8051 is een 8-bits Harvard-architectuurmicrocontroller in een 40-pins pakket, meestal een AT89S52 met 8 KB flash en 256 bytes RAM. Hij heeft geen PWM-hardware, zijn poorten zijn quasi-bidirectioneel (je moet een 1 schrijven voordat je een invoer leest) en zijn pinnen kunnen meer stroom opnemen dan ze leveren — dus de LED komt aan de sinkzijde en de H-brug van de motordriver (high-bridge) heeft pull-ups nodig om betrouwbaar te worden aangestuurd. Die details lijken voetnoten totdat de robot helemaal niets doet omdat EA zweeft of het resetcircuit actief hoog is en je het laag hebt aangesloten.
Je begint op een breadboard met alleen de chip, een kristal van 11,0592 MHz en twee belastingscondensatoren, een resetnetwerk en EA op hoog — het minimale circuit dat daadwerkelijk code uitvoert. De eerste drie tutorials voeren je door de architectuur en geheugenkaart, de algemene in-/uitvoer (GPIO) en poortinterfacing en daarna het bouwen van PWM met Timer 0 in 8-bits auto-reloadmodus: ongeveer 460,8 Hz met stappen van 5%, voor ongeveer een kwart van de CPU, een afweging die je maakt omdat er geen PWM-hardware is.
Vanaf daar loopt het pad samen met dat van de Arduino-lijnvolger: dezelfde IR-array (infrarood) wordt samengevouwen tot een gewogen fout, dezelfde PID-regeling (proportionele, integrerende en differentiërende regeling) en dezelfde browsersimulator waarin je versterkingen vindt die de bochten netjes nemen. De techniekstructuur houdt hardware- en conceptknooppunten gescheiden, zodat de eerste helft niets nodig heeft behalve de chip en een ISP-programmeur (in-system programming), zoals een USBasp, en alleen de laatste twee bouwknooppunten het chassis, de motors en de array nodig hebben.
Werk de techniekstructuur hieronder in volgorde door. De eerste drie knooppunten hebben alleen de chip op een breadboard nodig, de versterkingen voor de lijnvolger stel je af in de browsersimulator en alleen de laatste twee stappen vereisen het chassis en de motors. Je voortgang wordt op dit apparaat opgeslagen.
Stuklijst
| Onderdeel | Aantal | Geschatte kosten | Opmerkingen |
|---|---|---|---|
| AT89S52 40-pins DIP | 1 | $2 | In-system programmeerbaar. Een AT89C51 vereist een parallelle programmeur die je niet hebt |
| USBasp ISP-programmeur | 1 | $3 | De AT89S52 wordt via SPI geprogrammeerd — zo is dit praktisch haalbaar |
| Kristal van 11,0592 MHz | 1 | $0.50 | Niet 12 MHz. Zie hieronder — dit is geen voorkeur |
| Keramische condensatoren van 33 pF | 2 | $0.20 | Belastingscondensatoren voor het kristal |
| 10 µF elektrolytische condensator + 10 kΩ-weerstand | 1 van elk | $0.20 | Het resetnetwerk. Reset is hier actief HIGH |
| 10 kΩ-weerstandenmatrix | 1 | $0.50 | Pull-ups voor poort 0 — de poort is open drain en kan zonder deze niet hoog sturen |
| 40-pins ZIF- of DIP-socket | 1 | $1 | Soldeer de chip nooit rechtstreeks; je zult hem verwijderen |
| IR-reflectiearray | 1 | $5–10 | Digitale uitvoer, of voeg een externe ADC toe — de 8051 heeft geen analoge invoer |
| L298N | 1 | $3 | |
| TT-tandwielmotor | 2 | $4 | |
| 2WD-chassis | 1 | $6–10 | |
| Accupakket | 1 | $6 | |
| Breadboard en jumperdraden | — | $5 | De eerste drie mijlpalen gebeuren volledig hier |
Totaal: ongeveer $35–50.
Twee aankopen bepalen of dit project prettig of frustrerend wordt.
Het kristal moet 11,0592 MHz zijn. De 8051 bepaalt zijn seriële baudrate door Timer 1 te laten overstromen, en bij 11,0592 MHz komt elke standaardbaudrate uit op een geheel getal als herlaadwaarde — 9600 baud is exact TH1 = 0xFD. Een kristal van 12 MHz levert 10.417 baud tegen een doel van 9600, een fout van 8,5%, ver voorbij de ~3% die een UART verdraagt. Elk teken wordt daardoor foutief ontvangen. De chip werkt prima totdat je iets probeert af te drukken voor foutzoeken, het slechtst mogelijke moment om dat te ontdekken.
De sensorarray moet digitale uitgangen hebben, of je moet een externe ADC toevoegen zoals een ADS7828 of ADC0808. De 8051 heeft helemaal geen analoge invoer. Dit is het eerste wat de chip wegneemt, maar een Arduino biedt het gratis, en het is de moeite waard er bewust voor te kiezen: comparatoruitgangen zijn eenvoudiger, maar kosten je het gladde proportionele foutsignaal waarmee PID goed kan worden afgesteld.
Het minimale circuit
Zorg ervoor dat de kale chip code uitvoert op een breadboard voordat je een sensor of motor aansluit. Zes verbindingen:
| Pin | Verbinden met | Waarom |
|---|---|---|
40 (VCC) |
+5 V | |
20 (GND) |
Aarde | |
31 (EA) |
+5 V | Selecteert het interne programmageheugen. Bij een zwevende of geaarde pin haalt de chip zijn code uit extern geheugen dat er niet is en doet hij helemaal niets |
18, 19 (XTAL2, XTAL1) |
Over het kristal | Met een condensator van 33 pF van elke poot naar aarde |
9 (RST) |
10 µF naar +5 V, 10 kΩ naar aarde | Reset is hier actief HIGH — anders dan bij vrijwel elke andere microcontroller |
Een zwevende EA is de meest voorkomende reden dat een eerste 8051-bord dood lijkt, en dit veroorzaakt geen fout, geen licht en geen aanwijzing. Controleer dit elke keer eerst.
Een LED op P1.0 is de “hello world”: sluit de kathode aan de pin, de anode via een 330 Ω-weerstand op +5 V en schrijf 0 om hem te laten oplichten. De pin neemt ongeveer 10 mA op en levert ongeveer 60 microampère; andersom aangesloten gloeit de LED zwak en lijkt het op een fout.
Bouw hem stap voor stap
De eerste drie hebben alleen de chip op een breadboard nodig. Je kunt dus ver met dit project zijn voordat je een chassis koopt.
| # | Mijlpaal | De test | Geslaagd ziet er zo uit |
|---|---|---|---|
| 1 | Chip werkt | Laat een LED op P1.0 knipperen | Hij knippert. Zo niet, controleer dan EA vóór al het andere |
| 2 | Timing geverifieerd | Knipper precies op 1 Hz met een getelde vertraging | Een stopwatch over 60 knipperingen wijkt minder dan een seconde af |
| 3 | Seriële communicatie werkt | Druk een teller af op 9600 baud | Schone tekst — onleesbare uitvoer betekent het verkeerde kristal |
| 4 | GPIO-invoer | Lees een knop op P1.1 met de pull-up | De invoer wordt betrouwbaar gelezen. Schrijf 1 voordat je leest |
| 5 | Timerinterrupt | Schakel een pin om vanuit een Timer 0 ISR, controleer met een oscilloscoop of meet de tijd | De periode is de berekende waarde en is stabiel |
| 6 | Software-PWM | Bestuur een LED met een duty van 0%, 25%, 50%, 100% | De helderheid verschilt zichtbaar en er is geen flikkering |
| 7 | PWM-kosten gemeten | Schakel een extra pin om in de hoofdlus en meet de tijd | Je kunt aangeven welk deel van de CPU de ISR verbruikt |
| 8 | Motoren bestuurd | Laat beide wielen vooruit en achteruit draaien met de opgegeven duty | Beide richtingen en snelheden werken op blokken |
| 9 | Sensoren gelezen | Druk alle kanalen af over de lijn en over de vloer | Elk kanaal onderscheidt de twee |
| 10 | Foutsignaal | Beweeg de robot met de hand over de lijn | Een monotone gewogen positie zonder sprongen |
| 11 | Volgen | Rijd op een ovalen baan van tape | Voltooide rondjes |
Mijlpaal 7 is de reden waarom dit project bestaat. De analogWrite van een Arduino kost niets — de PWM wordt in silicium gegenereerd. Hier heb je hem gebouwd met een timerinterrupt, en hij vuurt tienduizenden keren per seconde. Meten welk deel van de CPU dat verbruikt is de les: doorgaans is dat een kwart van de chip, en dat is precies wat PWM-hardware je oplevert.
Hoe een goed resultaat eruitziet
| Meting | Typisch voor deze bouw |
|---|---|
| Machinecyclus bij 11,0592 MHz | 1,085 µs — je kunt instructies tellen en de timing weten |
| Software-PWM-frequentie | ~460 Hz met stappen van 5%, uit Timer 0 in 8-bits auto-reload |
| CPU-verbruik door de PWM-ISR | ~25% |
| Overgebleven snelheid van de hoofdlus | Nog steeds ruim boven 200 Hz voor de regellus |
| Gebruikt RAM | Minder dan 100 van de 256 bytes — de beperking is echt maar niet krap |
| Volgprestaties | Vergelijkbaar met de Arduino-bouw; de robot is niet het doel |
Die laatste rij moet je ronduit zeggen. Deze robot presteert niet beter dan de Arduino-lijnvolger. Het is dezelfde robot, op de moeilijke manier gebouwd, en de opbrengst is begrip in plaats van prestaties. Wil je een betere lijnvolger, stel dan de Arduino-versie af. Wil je weten wat analogWrite voor je heeft gedaan, bouw dan deze.
Problemen oplossen
| Symptoom | Vermoedelijke oorzaak | Oplossing |
|---|---|---|
| De chip doet helemaal niets | EA zweeft of is geaard |
Verbind pin 31 met +5 V |
Nog steeds niets, EA is hoog |
Het kristal oscilleert niet | Controleer de condensatoren van 33 pF en de soldeerverbindingen van het kristal |
| De chip wordt steeds opnieuw gereset | RST wordt hoog gehouden | Reset is actief HIGH — controleer het netwerk van 10 µF / 10 kΩ |
| Seriële uitvoer is onleesbaar | Kristal van 12 MHz | Gebruik 11,0592 MHz, of accepteer geen seriële foutzoek |
| LED gloeit zeer zwak | Aangesloten op de bronstroom | Kathode naar de pin; schrijf 0 om hem te laten oplichten |
| Poort 0 leest en schrijft niets | Open drain zonder pull-ups | 10 kΩ van elke pin naar +5 V |
| PWM-periode schokt | De timer wordt te laat in de ISR herladen | Herlaad als eerste instructie, of gebruik modus 2 |
| Programma springt naar een willekeurig adres | Stack overlapt registerbank 1 | SP = 0x30; bovenaan main() |
| Het gedrag wordt onvoorspelbaar naarmate de code groeit | Onvoldoende RAM | 256 bytes totaal — controleer de linkerkaart |
| Programmeur ziet de chip niet | ISP-pinnen in gebruik of geen resetbesturing | Maak P1.5–P1.7 en RST vrij tijdens het programmeren |
| Sensoren leveren geen bruikbare waarde | Analoge array op een chip zonder ADC | Gebruik een array met digitale uitgangen of voeg een externe ADC toe |
Waar je daarna kunt gaan
Voeg een tweede timer toe en meet je eigen lus. Met Timer 0 voor PWM kan Timer 1 de periode van je regellus tellen. Daardoor wordt “het voelt responsief” een getal. Op een chip waarop je machinecycli kunt tellen, is dat getal exact voorspelbaar — controleer je voorspelling.
Gebruik een LCD via poort 0 om het open-drainprobleem te begrijpen en de tijdsvereisten te zien van een apparaat dat werkelijk langzamer is dan de processor.
Bouw daarna de Arduino-versie — en merk op wat je nu van elke regel begrijpt. De analogWrite die je hier in één regel schrijft is de ISR waar je hier een avond aan hebt besteed; analogRead is de ADC die je extern moest toevoegen. Die vergelijking is de echte oplevering van dit project.
Projectroadmap
De bouwroute
Volg de techboom van onderdelen tot een werkende robot. Elk knooppunt wordt ontgrendeld zodra de voorwaarden klaar zijn, en je voortgang wordt op dit apparaat opgeslagen.
0 / 17 klaar
Componenten
- Controller8051-microcontrollerDe chip uit je studieprogramma, met niets tussen jou en de hardware.
- SensorIR-reflectiesensorarrayEen rij infrarode ogen die een robot vertelt waar de lijn ligt.
- DriverL298N-motordriverDe dubbele H-brug die zwakke logica-pins omzet in motorvermogen.
- ActuatorDC-gelijkstroommotor (TT Motor)De gele tandwielmotor die een kale basis in een rijdende robotauto verandert.
- Chassis2WD-robotchassisDe basis waarop twee motoren, een vrij zwenkwiel en je elektronica worden gemonteerd.
- VoedingAccu- en voedingspakket voor robotsHet verschil tussen een robot die blijft draaien en een robot die steeds opnieuw opstart.
Tutorials in deze route
- Beginner · 30 min lezen8051-architectuur: pinnen, geheugenkaart en registersHarvard-kern, vier poorten, 256 bytes RAM en timing die je in machinacycli kunt meetellen.
- Beginner · 28 min8051 GPIO en poortinterfacing: trek aan, stuur nietWaarom 8051-LED's omgekeerd bedraad zijn, waarom je eerst 1 schrijft voor je leest, en wat een poort kan aansturen.
- Gevorderd · 35 min lezen8051-timers en software-PWM voor motorregelingBouw PWM vanuit een timer 0-interrupt, kies de afweging tussen frequentie en resolutie, en stuur een H-brug aan.
- Beginner · 20 minEen IR-reflectiearray lezen voor lijnvolgenMaak van een rij IR-sensoren één vloeiende lijnpositie waarop je kunt sturen.
- Beginner · 18 min lezenBestuur gelijkstroommotoren met PWM en een H-brugBedraad en bestuur een gelijkstroommotor met borstels veilig met PWM, een H-brug en realistische stroomgrenzen.
- Beginner · 20 min lezenBouw een lijnvolger: van sensoren tot PID-besturingVan IR-reflectiesensoren via een gewogen fout naar vloeiende PID-besturing — zo werkt een lijnvolger echt.
Oefen voordat je bedraadt
Stem het af in de live simulator
De bouwroute loopt via een lab in de browser. Krijg het gedrag hier goed en zet je instellingen daarna over naar de echte robot.
Veelgestelde vragen
Waarom bouw je een lijnvolger op een 8051 in plaats van op een Arduino?
Omdat de 8051 je zichtbaar maakt wat de Arduino verbergt. Er is geen analogWrite, dus schrijf je zelf de PWM-generator; er is geen pinMode, dus leer je wat quasi-bidirectionele poorten werkelijk doen. Wil je een robot die werkt, gebruik dan een Arduino. Wil je de robot begrijpen, dan leert de 8051 je meer per uur dan elk bord met een bibliotheek voor alles.
Welke componenten heb ik nodig voor een 8051-lijnvolgerrobot?
Een AT89S52 met kristal en resetcircuit, een IR-reflectiesensorarray, een H-brugdriver zoals de L298N of L293D, twee TT-tandwielmotoren, een 2WD-chassis en een accupakket met afzonderlijke voedingen voor de logica en de motoren. Je hebt ook een ISP-programmeur nodig — een USBasp kost heel weinig en programmeert de AT89S52 via vier pinnen.
Hoe bestuur je de motorsnelheid op een 8051 zonder PWM-hardware?
Je genereert de PWM in software. Timer 0 draait in 8-bits auto-reloadmodus en onderbreekt elke 100 machinecycli; de interrupt telt tikken en houdt de uitvoer tijdens de eerste N tikken van elke periode hoog. Bij 11,0592 MHz geeft dat 460,8 Hz met stappen van 5% en kost ongeveer een kwart van de CPU — de afweging die je maakt omdat er geen PWM-hardware is.
Kan ik de code in C schrijven, of moet ik assembly gebruiken?
C is prima en wordt tegenwoordig in de meeste cursussen gebruikt. Keil C51 is de industriële standaard en SDCC is een gratis open-sourcealternatief. Assembly is de moeite waard om op deze chip te lezen — de instructieset is klein en de timing is meetbaar — maar je hoeft er geen hele robot mee te schrijven.
Waarom doet mijn 8051-robot helemaal niets na het programmeren?
Controleer eerst of EA (pin 31) aan +5 V hangt. Laat de pin zweven of verbind hem met aarde, dan probeert de chip zijn programma uit extern geheugen te halen dat er niet is, en gebeurt er niets zonder enige foutmelding. Controleer daarna het resetcircuit — reset bij de 8051 is actief hoog — en de twee belastingscondensatoren van het kristal.
Moet ik onderdelen kopen voordat ik met dit project begin?
Nee. De lijnvolglogica en het afstellen van de versterkingen draaien in de browsersimulator en voor de drie 8051-tutorials heb je alleen de chip op een breadboard nodig. Koop het chassis en de motors wanneer je klaar bent om de fysieke robot te bedraden.