Arduino Nano pinout: pindiagram, A6/A7, voeding en Old Bootloader
De Arduino Nano pinout in één gids: D0–D13, A0–A7 (A6/A7 alleen analoog), PWM-pins, VIN/5V/3V3, CH340-driver, Old Bootloader en een pinvergelijking tussen Uno en Nano.
De Arduino Nano pinout bestaat uit 30 pins die langs de twee lange randen van een board van 45 × 18 mm zijn opgesteld: 14 digitale in-/uitgangspinnen (D0–D13), waarvan er 6 PWM kunnen uitsturen (~3, 5, 6, 9, 10, 11), 8 analoge ingangen (A0–A7) en de voedings- en besturingspins: VIN, 5V, 3V3, AREF, twee keer GND en twee keer RST. Omdat de Nano dezelfde ATmega328P-processor gebruikt als de Arduino Uno, zijn de pinnummers en functies ook hetzelfde: een sketch voor de Uno draait zonder aanpassingen, behalve dat je de Nano kiest in het boardmenu.
Toch zijn er een paar belangrijke details die de Nano van de Uno onderscheiden, en daar lopen beginners precies op vast: A6 en A7 zijn alleen analoog, er is geen DC-aansluiting, de 3V3-pin levert heel weinig stroom, clone-boards regelen USB met een CH340-chip en om code te uploaden moet je vaak ATmega328P (Old Bootloader) kiezen. In deze gids leer je elke pin kennen, plaats je de Nano goed op een breadboard, zie je de pinvergelijking tussen Uno en Nano en ontdek je hoe de Nano Every en Nano ESP32 verschillen van de klassieke Nano.

Wat is de Arduino Nano en hoe verschilt hij van de Uno?
De Arduino Nano past alle kernfuncties van de Uno op een board van 45 × 18 mm dat ongeveer 7 gram weegt. De pins wijzen naar beneden, dus hij past direct in een breadboard; dat betekent minder jumperdraden en als de schakeling klaar is, verhuist hij makkelijk naar een doosje of een vaste printplaat. Binnenin zit dezelfde 16 MHz ATmega328P als op de Uno, het logische niveau is 5 V en dezelfde bibliotheken werken ongewijzigd. Op de originele Nano regelt een FT232RL-chip de USB-naar-serieel-communicatie; bijna alle betaalbare clones hebben in plaats daarvan een CH340G of CH340C op de onderkant van het board. Voor robotauto's, wearables, afstandsbedieningen en elke schakeling die in een doosje moet passen, is de Nano een praktischere keuze dan de Uno.
| Eigenschap | Arduino Nano (V3) |
|---|---|
| Microcontroller | ATmega328P, 8-bit, 16 MHz (TQFP-32-behuizing) |
| Logische (werk)spanning | 5 V |
| Ingangsspanning VIN | 7–12 V aanbevolen |
| Digitale in-/uitgang | 14 pins (D0–D13); 20 inclusief A0–A5 |
| PWM-uitgang | 6 pins: D3, D5, D6, D9, D10, D11 |
| Analoge ingang | 8 pins (A0–A7), 10-bit (0–1023) |
| Stroom per pin | 20 mA aanbevolen, 40 mA absoluut maximum |
| Geheugen | 32 KB flash (30.720 bytes bruikbaar in de IDE), 2 KB SRAM, 1 KB EEPROM |
| USB | Mini-B; FT232RL (origineel) of CH340 (clone) |
| Afmetingen en gewicht | 45 × 18 mm, ongeveer 7 g |
Arduino Nano-pindiagram: welke pin zit waar?
De 30 pins van de Nano zijn gerangschikt in twee rijen van 15 tegenover elkaar, met 15,24 mm (0,6 inch) tussen de rijen. Leg het board voor je neer met de mini-USB-aansluiting het dichtst bij jou en je ziet direct naast de aansluiting twee pins tegenover elkaar: D12 en D13. De rij met D13 bevat 3V3, AREF, A0–A7 en de voedingspins; de rij met D12 bevat de digitale pins van D11 naar D2, gevolgd door GND, RST, RX0 (D0) en TX1 (D1). Aan het uiteinde van de twee rijen dat het verst van USB ligt, staan VIN en TX1 tegenover elkaar, en ook de 2×3 ICSP-header zit aan dit uiteinde. Rond de resetknop in het midden vind je de voedingsled (POW of ON), de L-led die met D13 is verbonden en de TX- en RX-leds die tijdens het uploaden knipperen.
| Positie (vanaf USB) | Analoge rij en voedingsrij | Digitale rij | Opmerking |
|---|---|---|---|
| 1 | D13 (SCK, L-led) | D12 (MISO) | Direct naast de USB-aansluiting |
| 2 | 3V3 | ~D11 (MOSI) | 3V3 levert zeer weinig stroom |
| 3 | AREF | ~D10 (SS) | - |
| 4 | A0 | ~D9 | - |
| 5 | A1 | D8 | - |
| 6 | A2 | D7 | - |
| 7 | A3 | ~D6 | - |
| 8 | A4 (SDA) | ~D5 | I2C-datalijn |
| 9 | A5 (SCL) | D4 | I2C-klokliijn |
| 10 | A6 | ~D3 (INT1) | A6 is alleen analoog |
| 11 | A7 | D2 (INT0) | A7 is alleen analoog |
| 12 | 5V | GND | 5V en GND staan tegenover elkaar |
| 13 | RST | RST | Beide zijn dezelfde resetlijn |
| 14 | GND | D0 (RX0) | D0 is verbonden met de USB-serieel-chip |
| 15 | VIN | D1 (TX1) | De ICSP-header zit aan dit uiteinde |
Digitale pins (D0–D13), PWM en speciale functies
Elke digitale pin stel je met pinMode() in als ingang of uitgang; als uitgang geeft HIGH ongeveer 5 V en LOW 0 V. Om te voorkomen dat een ingang zweeft, kun je met INPUT_PULLUP de interne weerstand van 20–50 kΩ van de chip inschakelen. De veilige stroom per pin is 20 mA; een rode led met een weerstand van 220 Ω trekt ongeveer 13 mA en de juiste weerstand vind je met de led-weerstandscalculator. Sommige pins hebben extra functies; als je die vooraf kent, voorkom je conflicten zodra je project groeit:
| Pin | Extra functie | Waar je op moet letten |
|---|---|---|
| D0 (RX), D1 (TX) | Hardware-seriepoort (Serial) | Via weerstanden van 1 kΩ verbonden met de USB-serieel-chip; houd vrij tijdens het uploaden |
| D2, D3 | Externe interrupts INT0, INT1 | attachInterrupt() werkt alleen op deze twee pins |
| ~D3, ~D11 | PWM, Timer2 (ongeveer 490 Hz) | PWM op deze pins valt weg zolang tone() speelt |
| ~D5, ~D6 | PWM, Timer0 (ongeveer 980 Hz) | Dezelfde timer als millis() en delay() |
| ~D9, ~D10 | PWM, Timer1 (ongeveer 490 Hz) | De Servo-bibliotheek schakelt PWM op deze twee pins uit |
| D10–D13 | SPI: SS, MOSI, MISO, SCK | D10 moet een uitgang blijven bij gebruik van SPI |
| D13 | Ingebouwde L-led | De led en zijn weerstand zijn rechtstreeks met de pin verbonden |
Een klein maar belangrijk detail dat de Nano van de Uno onderscheidt, zit op D13. Op de Uno R3 wordt de L-led aangestuurd via een opamp, terwijl op de Nano de led en zijn weerstand rechtstreeks met de pin zijn verbonden. Als je D13 met INPUT_PULLUP als knopingang gebruikt, trekt de led de pin omlaag en lees je mogelijk LOW, ook als de knop niet is ingedrukt; bewaar deze pin voor uitgangen of SPI. Hoe PWM werkt en wat de waarden van analogWrite() betekenen, lees je in Wat is PWM?, en over interrupts in Arduino-interrupts.
Analoge pins A0–A7: waarom zijn A6 en A7 anders?
De acht analoge ingangen van de Nano meten spanningen tussen 0 en 5 V met een resolutie van 10 bit: analogRead() geeft een getal van 0 tot 1023 en één stap is ongeveer 4,9 mV. Indien nodig werken A0–A5 ook als gewone digitale pins (A0 = 14 … A5 = 19) en A4 en A5 zijn tegelijk de SDA- en SCL-lijnen van de I2C-bus. A6 en A7, die de Uno niet heeft, zijn twee extra ADC-kanalen die je vindt op de SMD-behuizing (TQFP) van de ATmega328P. Deze twee kanalen zijn alleen met de analoog-digitaalomzetter verbonden; erachter zit geen poortregister, uitgangsdriver of pull-upweerstand. Daarom werken pinMode(), digitalRead(), digitalWrite() en INPUT_PULLUP niet op deze twee pins.
Dat A6 en A7 alleen analoog zijn lijkt misschien een nadeel, maar je kunt het slim benutten. Als je via weerstanden met verschillende waarden meerdere knoppen op één analoge pin aansluit, geeft elke knop een andere spanning; zo lees je vier knoppen met één pin en houd je de digitale pins vrij voor motoren en displays. Verbind in de schakeling A6 via een weerstand van 10 kΩ met 5V; sluit de eerste knop rechtstreeks aan tussen A6 en GND en de andere drie knoppen via respectievelijk weerstanden van 2,2 kΩ, 4,7 kΩ en 10 kΩ op GND.
1// A6'da 4 buton: 10 kΩ pull-up + farklı seri dirençler / 4 buttons on A6: 10 kΩ pull-up + different series resistors
2const byte LADDER_PIN = A6; // yalnız analog pin / analog-only pin
3
4byte readButton() {
5 int v = analogRead(LADDER_PIN);
6 if (v < 92) return 1; // 0 Ω -> yaklaşık 0 / about 0
7 if (v < 256) return 2; // 2,2 kΩ -> yaklaşık 184 / about 184
8 if (v < 419) return 3; // 4,7 kΩ -> yaklaşık 327 / about 327
9 if (v < 767) return 4; // 10 kΩ -> yaklaşık 512 / about 512
10 return 0; // basılı değil -> 1023 / not pressed -> 1023
11}
12
13void setup() {
14 Serial.begin(9600);
15}
16
17void loop() {
18 static byte lastButton = 0;
19 byte b = readButton();
20 if (b != lastButton) {
21 delay(20); // kontak sıçramasını bekle / wait out contact bounce
22 b = readButton(); // değeri doğrula / confirm the value
23 if (b != lastButton) {
24 lastButton = b;
25 if (b != 0) {
26 Serial.print(F("Buton / Button: "));
27 Serial.println(b);
28 }
29 }
30 }
31}| Knop | Serieweerstand naar GND | Verwachte analogRead | Bereik dat in de code wordt geaccepteerd |
|---|---|---|---|
| Knop 1 | 0 Ω (direct) | 0 | 0–91 |
| Knop 2 | 2,2 kΩ | Ongeveer 184 | 92–255 |
| Knop 3 | 4,7 kΩ | Ongeveer 327 | 256–418 |
| Knop 4 | 10 kΩ | Ongeveer 512 | 419–766 |
| Geen | - | 1023 | 767–1023 |
De waarden komen uit de formule analogRead = 1023 × R / (10 kΩ + R) en elke drempel ligt precies halverwege twee naburige waarden. Omdat de pull-upweerstand en de ADC door dezelfde 5V-rail worden gevoed, veranderen de metingen niet, ook niet als de voeding zakt naar 4,7 V; dit heet een ratiometrische meting. Als twee knoppen tegelijk zijn ingedrukt, komen hun weerstanden parallel te staan en daalt de meting: de code ziet een knop met een lager nummer, en als je 3 en 4 samen indrukt, lees je zelfs knop 2. Daarom is een weerstandsladder geschikt voor menu's waarbij steeds maar één toets wordt ingedrukt. Je kunt de spanningsdeling uitproberen met de spanningsdelercalculator en meer over analoge metingen lezen in het ADC-artikel.
Voedingspins: VIN, 5V, 3V3 en GND
| Pin | Wat doet het | Limieten en waarschuwingen |
|---|---|---|
| VIN | Voedt het board met 7–12 V; de regelaar brengt dit terug naar 5 V | De AMS1117 op clones verdraagt maximaal 15 V en wordt bij 12 V snel heet |
| 5V | De 5V-rail van het board: als uitgang voedt hij sensoren, als ingang accepteert hij geregelde 5 V | Ongeveer 4,7 V via USB; zet er nooit meer dan 5 V van buitenaf op |
| 3V3 | 3,3 V-uitgang | Komt van de FT232RL op het origineel en van de CH340 op clones; zeer beperkte stroom |
| GND (2 pins) | Gemeenschappelijke massa | De GND van elke externe voeding moet hier worden aangesloten |
| RST (2 pins) | Herstart het board als hij LOW wordt getrokken | Voor een externe resetknop; beide zijn dezelfde lijn |
| AREF | Externe referentie-ingang voor analoge metingen | Roep analogReference(EXTERNAL) aan voordat je hem gebruikt |
Je kunt de Nano op drie manieren voeden. Bij voeding via USB komt de 5 V van de computer via een schottkydiode; de diode laat ongeveer 0,3 V wegvallen, dus op de 5V-pin meet je meestal 4,6–4,8 V, en de MBR0520-diode op het originele board is gespecificeerd voor maximaal 500 mA. Als je 7–12 V op de VIN-pin zet, brengt de regelaar aan de onderkant (een LM1117 op het origineel, meestal een AMS1117 op clones) dit terug naar 5 V. De regelaar zet de overtollige spanning om in warmte: het vermogen dat hij afvoert is (VIN − 5 V) × stroom, dus als je 150 mA uit een ingang van 12 V haalt, verstookt de kleine regelaar ongeveer 1 W en wordt hij te heet om aan te raken. Daarom is 7–9 V ideaal voor VIN. De derde manier is geregelde 5 V van buitenaf op de 5V-pin zetten; de regelaar wordt dan omzeild en de diode aan de USB-kant voorkomt dat er stroom terugvloeit naar je computer. Als je op een voeding van 12 V werkt, is een LM2596-stepdownconverter die 5 V maakt en op de 5V-pin wordt aangesloten een veel koelere oplossing; alle voedingsmogelijkheden staan in Hoe voed je een Arduino.
De 3V3-pin is de meest misverstane pin van de Nano. Op de Uno komt deze pin van een aparte regelaar, maar de klassieke Nano heeft geen aparte 3,3 V-regelaar. Op de originele Nano komt de 3,3 V van een kleine regelaar in de FT232RL-chip (maximaal 50 mA) en volgens oudere documentatie van Arduino is deze uitgang niet beschikbaar als het board niet via USB wordt gevoed. Op de meeste clones is de pin verbonden met de eigen interne regelaar van de CH340 en is hij alleen veilig voor belastingen van enkele mA. Voed dus geen 3,3 V-modules zoals de nRF24L01, ESP-01 of RC522 via deze pin; gebruik een aparte AMS1117-3.3-regelaar die je voedt vanaf de 5V-pin. En als je een 5 V-uitgang van de Nano met de ingang van een 3,3 V-module verbindt, plaats er dan een niveauconverter of een spanningsdeler tussen.
Dat de 5V-pin via USB rond 4,7 V zit, beïnvloedt ook analoge metingen: analogRead() gebruikt de voedingsspanning als bovengrens, dus als je 5,0 V in je berekening zet, wijkt het resultaat 4–6 procent af. De werkelijke voedingsspanning kun je bepalen door de interne vaste referentie van de ATmega328P van ongeveer 1,1 V te meten. De eerste testsketch hieronder doet precies dat, rekent alle acht analoge ingangen met de werkelijke voedingsspanning om naar volt en laat de L-led op D13 knipperen:
1// Arduino Nano: A0-A7'yi ve gerçek besleme gerilimini oku / read A0-A7 and the real supply voltage
2const byte ANALOG_PINS[8] = {A0, A1, A2, A3, A4, A5, A6, A7};
3
4long readVccMillivolts() {
5 // Referans AVcc, ölçülen kanal dahili 1,1 V / reference AVcc, measured channel internal 1.1 V
6 ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
7 delay(2); // referansın oturmasını bekle / let the reference settle
8 ADCSRA |= _BV(ADSC); // dönüşümü başlat / start the conversion
9 while (bit_is_set(ADCSRA, ADSC)) {} // bitmesini bekle / wait until it finishes
10 unsigned int raw = ADC; // 10 bit sonuç / 10-bit result
11 return 1125300L / raw; // 1,1 V x 1023 x 1000 / 1.1 V x 1023 x 1000
12}
13
14void setup() {
15 Serial.begin(9600);
16 pinMode(LED_BUILTIN, OUTPUT); // D13'teki L LED'i / L LED on D13
17}
18
19void loop() {
20 long vcc = readVccMillivolts();
21 analogRead(A0); // kanal değişti, ilk okumayı at / channel changed, discard the first reading
22 Serial.print(F("Vcc: "));
23 Serial.print(vcc);
24 Serial.print(F(" mV |"));
25 for (byte i = 0; i < 8; i++) {
26 int raw = analogRead(ANALOG_PINS[i]); // A6 ve A7 de okunur / A6 and A7 are read too
27 Serial.print(F(" A"));
28 Serial.print(i);
29 Serial.print(F("="));
30 Serial.print(raw * (vcc / 1000.0) / 1023.0, 2); // gerçek Vcc ile volta çevir / convert to volts using the real Vcc
31 }
32 Serial.println();
33 digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); // L LED'ini çevir / toggle the L LED
34 delay(1000);
35}Open na het uploaden de Serial Monitor op 9600 baud. De waarde Vcc moet rond 4600–4800 mV liggen via USB en rond 5000 mV bij voeding via VIN. Niet aangesloten analoge pins geven willekeurige waarden; als je een potentiometer op A0 aansluit en eraan draait, zie je de waarde soepel veranderen tussen 0 en Vcc. De interne referentie kan per chip ±10% variëren; voor een nauwkeuriger resultaat meet je de 5V-pin met een multimeter en vermenigvuldig je de constante 1125300 in de code met de verhouding jouw gemeten waarde / de waarde die de code toont. Omdat deze sketch direct registers van de ATmega328P gebruikt, werkt hij niet op de Nano Every of Nano ESP32.
Mini-USB, CH340 en driverinstallatie
De klassieke Nano heeft een Mini-B USB-aansluiting; de micro-USB- of USB-C-kabels van telefoons passen er niet in. Sommige nieuwere clones hebben micro-USB- of USB-C-aansluitingen, maar de meeste hebben nog steeds mini-USB. De meest voorkomende reden dat het board helemaal niet in de poortlijst verschijnt, is een kabel die alleen oplaadt en geen datadraden heeft: de voedingsled gaat branden, maar de computer ziet het board niet. Als de kabel in orde is, draai je het board om en kijk je naar de chip bij de USB-aansluiting. Staat daar FT232RL, dan heb je een originele Nano en zit de driver meestal al in het besturingssysteem; staat daar CH340G of CH340C, dan heb je een clone.
Windows 10 en 11 installeren de CH340-driver vaak zelf via Windows Update en het board verschijnt in Apparaatbeheer met een naam als USB-SERIAL CH340 (COM3). Zie je onder Overige apparaten een USB2.0-Serial met een geel uitroepteken, installeer dan de CH341SER-driver van de chipmaker WCH, haal het board eruit en steek hem weer in. Huidige macOS-versies bevatten de driver; de poort verschijnt als /dev/cu.usbserial-… en oude drivers erbovenop installeren kan conflicten veroorzaken. Op Linux zit de driver in de kernel; als de poort verdwijnt zodra je het board aansluit op Ubuntu 22.04 of nieuwer, grijpt het schermlezerpakket brltty de CH340 en als je dat niet gebruikt, kun je het verwijderen met sudo apt remove brltty. Alle poort- en driverproblemen staan in Arduino uploadt niet en de verschillen tussen USB-serieel-chips in USB-naar-TTL-converters.
Code uploaden: ATmega328P of Old Bootloader?
- Kies in de Arduino IDE Tools › Board › Arduino AVR Boards › Arduino Nano.
- Steek het board in en kies onder Tools › Port de nieuwe poort (zoals COM3 op Windows of /dev/cu.usbserial-… op macOS).
- Probeer onder Tools › Processor eerst het voorbeeld Blink te uploaden met de optie ATmega328P.
- Als de uitvoer bij tien pogingen steeds programmer is not responding of not in sync meldt, zet Processor dan op ATmega328P (Old Bootloader) en upload opnieuw.
- Als het nog steeds mislukt, probeer dan een andere USB-poort, haal eventuele draden van D0 en D1 en controleer of de L-led snel knippert als je op de resetknop drukt.
- Noteer welke optie werkte; andere Nano's van dezelfde verkoper hebben waarschijnlijk dezelfde instelling nodig.
De reden voor deze verwarring is een wijziging uit 2018. Arduino verving de oude bootloader van 2 KB van de Nano (ATmegaBOOT) door de Optiboot van 512 bytes die ook op de Uno wordt gebruikt. Optiboot ontvangt code met 115200 baud, terwijl de oude bootloader 57600 baud verwacht; als de snelheden niet overeenkomen, lijkt het board helemaal niet te reageren. Omdat clonemakers jarenlang boards met de oude bootloader bleven leveren, biedt de IDE beide opties aan en het kiezen van de verkeerde doet het board geen kwaad. Als je wilt, kun je een tweede Arduino als ArduinoISP gebruiken om de nieuwe bootloader op de Nano te branden: uploaden gaat sneller en ook de eindeloze resetlus van de oude bootloader na een watchdogreset verdwijnt.
| Processoroptie | Bootloader | Uploadsnelheid | Ruimte voor code |
|---|---|---|---|
| ATmega328P | Optiboot (sinds 2018) | 115200 baud | 30.720 bytes |
| ATmega328P (Old Bootloader) | ATmegaBOOT (oud) | 57600 baud | 30.720 bytes |
| ATmega168 | ATmegaBOOT (oud) | 19200 baud | 14.336 bytes |
Plaatsing op een breadboard en solderen

Als je de Nano in een breadboard steekt, plaats hem dan zo dat de twee rijen pins aan weerszijden van het middenkanaal zitten. Zo komt elke pin in zijn eigen strip en kun je via de vrije gaatjes van die strip draden op die pin aansluiten. Omdat het board het kanaal en de gaatjes tussen de pins bedekt, blijven er naast elke pin maar een paar gaatjes over; op gangbare breadboards met 830 contacten heb je, als je het board in het midden over het kanaal plaatst, 2 vrije gaatjes aan de ene kant en 3 aan de andere. Door de USB-aansluiting naar de korte rand van het breadboard te richten, is de kabel makkelijk aan te sluiten. Verbind daarna de pins 5V en GND van de Nano met de rode en blauwe voedingsrails van het breadboard, zodat je daar sensoren mee kunt voeden. Wil je opfrissen hoe een breadboard van binnen is bedraad, lees dan Wat is een breadboard?.
- De headers solderen: Bij clones die met losse pins komen, druk je eerst de male headers in het breadboard, leg je de Nano erop en soldeer je hem zo; het breadboard houdt de headers recht en precies 0,6 inch uit elkaar. De techniek vind je in Hoe soldeer je.
- Verwijderen: Als je het board aan één kant optilt, buigen de pins; til beide uiteinden steeds een stukje op of schuif een platte schroevendraaier eronder en trek het board gelijkmatig los.
- Slecht contact: Bij oude of goedkope breadboards slijten de veertjes; de Nano reset dan af en toe of een sensor valt soms uit. Probeer het board naar een ander deel van het breadboard te verplaatsen.
- Nano-uitbreidingsboard: In een vast project vermindert een Nano I/O-shield met schroefklemmen of 3-pins headers die voor elke pin signaal, 5V en GND geven de bedradingswirwar sterk.
- Minibreadboard: Kleine breadboards met 170 contacten hebben geen voedingsrails; leid 5V en GND naar aparte strips en markeer ze met draadkleuren.
Pinvergelijkingstabel Arduino Uno naar Nano
| Functie | Arduino Uno R3 | Arduino Nano | Opmerking |
|---|---|---|---|
| Digitale I/O | D0–D13 | D0–D13 | Dezelfde nummers en functies |
| PWM | ~3, 5, 6, 9, 10, 11 | ~3, 5, 6, 9, 10, 11 | Dezelfde frequenties en timers |
| Analoge ingang | A0–A5 | A0–A7 | A6 en A7 bestaan alleen op de Nano en zijn alleen analoog |
| I2C SDA / SCL | A4 / A5 (kopie naast AREF) | A4 / A5 | Geen aparte SDA/SCL-pins op de Nano |
| SPI SS / MOSI / MISO / SCK | 10 / 11 / 12 / 13 | 10 / 11 / 12 / 13 | Beide hebben ze ook op de ICSP-header |
| Externe interrupts | D2, D3 | D2, D3 | Hetzelfde |
| Ingebouwde led | D13 (gebufferd via opamp) | D13 (rechtstreeks met de pin verbonden) | Wees voorzichtig met D13 als ingang op de Nano |
| Voedingsingang | DC-aansluiting en Vin, 7–12 V | Alleen VIN-pin, 7–12 V | Geen aansluiting op de Nano |
| USB | USB-B; ATmega16U2 of CH340 | Mini-B; FT232RL of CH340 | Andere kabels |
| 3,3V-uitgang | Aparte regelaar, 50 mA | Van de USB-chip, zeer beperkt | Voed op de Nano geen modules hiermee |
| IOREF | Ja | Nee | Voor shieldcompatibiliteit |
| Ruimte voor code | 32.256 bytes | 30.720 bytes | De IDE reserveert 2 KB op de Nano |
| Shields plaatsen | Direct | Met een adapter of uitbreidingsboard | - |
Zoals de tabel laat zien, hoef je een schakeling die voor de Uno is gebouwd alleen over te zetten naar de Nano door de draden op de pins met dezelfde nummers aan te sluiten: een servo op D9 van de Uno gaat naar D9 op de Nano en een I2C-display op A4/A5 blijft op A4/A5. De enige wijziging in de code is dat je onder Tools › Board Arduino Nano kiest. Shields die direct op de Uno passen, passen echter niet op de Nano; daarvoor bestaan adapterboards die de Nano omzetten naar de pinindeling van de Uno. De gedetailleerde rol van elke pin op de Uno vind je in Arduino Uno pinout en hulp bij het kiezen van een board in Welke Arduino moet ik kopen?.
Nano Every en Nano ESP32: hoe ze verschillen van de klassieke Nano
| Eigenschap | Klassieke Nano (V3) | Nano Every | Nano ESP32 |
|---|---|---|---|
| Processor | ATmega328P, 8-bit, 16 MHz | ATmega4809, 8-bit, 16 MHz in de IDE (tot 20 MHz) | ESP32-S3, dual-core, 32-bit, 240 MHz |
| Flash / SRAM | 32 KB / 2 KB | 48 KB / 6 KB | 16 MB / 512 KB (+8 MB PSRAM) |
| Logische spanning | 5 V | 5 V | 3,3 V (niet 5 V-tolerant) |
| USB | Mini-B | Micro-B | USB-C |
| VIN-bereik | 7–12 V aanbevolen | 7–21 V | 6–21 V |
| PWM-pins | D3, D5, D6, D9, D10, D11 | D3, D5, D6, D9, D10 (niet op D11) | Bijna alle digitale pins |
| A6 / A7 | Alleen analoog | Analoog en digitaal | Analoog en digitaal |
| Externe interrupts | Alleen D2, D3 | Alle digitale pins | Alle pins |
| Seriële lijn D0 / D1 | Gedeeld met USB (Serial) | Los van USB (Serial1) | Los van USB (Serial0) |
| Draadloos | Geen | Geen | Wi-Fi en Bluetooth LE |
| Boardpakket in de IDE | Arduino AVR Boards | Arduino megaAVR Boards | Arduino ESP32 Boards |
De Nano Every is een krachtigere versie van de klassieke Nano met dezelfde afmetingen en dezelfde pinindeling. Hij heeft een ATmega4809 aan boord, werkt op 5 V en biedt 48 KB flash en 6 KB SRAM, zodat OLED- en ledstripprojecten die moeite hebben met het RAM van de klassieke Nano wat ademruimte krijgen. Aan de USB-kant fungeert een SAMD11-chip als brug en wordt code geüpload via de UPDI-interface, dus je hebt geen gedoe met Old Bootloader. Om het board te gebruiken, installeer je het pakket Arduino megaAVR Boards via de Boards Manager. De verschillen om op te letten: PWM zit alleen op D3, D5, D6, D9 en D10 (D11 heeft geen PWM), A6 en A7 werken ook als digitale pins, elke digitale pin kan als externe interrupt worden gebruikt en D0 en D1 vormen een van USB onafhankelijke Serial1-poort. De instelling Tools › Registers emulation › ATMEGA328 emuleert poortregisters zoals PORTB, maar oude code die direct naar timer- of ADC-registers schrijft, werkt nog steeds niet. De sketch hieronder toont twee verschillen van de Every samen: hij praat met een module op D0/D1 terwijl de Serial Monitor open is en gebruikt A7 als knopingang met de interne pull-up.
1// Nano Every: Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2const byte BUTTON_PIN = A7; // Every'de A7 dijital de çalışır / A7 also works as digital on the Every
3
4bool lastState = HIGH;
5
6void setup() {
7 Serial.begin(9600); // Seri Monitör / Serial Monitor
8 Serial1.begin(9600); // D0/D1'deki modül, ör. HC-05 / module on D0/D1, e.g. HC-05
9 pinMode(BUTTON_PIN, INPUT_PULLUP); // klasik Nano'nun A7'sinde çalışmaz / does not work on the classic Nano's A7
10}
11
12void loop() {
13 if (Serial1.available()) {
14 Serial.write(Serial1.read()); // modülden bilgisayara / module to computer
15 }
16 if (Serial.available()) {
17 Serial1.write(Serial.read()); // bilgisayardan modüle / computer to module
18 }
19 bool state = digitalRead(BUTTON_PIN);
20 if (state != lastState) { // durum değişince bildir / report when the state changes
21 lastState = state;
22 Serial1.println(state == LOW ? "Buton basildi / Button pressed" : "Buton birakildi / Button released");
23 delay(20); // kontak sıçraması / contact bounce
24 }
25}De Nano ESP32 daarentegen is een heel andere wereld in dezelfde boardgrootte: de ESP32-S3-processor in de u-blox NORA-W106-module draait op 240 MHz en biedt Wi-Fi en Bluetooth LE. Het belangrijkste verschil is de spanning: alle pins werken op 3,3 V en zijn niet 5 V-tolerant, dus een sensor met een 5 V-uitgang die je rechtstreeks op een klassieke Nano zou aansluiten, kan de Nano ESP32 beschadigen. Waar de klassieke Nano zijn 5V-pin heeft, zit een VBUS-pin, die alleen 5 V geeft als het board via USB wordt gevoed; bij voeding via VIN is deze pin dood. In plaats van AREF en de RST-pin aan de analoge kant vind je BOOT0 en BOOT1. Het board programmeer je met het pakket Arduino ESP32 Boards en het menu Tools › Pin Numbering heeft twee opties: in de standaardinstelling By Arduino pin gelden de namen D en A die op het board staan, terwijl bij By GPIO number de nummers de GPIO-nummers van de ESP32 zijn. D2 is bijvoorbeeld in werkelijkheid GPIO5; in GPIO-modus configureert pinMode(2, OUTPUT) in plaats daarvan pin A1. Als je pins altijd op naam schrijft, zoals D2 en A0, werkt je code in beide modi correct.
1// Nano ESP32: Araçlar > Pin Numbering > By Arduino pin (default)
2// Nano ESP32: Tools > Pin Numbering > By Arduino pin (default)
3bool ledOn = false;
4
5void setup() {
6 Serial.begin(115200); // USB-C üzerinden / over USB-C
7 pinMode(LED_BUILTIN, OUTPUT); // D13 = GPIO48
8 pinMode(LED_RED, OUTPUT);
9 pinMode(LED_GREEN, OUTPUT);
10 pinMode(LED_BLUE, OUTPUT);
11 digitalWrite(LED_RED, HIGH); // RGB LED ters mantık: HIGH = sönük / active low: HIGH = off
12 digitalWrite(LED_GREEN, HIGH);
13 digitalWrite(LED_BLUE, HIGH);
14 analogReadResolution(12); // 0-4095 arası / range 0-4095
15}
16
17void loop() {
18 int raw = analogRead(A0); // 12 bit ham değer / 12-bit raw value
19 int mv = analogReadMilliVolts(A0); // kalibre edilmiş milivolt / calibrated millivolts
20 Serial.printf("A0: %d (%d mV)\n", raw, mv);
21 digitalWrite(LED_GREEN, mv > 1650 ? LOW : HIGH); // 1,65 V üstünde yeşil / green above 1.65 V
22 digitalWrite(LED_RED, mv > 1650 ? HIGH : LOW); // altında kırmızı / red below
23 ledOn = !ledOn;
24 digitalWrite(LED_BUILTIN, ledOn ? HIGH : LOW); // D13 LED'ini yakıp söndür / blink the D13 LED
25 delay(500);
26}De analoge ingangen van de Nano ESP32 meten met 12 bit en geven waarden van 0 tot 4095, terwijl analogReadMilliVolts() de kalibratiegegevens van de chip gebruikt om het resultaat direct in millivolt te geven. De ingebouwde RGB-led werkt met omgekeerde logica, dus hij gaat branden als je LOW schrijft. Als code niet wil uploaden en het board uit de poortlijst verdwijnt, kun je het in bootloadermodus zetten door twee keer snel achter elkaar op de resetknop te drukken. Meer over de Wi-Fi-kant van de ESP32 lees je in Wat is de ESP32? en om een board te kiezen, lees je Arduino of ESP32?. Van de andere leden van de familie brengt de Nano R4 dezelfde 48 MHz Renesas RA4M1-processor als de Uno R4 naar het 5 V Nano-formaat, maar hij levert slechts 8 mA per pin, terwijl de Nano 33 IoT en Nano 33 BLE net als de Nano ESP32 3,3 V-boards zijn.
Projectideeën met de Arduino Nano
- Zakthermometer: Toon de temperatuur die je met een DHT11 meet op een klein OLED-display; de Nano en het display passen in een luciferdoosje.
- Mini-robotauto: Het kleine formaat van de Nano bespaart ruimte op het chassis; stuur de motoren aan met een L298N en volg de stappen in Een robotauto bouwen.
- Lijnvolgrobot: Acht analoge ingangen zijn ruim voldoende om een array van vijf sensoren uit te lezen; de details staan in Lijnvolgrobot.
- Bluetooth-afstandsbediening: Sluit een HC-05-module met SoftwareSerial aan op D8 en D7 en bedien een led of relais vanaf je telefoon; D0 en D1 blijven vrij om te uploaden.
- Wearable-licht: Maak een badge- of tasverlichting met een Nano op batterijen en een paar WS2812B-leds.
- Een toetsenbordje op één pin: Bouw de weerstandsladder hierboven op zowel A6 als A7 voor een menu met acht knoppen en bewaar de digitale pins voor het display en de motoren.
- Wil je een USB-toetsenbord? De ATmega328P van de klassieke Nano heeft geen ingebouwde USB en kan dus niet als toetsenbord of muis bij een computer verschijnen; daarvoor heb je boards met een ATmega32U4 nodig, zoals de Leonardo en Pro Micro.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| De Nano verschijnt niet in de poortlijst | Kabel die alleen oplaadt of ontbrekende CH340-driver | Gebruik een datakabel, installeer de CH341SER-driver; verwijder brltty op Linux |
| Het uploaden stopt met de fout "not in sync" | Het board heeft de oude bootloader | Tools › Processor › ATmega328P (Old Bootloader) |
| Een knop op A6 of A7 reageert helemaal niet | Deze pins hebben geen digitalRead of interne pull-up | Voeg een externe pull-up van 10 kΩ toe en gebruik een drempel met analogRead |
| Een knop op D13 wordt altijd als ingedrukt gelezen | De L-led en zijn weerstand trekken de pin omlaag | Verplaats de knop naar een andere pin |
| Een module die via 3V3 wordt gevoed is instabiel of dood | De 3V3-pin levert zeer weinig stroom | Gebruik een aparte 3,3 V-regelaar die vanaf 5V wordt gevoed |
| Analoge metingen zijn een paar procent te hoog | Via USB staat de 5V-pin op ongeveer 4,7 V | Meet de werkelijke Vcc of voed het board via VIN |
| Het board wordt erg heet met 12 V op VIN | De regelaar voert (12 − 5) × stroom af als warmte | Zet 7–9 V op VIN of voed de 5V-pin met een stepdownmodule |
| Met een aangesloten servo dimt de led op D9/D10 niet | De Servo-bibliotheek gebruikt Timer1 | Verplaats de led naar D3, D5, D6 of D11 |
De Arduino Nano is de makkelijkste manier om alles wat je op de Uno hebt geleerd mee te nemen naar kleine, vaste projecten; zolang je de verschillen rond A6/A7, 3V3 en de bootloader kent, kom je niet voor verrassingen te staan. Wil je terug naar de basis, begin dan met Wat is Arduino?. In de BlueGrays-app vind je stap-voor-stapprojecten met schakelschema's en kant-en-klare code voor een knipperende led, een led met een knop, licht meten met een LDR, afstand met de HC-SR04, temperatuur en luchtvochtigheid met de DHT11, een RGB-led, een servo met een potentiometer en seriële communicatie tussen twee Arduino's; ze werken allemaal op de Nano met dezelfde pinnummers.
Veelgestelde vragen
Hoeveel pins heeft een Arduino Nano?
De klassieke Arduino Nano heeft 30 pins in twee rijen. Daarvan zijn er 14 digitale in-/uitgangen (D0–D13), 8 analoge ingangen (A0–A7) en de rest zijn VIN, 5V, 3V3, AREF, twee GND- en twee RST-pins. Omdat A0–A5 ook als digitale pins kunnen worden gebruikt, heb je 20 digitale pins; A6 en A7 kunnen alleen analoge waarden lezen.
Welke pins zijn PWM op de Arduino Nano?
De PWM-pins zijn D3, D5, D6, D9, D10 en D11; op het board of in pinoutdiagrammen zijn ze gemarkeerd met een ~ naast het nummer. D5 en D6 werken op ongeveer 980 Hz, de andere op ongeveer 490 Hz. De Servo-bibliotheek beïnvloedt PWM op D9 en D10 en de functie tone() beïnvloedt D3 en D11.
Kunnen A6 en A7 op de Arduino Nano als digitale pins worden gebruikt?
Nee. A6 en A7 zijn twee kanalen van de ATmega328P die alleen met de analoog-digitaalomzetter zijn verbonden; pinMode, digitalRead, digitalWrite en de interne pull-up werken niet op deze pins. Om een knop te lezen, voeg je een externe pull-upweerstand van 10 kΩ toe en vergelijk je de waarde van analogRead() met een drempel. Op de Nano Every en Nano ESP32 kunnen A6 en A7 echter ook als digitale pins worden gebruikt.
Welke spanning mag ik op een Arduino Nano zetten?
Je kunt de Nano voeden via USB, met 7–12 V op de VIN-pin of met geregelde 5 V op de 5V-pin. De AMS1117-regelaar op clone-boards kan boven 15 V kapotgaan en wordt zelfs bij 12 V snel heet, dus 7–9 V is ideaal voor VIN. Zet nooit meer dan 5 V op de 5V-pin.
Wat betekent Old Bootloader op de Arduino Nano?
In 2018 verving Arduino de bootloader van de Nano door de kleinere, snellere Optiboot; de nieuwe bootloader communiceert met 115200 baud en de oude met 57600 baud. De meeste clone-Nano's op de markt hebben nog de oude bootloader, dus als je onder Tools › Processor niet ATmega328P (Old Bootloader) kiest, stopt het uploaden met de fout not in sync. Het kiezen van de verkeerde optie doet het board geen kwaad, dus je kunt gewoon beide proberen.
Wat is het verschil tussen de Arduino Nano en Uno?
Beide gebruiken een ATmega328P op 16 MHz, dus de pinnummers, PWM-pins, I2C-lijnen (A4/A5), SPI-lijnen (D10–D13) en de code zijn hetzelfde. De Nano is kleiner, past in een breadboard en heeft twee extra analoge ingangen (A6, A7), maar hij heeft geen DC-aansluiting en geen shieldheaders. De Nano gebruikt ook mini-USB en de IDE geeft hem 30.720 bytes voor code, terwijl de limiet van de Uno 32.256 bytes is.
Projecten om hierna te bouwen
Alle projecten bekijken
LED laten knipperen
De allereerste hallo van de elektronica: één LED aan- en uitzetten. De Arduino zet de LED met korte tussenpozen aan en uit, zodat het licht snel knippert.

LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Afstand meten met HC-SR04 (Serial-weergave)
De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Een RGB-led gebruiken
In één enkele led zitten drie kleuren verstopt: de RGB-led licht eerst rood op, dan groen, dan blauw, elke kleur een halve seconde aan en een halve seconde uit, waarna de cyclus opnieuw begint.

Servomotor aansturen met een potentiometer
Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

Eenrichtingscommunicatie tussen 2 Arduino's
Je laat twee Arduino's met elkaar praten via één draad: druk op de knop van de ene en de led van de andere gaat aan, druk nog een keer en hij gaat uit.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

