Arduino Uno

Wat het is

De Arduino Uno is een klein ontwikkelbord rond de ATmega328P van Microchip, een 8-bits microcontroller. De pinnen van de chip zijn beschikbaar op gelabelde headers; het bord voegt een USB-poort toe voor programmeren en voeding en regelt de lastige details af, zoals de spanningsregelaar, het klokkristal en het resetcircuit, zodat jij je kunt richten op code en bedrading. Voor veel beginnende roboticalerenden begint hun eerste robotavontuur bij de Uno: daar laten ze voor het eerst een motor draaien of een sensor oplichten.

De blijvende aantrekkingskracht is niet de ruwe prestatie; volgens moderne maatstaven is hij traag en heeft hij weinig geheugen. Het is vergevingsgezindheid. De 5V-pinnen verdragen bedradingsfouten van beginners, de community heeft vrijwel elke denkbare vraag beantwoord en vrijwel elke hobbysensor en driver wordt geleverd met voorbeeldcode voor de Uno.

Hoe het werkt

Je schrijft een sketch, een C++-programma met twee functies. setup() wordt eenmaal uitgevoerd als het bord aan gaat; loop() draait daarna voor altijd. Daarin lees je ingangen en bestuur je uitgangen via de pinnen:

• Digitale pinnen lezen of schrijven een HIGH/LOW-signaal (5 V / 0 V), zoals een knopdruk, een LED of de richtingsingang van een motordriver.
• PWM-pinnen, herkenbaar aan ~, bootsen een analoge spanning na door zeer snel aan en uit te schakelen. Daarmee stel je de snelheid van een motor of de helderheid van een LED in.
• Analoge ingangen meten een spanning van 0–5 V en geven die terug als getal van 0–1023. Zo lees je een potentiometer of een analoge lijnsensor.

De Uno heeft geen besturingssysteem. Alleen je code draait, waardoor de timing voorspelbaar is. Dat is waardevol wanneer je een regellus rond een echte robot sluit.

Wanneer je hem gebruikt

Kies een Uno wanneer je leert, de grootst mogelijke verzameling compatibele tutorials en bibliotheken wilt of een eenvoudige real-timetaak uitvoert: enkele sensoren uitlezen, een regellus draaien en twee motoren aansturen. Een lijnvolger, een robot met obstakelvermijding of een kleine rover met differentiaalaandrijving valt precies binnen zijn comfortabele toepassingsgebied.

Kies iets anders wanneer je Wi-Fi of Bluetooth nodig hebt, meestal een ESP32 als upgrade, zware wiskunde of beeldverwerking nodig hebt, met een Raspberry Pi, of veel geheugen nodig hebt. De 2 KB SRAM van de Uno vult zich sneller dan beginners verwachten; lange tekenreeksen en grote arrays zijn de gebruikelijke oorzaken.

Veelvoorkomende valkuilen

• Het is een 5V-bord. Veel moderne sensoren werken op 3,3 V en kunnen door 5V-logica beschadigen. Controleer de datasheet vóór het bedraden.
• Voed motoren niet vanaf het bord. De spanningsregelaar van de Uno kan geen motorstroom leveren; gebruik een aparte accu en een motordriver. Motoren rechtstreeks via de Uno voeden is de meest voorkomende oorzaak van brown-out of een reset van het bord.
• delay() blokkeert alles. Terwijl het bord in een delay() staat, kan het geen sensoren uitlezen of reageren. Gebruik voor alles dat moet reageren millis() om de tijd bij te houden.
• Let op het geheugen. Gedraagt het bord zich zonder duidelijke reden onvoorspelbaar, dan ben je mogelijk de SRAM kwijt.

Pindindeling: wat elke pin werkelijk kan

Veertien digitale en zes analoge pinnen, maar ze zijn niet uitwisselbaar. Zes daarvan hebben een tweede belangrijke taak.

Twee van die lijnen bepalen de meeste robotontwerpen. D2 en D3 zijn de enige echte interruptpins, dus een robot met twee wielencoders gebruikt beide en houdt er geen over. En A4/A5 vormen de I²C-bus, dus een MPU-6050 en een analoge sensorarray op een Uno concurreren meteen om pinnen.

Deze pintekort is de belangrijkste reden dat een project uit de Uno groeit, niet de snelheid of het geheugen. Veertien digitale en zes analoge pinnen zijn snel op als je een motordriver (6 pinnen), een encoderpaar (4 pinnen, waarvan 2 interrupts) en een sensorarray (6 analoge) hebt.

Voeding en de drie manieren om het te verprutsen

De regelaar is lineair en verbrandt dus het verschil tussen de ingang en 5 V als warmte. Bij 12 V in en 200 mA verbruik is dat (12 − 5) × 0.2 = 1.4 W in een kleine behuizing, waardoor hij werkelijk warm wordt. Voer liever 9 V dan 12 V toe als je kunt kiezen.

Drie specifieke fouten zijn het noemen waard:

Motoren voeden via de 5V-pin. De regelaar kan geen motorstroom leveren. De rail zakt, het bord reset en het symptoom lijkt op een softwarecrash. Motoren krijgen een eigen voeding en delen alleen de massa.

De 5V-pin voeden vanuit een spanningsbron zonder spanningsregeling. Die pin ligt recht op de rail, dus alles boven ongeveer 5,5 V gaat direct naar de ATmega328P.

Gelijktijdig voeden via USB en de bajonetconnector. Het bord verwerkt dat met een comparator die de hoogste bron selecteert, maar een accu op de connector laadt niet op. Bij een kloon met onvoldoende bescherming in het ontwerp kan die accu via USB stroom terugvoeren.

Wat de pinnen kunnen leveren

De 3,3V-pin verrast mensen regelmatig. Het is geen algemene rail, maar een hulpaansluiting voor 50 mA. Een ESP-01-module die probeert te zenden, veroorzaakt hier direct brown-out.

Het probleem met 2 KB geheugen

De Uno heeft 32 KB flashgeheugen voor je programma en 2 KB SRAM voor variabelen tijdens de uitvoering. Flash is zelden de beperking. SRAM wel, en dat voortdurend.

Elke letterlijke tekenreeks in Serial.print wordt bij het opstarten naar SRAM gekopieerd:

Serial.println("Calibration complete, entering drive mode");   // 43 bytes of SRAM, forever

Twintig zulke berichten nemen 800 bytes in, 40% van het totaal. De F()-macro laat de tekenreeks in flash staan en leest die alleen indien nodig:

Serial.println(F("Calibration complete, entering drive mode"));  // 0 bytes of SRAM

Ook arrays verbruiken veel geheugen. Een float is 4 bytes, dus een logbuffer van 200 monsters is 800 bytes en zonder waarschuwing. De compiler meldet het flashverbruik gewoon en zegt niets bruikbaars over SRAM tijdens de uitvoering.

Het symptoom van een tekort is geen nette foutmelding. De stack groeit naar beneden, de heap naar boven. Wanneer ze elkaar raken, beschadigen variabelen elkaar stilzwijgend. Het bord gedraagt zich onvoorspelbaar: metingen die geen zin hebben, een lus die slaat, een reset zonder oorzaak. Begint een Uno zich onlogisch te gedragen nadat je een functie hebt toegevoegd, ga dan eerst uit van een tekort aan SRAM.

// Drop this in and watch it while you develop.
int freeRam() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

Bij minder dan ongeveer 200 bytes vrij geheugen kun je problemen verwachten.

Problemen oplossen

Uno of iets anders?

De Nano verdient bijzondere vermelding voor robots: het is dezelfde ATmega328P met dezelfde code, maar geschikt voor breadboards en met A6 en A7 als extra analoge ingangen. Voor een 8-kanaals reflectiearray betekent dat het verschil tussen wel of niet passen. Daarom schrijven lijnvolgerbouwprojecten zo vaak een Nano voor.

De eerlijke samenvatting: de waarde van de Uno is dat alles er de eerste keer op werkt. Elke bibliotheek, tutorial en bedradingsschema gaat ervan uit. Tijdens het leren is dat méér waard dan elke specificatie, en als je er te groot voor wordt, is dat vrijwel altijd het aantal pinnen.