Componenten · 19 min leestijd

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.

Arduino Nano-board en zijn pins
Originele Arduino Nano: de mini-USB-aansluiting aan het ene uiteinde, de 2×3 ICSP-header aan het andere en de resetknop in het midden. De pins D13, 3V3 en AREF zitten aan de USB-kant; VIN en TX1 zitten aan het andere uiteinde.

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.

EigenschapArduino Nano (V3)
MicrocontrollerATmega328P, 8-bit, 16 MHz (TQFP-32-behuizing)
Logische (werk)spanning5 V
Ingangsspanning VIN7–12 V aanbevolen
Digitale in-/uitgang14 pins (D0–D13); 20 inclusief A0–A5
PWM-uitgang6 pins: D3, D5, D6, D9, D10, D11
Analoge ingang8 pins (A0–A7), 10-bit (0–1023)
Stroom per pin20 mA aanbevolen, 40 mA absoluut maximum
Geheugen32 KB flash (30.720 bytes bruikbaar in de IDE), 2 KB SRAM, 1 KB EEPROM
USBMini-B; FT232RL (origineel) of CH340 (clone)
Afmetingen en gewicht45 × 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 voedingsrijDigitale rijOpmerking
1D13 (SCK, L-led)D12 (MISO)Direct naast de USB-aansluiting
23V3~D11 (MOSI)3V3 levert zeer weinig stroom
3AREF~D10 (SS)-
4A0~D9-
5A1D8-
6A2D7-
7A3~D6-
8A4 (SDA)~D5I2C-datalijn
9A5 (SCL)D4I2C-klokliijn
10A6~D3 (INT1)A6 is alleen analoog
11A7D2 (INT0)A7 is alleen analoog
125VGND5V en GND staan tegenover elkaar
13RSTRSTBeide zijn dezelfde resetlijn
14GNDD0 (RX0)D0 is verbonden met de USB-serieel-chip
15VIND1 (TX1)De ICSP-header zit aan dit uiteinde
In handleidingen en schema's worden de pins van de Nano soms in fysieke volgorde van 1 tot 30 genummerd: pin 1 is TX1 (D1) en pin 30 is VIN. Die nummers gebruik je niet in code. In code gebruik je altijd de naam die op het board staat: je schrijft 7 voor D7 en A3 voor A3. Als de labels op het board moeilijk te lezen zijn, houd dan de pindiagramtool open op je telefoon.

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:

PinExtra functieWaar 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, D3Externe interrupts INT0, INT1attachInterrupt() werkt alleen op deze twee pins
~D3, ~D11PWM, Timer2 (ongeveer 490 Hz)PWM op deze pins valt weg zolang tone() speelt
~D5, ~D6PWM, Timer0 (ongeveer 980 Hz)Dezelfde timer als millis() en delay()
~D9, ~D10PWM, Timer1 (ongeveer 490 Hz)De Servo-bibliotheek schakelt PWM op deze twee pins uit
D10–D13SPI: SS, MOSI, MISO, SCKD10 moet een uitgang blijven bij gebruik van SPI
D13Ingebouwde L-ledDe 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.

De compiler klaagt niet over digitalRead(A6), maar het resultaat is betekenisloos en je knop lijkt helemaal niet te werken. Gebruik A6 en A7 voor analoge bronnen zoals een potentiometer, een LDR of een bodemvochtsensor. Wil je een knop aansluiten, voeg dan een externe pull-upweerstand van 10 kΩ toe tussen de pin en 5V en lees hem uit met analogRead(): beschouw de knop als ingedrukt wanneer de waarde onder 300 zakt.

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.

C++ (Arduino IDE)
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}
KnopSerieweerstand naar GNDVerwachte analogReadBereik dat in de code wordt geaccepteerd
Knop 10 Ω (direct)00–91
Knop 22,2 kΩOngeveer 18492–255
Knop 34,7 kΩOngeveer 327256–418
Knop 410 kΩOngeveer 512419–766
Geen-1023767–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

PinWat doet hetLimieten en waarschuwingen
VINVoedt het board met 7–12 V; de regelaar brengt dit terug naar 5 VDe AMS1117 op clones verdraagt maximaal 15 V en wordt bij 12 V snel heet
5VDe 5V-rail van het board: als uitgang voedt hij sensoren, als ingang accepteert hij geregelde 5 VOngeveer 4,7 V via USB; zet er nooit meer dan 5 V van buitenaf op
3V33,3 V-uitgangKomt van de FT232RL op het origineel en van de CH340 op clones; zeer beperkte stroom
GND (2 pins)Gemeenschappelijke massaDe GND van elke externe voeding moet hier worden aangesloten
RST (2 pins)Herstart het board als hij LOW wordt getrokkenVoor een externe resetknop; beide zijn dezelfde lijn
AREFExterne referentie-ingang voor analoge metingenRoep 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.

Een 9 V-batterij of een 12 V-adapter aansluiten op de 5V-pin maakt de Nano direct kapot: deze pin is de uitgang van de regelaar en de ATmega328P verdraagt maximaal 6 V. Sluit batterijen en adapters altijd aan op de VIN-pin. Let ook op de polariteit; de meeste Nano's hebben geen bescherming tegen omgekeerde polariteit op VIN.

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:

C++ (Arduino IDE)
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?

  1. Kies in de Arduino IDE Tools › Board › Arduino AVR Boards › Arduino Nano.
  2. Steek het board in en kies onder Tools › Port de nieuwe poort (zoals COM3 op Windows of /dev/cu.usbserial-… op macOS).
  3. Probeer onder Tools › Processor eerst het voorbeeld Blink te uploaden met de optie ATmega328P.
  4. 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.
  5. 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.
  6. 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.

ProcessoroptieBootloaderUploadsnelheidRuimte voor code
ATmega328POptiboot (sinds 2018)115200 baud30.720 bytes
ATmega328P (Old Bootloader)ATmegaBOOT (oud)57600 baud30.720 bytes
ATmega168ATmegaBOOT (oud)19200 baud14.336 bytes
Voor de Nano meldt de compileruitvoer Maximum is 30720 bytes; met de Uno geselecteerd wordt dezelfde sketch gemeten tegen een limiet van 32.256 bytes. De IDE reserveert op de Nano 2 KB voor compatibiliteit met oudere boards, ook als de nieuwe bootloader is geïnstalleerd. Als je sketch die limiet nadert, verwijder dan ongebruikte bibliotheken en overbodige Serial.print()-regels, vereenvoudig grote tabellen of stap over op de Nano Every met 48 KB flash.

Plaatsing op een breadboard en solderen

Breadboard en zijn middenkanaal
Het kanaal in het midden van een breadboard scheidt de twee helften; als de Nano over dit kanaal heen staat, komt elke pin in zijn eigen strip.

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.
Als je de Nano op gaatjesprint met stroken soldeert, zorg dan dat pins die tegenover elkaar liggen niet op dezelfde koperstrook komen. Als de stroken tussen de twee rijen pins niet zijn doorgesneden, worden 5V en GND op positie 12 en VIN en TX1 op positie 15 aan elkaar kortgesloten en zodra je USB aansluit, worden zowel het board als de poort van je computer belast. Snij de stroken tussen de twee rijen door met een boortje; de details staan in het artikel over de vaste schakeling.

Pinvergelijkingstabel Arduino Uno naar Nano

FunctieArduino Uno R3Arduino NanoOpmerking
Digitale I/OD0–D13D0–D13Dezelfde nummers en functies
PWM~3, 5, 6, 9, 10, 11~3, 5, 6, 9, 10, 11Dezelfde frequenties en timers
Analoge ingangA0–A5A0–A7A6 en A7 bestaan alleen op de Nano en zijn alleen analoog
I2C SDA / SCLA4 / A5 (kopie naast AREF)A4 / A5Geen aparte SDA/SCL-pins op de Nano
SPI SS / MOSI / MISO / SCK10 / 11 / 12 / 1310 / 11 / 12 / 13Beide hebben ze ook op de ICSP-header
Externe interruptsD2, D3D2, D3Hetzelfde
Ingebouwde ledD13 (gebufferd via opamp)D13 (rechtstreeks met de pin verbonden)Wees voorzichtig met D13 als ingang op de Nano
VoedingsingangDC-aansluiting en Vin, 7–12 VAlleen VIN-pin, 7–12 VGeen aansluiting op de Nano
USBUSB-B; ATmega16U2 of CH340Mini-B; FT232RL of CH340Andere kabels
3,3V-uitgangAparte regelaar, 50 mAVan de USB-chip, zeer beperktVoed op de Nano geen modules hiermee
IOREFJaNeeVoor shieldcompatibiliteit
Ruimte voor code32.256 bytes30.720 bytesDe IDE reserveert 2 KB op de Nano
Shields plaatsenDirectMet 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

EigenschapKlassieke Nano (V3)Nano EveryNano ESP32
ProcessorATmega328P, 8-bit, 16 MHzATmega4809, 8-bit, 16 MHz in de IDE (tot 20 MHz)ESP32-S3, dual-core, 32-bit, 240 MHz
Flash / SRAM32 KB / 2 KB48 KB / 6 KB16 MB / 512 KB (+8 MB PSRAM)
Logische spanning5 V5 V3,3 V (niet 5 V-tolerant)
USBMini-BMicro-BUSB-C
VIN-bereik7–12 V aanbevolen7–21 V6–21 V
PWM-pinsD3, D5, D6, D9, D10, D11D3, D5, D6, D9, D10 (niet op D11)Bijna alle digitale pins
A6 / A7Alleen analoogAnaloog en digitaalAnaloog en digitaal
Externe interruptsAlleen D2, D3Alle digitale pinsAlle pins
Seriële lijn D0 / D1Gedeeld met USB (Serial)Los van USB (Serial1)Los van USB (Serial0)
DraadloosGeenGeenWi-Fi en Bluetooth LE
Boardpakket in de IDEArduino AVR BoardsArduino megaAVR BoardsArduino 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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

SymptoomOorzaakOplossing
De Nano verschijnt niet in de poortlijstKabel die alleen oplaadt of ontbrekende CH340-driverGebruik een datakabel, installeer de CH341SER-driver; verwijder brltty op Linux
Het uploaden stopt met de fout "not in sync"Het board heeft de oude bootloaderTools › Processor › ATmega328P (Old Bootloader)
Een knop op A6 of A7 reageert helemaal nietDeze pins hebben geen digitalRead of interne pull-upVoeg een externe pull-up van 10 kΩ toe en gebruik een drempel met analogRead
Een knop op D13 wordt altijd als ingedrukt gelezenDe L-led en zijn weerstand trekken de pin omlaagVerplaats de knop naar een andere pin
Een module die via 3V3 wordt gevoed is instabiel of doodDe 3V3-pin levert zeer weinig stroomGebruik een aparte 3,3 V-regelaar die vanaf 5V wordt gevoed
Analoge metingen zijn een paar procent te hoogVia USB staat de 5V-pin op ongeveer 4,7 VMeet de werkelijke Vcc of voed het board via VIN
Het board wordt erg heet met 12 V op VINDe regelaar voert (12 − 5) × stroom af als warmteZet 7–9 V op VIN of voed de 5V-pin met een stepdownmodule
Met een aangesloten servo dimt de led op D9/D10 nietDe Servo-bibliotheek gebruikt Timer1Verplaats de led naar D3, D5, D6 of D11
Maak voordat je aan een Nano-project begint een pinplan: plaats eerst de onderdelen die I2C (A4/A5), SPI (D10–D13), interrupts (D2/D3) en PWM nodig hebben, verdeel analoge sensoren over A0–A3 en A6–A7, zet knoppen op de resterende digitale pins en bewaar D0 en D1 voor het laatst. Als het board onverwacht herstart, helpen de stappen voor het oplossen van problemen in Arduino blijft resetten.

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.

Alle projecten bekijken
LED laten knipperen
AR-1Beginner

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.

4.6(200)
1246
LED aansturen met een drukknop (Push)
AR-9Beginner

LED aansturen met een drukknop (Push)

Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

4.8(114)
253
Lichtsterkte meten met een LDR
AR-11Beginner

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.

4.6(83)
143
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

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.

4.6(50)
82
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

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…

4.7(47)
83
Een RGB-led gebruiken
AR-39Beginner
Premium

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.

4.9(73)
100
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

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.

4.6(37)
53
Eenrichtingscommunicatie tussen 2 Arduino's
AR-57Gemiddeld
Premium

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.

4.4(37)
50