Arduino Nano Pinbelegung: A6/A7, Stromversorgung und Bootloader

Die Arduino Nano Pinbelegung umfasst 30 Pins an den beiden langen Kanten der 45 × 18 mm großen Platine: 14 digitale Ein-/Ausgänge (D0–D13), von denen 6 PWM ausgeben können (~3, 5, 6, 9, 10, 11), 8 analoge Eingänge (A0–A7) sowie die Versorgungs- und Steuerpins VIN, 5V, 3V3, AREF, zweimal GND und zweimal RST. Da der Nano denselben ATmega328P wie der Arduino Uno verwendet, sind auch Pinnummern und Funktionen gleich: Ein Sketch für den Uno läuft ohne jede Änderung, du musst nur im Board-Menü den Nano auswählen.

Trotzdem gibt es ein paar wichtige Unterschiede zum Uno, und genau dort bleiben Einsteiger hängen: A6 und A7 sind nur analog nutzbar, es gibt keine DC-Buchse, der 3V3-Pin liefert sehr wenig Strom, bei Klonen übernimmt ein CH340 den USB-Teil, und zum Hochladen musst du oft ATmega328P (Old Bootloader) auswählen. In dieser Anleitung lernst du jeden Pin kennen, erfährst, wie du den Nano richtig aufs Breadboard steckst, siehst die Pin-Zuordnung zum Uno und erfährst, worin sich Nano Every und Nano ESP32 vom klassischen Nano unterscheiden.

Was ist der Arduino Nano und was unterscheidet ihn vom Uno?

Der Arduino Nano bringt alle Grundfunktionen des Uno auf einer Platine von 45 × 18 mm und rund 7 Gramm unter. Seine Pins zeigen nach unten, deshalb steckt er direkt im Breadboard; das spart Jumperkabel, und die fertige Schaltung wandert leicht in ein Gehäuse oder auf eine dauerhafte Platine. Im Inneren arbeitet derselbe ATmega328P mit 16 MHz wie beim Uno, der Logikpegel beträgt 5 V und dieselben Bibliotheken funktionieren unverändert. Beim Original-Nano erledigt ein FT232RL die USB-Seriell-Kommunikation; fast alle günstigen Klone auf dem Markt haben stattdessen einen CH340G oder CH340C auf der Unterseite. Für Roboterautos, Wearables, Fernbedienungen und jede Schaltung, die in ein Gehäuse passen muss, ist der Nano praktischer als der Uno.

Arduino Nano Pinout: Welcher Pin liegt wo?

Die 30 Pins des Nano sind in zwei gegenüberliegenden Reihen zu je 15 Pins angeordnet, der Abstand zwischen den Reihen beträgt 15,24 mm (0,6 Zoll). Legst du die Platine so vor dich, dass die Mini-USB-Buchse zu dir zeigt, siehst du direkt neben der Buchse zwei gegenüberliegende Pins: D12 und D13. In der Reihe mit D13 liegen 3V3, AREF, A0–A7 und die Versorgungspins; in der Reihe mit D12 folgen die digitalen Pins von D11 bis D2, danach GND, RST, RX0 (D0) und TX1 (D1). Am von USB am weitesten entfernten Ende stehen sich VIN und TX1 gegenüber, und dort sitzt auch der 2×3-ICSP-Header. Rund um den Reset-Taster in der Mitte findest du die Power-LED (POW oder ON), die an D13 angeschlossene L-LED sowie die TX- und RX-LEDs, die beim Hochladen flackern.

Digitale Pins (D0–D13), PWM und Sonderfunktionen

Jeder digitale Pin wird mit pinMode() als Eingang oder Ausgang festgelegt; als Ausgang liefert HIGH etwa 5 V und LOW 0 V. Damit ein Eingang nicht in der Luft hängt, kannst du mit INPUT_PULLUP den internen 20–50-kΩ-Widerstand des Chips einschalten. Der sichere Strom pro Pin liegt bei 20 mA; eine rote LED mit 220-Ω-Widerstand zieht etwa 13 mA, den passenden Widerstand findest du mit dem LED-Vorwiderstandsrechner. Einige Pins haben Zusatzfunktionen, und wenn du sie vorher kennst, vermeidest du Konflikte, sobald dein Projekt wächst:

Ein kleines, aber wichtiges Detail, das den Nano vom Uno unterscheidet, betrifft D13. Beim Uno R3 wird die L-LED über einen Operationsverstärker angesteuert, beim Nano hängen LED und Widerstand direkt am Pin. Nutzt du D13 mit INPUT_PULLUP als Tastereingang, zieht die LED den Pin nach unten, und du liest womöglich LOW, obwohl der Taster nicht gedrückt ist; nutze diesen Pin lieber als Ausgang oder für SPI. Wie PWM funktioniert und was die Werte von analogWrite() bedeuten, erfährst du in Was ist PWM?, Interrupts in Arduino Interrupts.

Analoge Pins A0–A7: Warum sind A6 und A7 anders?

Die acht analogen Eingänge des Nano messen Spannungen zwischen 0 und 5 V mit 10 Bit Auflösung: analogRead() liefert eine Zahl von 0 bis 1023, ein Schritt entspricht etwa 4,9 mV. A0–A5 lassen sich bei Bedarf auch als normale digitale Pins nutzen (A0 = 14 … A5 = 19), und A4 und A5 sind zugleich SDA und SCL des I2C-Busses. A6 und A7, die der Uno nicht hat, sind zwei zusätzliche ADC-Kanäle, die es nur im SMD-Gehäuse (TQFP) des ATmega328P gibt. Diese beiden Kanäle sind ausschließlich mit dem Analog-Digital-Wandler verbunden; dahinter gibt es kein Port-Register, keinen Ausgangstreiber und keinen Pull-up-Widerstand. Deshalb funktionieren pinMode(), digitalRead(), digitalWrite() und INPUT_PULLUP an diesen beiden Pins nicht.

Dass A6 und A7 nur analog arbeiten, wirkt wie ein Nachteil, lässt sich aber geschickt nutzen. Schließt du mehrere Taster über unterschiedliche Widerstände an einen Analogpin an, erzeugt jeder Taster eine andere Spannung; so liest du vier Taster mit einem einzigen Pin und hältst die digitalen Pins für Motoren und Displays frei. Verbinde A6 über einen 10-kΩ-Widerstand mit 5V; den ersten Taster schaltest du direkt zwischen A6 und GND, die anderen drei über Widerstände von 2,2 kΩ, 4,7 kΩ und 10 kΩ nach 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}

Die Werte ergeben sich aus der Formel analogRead = 1023 × R / (10 kΩ + R), und jede Schwelle liegt genau in der Mitte zwischen zwei benachbarten Werten. Da Pull-up-Widerstand und ADC an derselben 5-V-Leitung hängen, ändern sich die Messwerte nicht, selbst wenn die Versorgung auf 4,7 V sinkt; man nennt das eine ratiometrische Messung. Drückst du zwei Taster gleichzeitig, liegen ihre Widerstände parallel, und der Messwert sinkt: Der Code erkennt einen Taster mit kleinerer Nummer, bei 3 und 4 zusammen sogar Taster 2. Eine Widerstandsleiter eignet sich deshalb für Menüs, in denen immer nur eine Taste gedrückt wird. Die Rechnung kannst du mit dem Spannungsteiler-Rechner nachvollziehen, mehr über analoge Messungen steht im ADC-Artikel.

Versorgungspins: VIN, 5V, 3V3 und GND

Du kannst den Nano auf drei Wegen versorgen. Über USB kommen die 5 V vom Computer über eine Schottky-Diode; die Diode verliert etwa 0,3 V, deshalb misst du am 5V-Pin meist 4,6–4,8 V, und die MBR0520-Diode auf dem Original ist für höchstens 500 mA ausgelegt. Legst du 7–12 V an VIN, senkt der Spannungsregler auf der Unterseite (beim Original ein LM1117, bei Klonen meist ein AMS1117) sie auf 5 V. Der Regler verwandelt die überschüssige Spannung in Wärme: Die Verlustleistung beträgt (VIN − 5 V) × Strom; ziehst du also bei 12 V Eingang 150 mA, verheizt der kleine Regler etwa 1 W und wird zu heiß zum Anfassen. Deshalb sind 7–9 V an VIN ideal. Der dritte Weg ist, geregelte 5 V von außen in den 5V-Pin einzuspeisen; dann ist der Regler außen vor, und die Diode auf der USB-Seite verhindert, dass Strom in deinen Computer zurückfließt. Wenn du an einem 12-V-Netzteil arbeitest, ist es viel kühler, mit einem LM2596-Abwärtswandler 5 V zu erzeugen und in den 5V-Pin einzuspeisen; alle Versorgungsvarianten findest du in Arduino richtig mit Strom versorgen.

Der 3V3-Pin ist der am häufigsten missverstandene Pin des Nano. Beim Uno kommt dieser Pin von einem eigenen Regler, der klassische Nano hat dagegen keinen eigenen 3,3-V-Regler. Beim Original-Nano stammen die 3,3 V von einem kleinen Regler im FT232RL (höchstens 50 mA), und laut Arduinos älterer Dokumentation steht dieser Ausgang nicht zur Verfügung, wenn das Board nicht über USB versorgt wird. Bei den meisten Klonen hängt der Pin am internen Regler des CH340 und ist nur für Lasten von wenigen mA sicher. Versorge 3,3-V-Module wie nRF24L01, ESP-01 oder RC522 deshalb nicht über diesen Pin, sondern nimm einen separaten AMS1117-3.3-Regler, der aus dem 5V-Pin gespeist wird. Und wenn du einen 5-V-Ausgang des Nano mit dem Eingang eines 3,3-V-Moduls verbindest, setze einen Pegelwandler oder einen Spannungsteiler dazwischen.

Dass der 5V-Pin an USB bei etwa 4,7 V liegt, beeinflusst auch analoge Messungen: analogRead() nutzt die Versorgungsspannung als Obergrenze, und wenn du in der Rechnung 5,0 V einsetzt, liegt das Ergebnis um 4–6 Prozent daneben. Die tatsächliche Versorgungsspannung lässt sich berechnen, indem du die interne, feste Referenz des ATmega328P von etwa 1,1 V misst. Der erste Test-Sketch unten macht genau das, rechnet alle acht analogen Eingänge mit der echten Versorgungsspannung in Volt um und lässt die L-LED an D13 blinken:

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}

Öffne nach dem Hochladen den seriellen Monitor mit 9600 Baud. Der Vcc-Wert sollte an USB bei etwa 4600–4800 mV liegen und bei Versorgung über VIN bei rund 5000 mV. Unbeschaltete Analogpins zeigen zufällige Werte; schließt du ein Potentiometer an A0 an und drehst daran, ändert sich der Wert gleichmäßig zwischen 0 und Vcc. Die interne Referenz kann von Chip zu Chip um ±10 % abweichen; für ein genaueres Ergebnis misst du den 5V-Pin mit einem Multimeter und multiplizierst die Konstante 1125300 im Code mit dem Verhältnis gemessener Wert / vom Code angezeigter Wert. Weil dieser Sketch die Register des ATmega328P direkt nutzt, läuft er nicht auf dem Nano Every oder dem Nano ESP32.

Mini-USB, CH340 und Treiberinstallation

Der klassische Nano hat eine Mini-B-USB-Buchse; die Micro-USB- oder USB-C-Kabel von Handys passen nicht. Manche neueren Klone haben Micro-USB- oder USB-C-Buchsen, die meisten aber weiterhin Mini-USB. Der häufigste Grund, warum das Board gar nicht in der Portliste erscheint, sind reine Ladekabel ohne Datenleitungen: Die Power-LED leuchtet, aber der Computer sieht das Board nicht. Ist das Kabel in Ordnung, dreh das Board um und sieh dir den Chip neben der USB-Buchse an. Steht dort FT232RL, hast du einen Original-Nano, dessen Treiber meist schon im Betriebssystem steckt; steht dort CH340G oder CH340C, hast du einen Klon.

Windows 10 und 11 installieren den CH340-Treiber oft selbst über Windows Update, und das Board erscheint im Geräte-Manager unter einem Namen wie USB-SERIAL CH340 (COM3). Siehst du unter Andere Geräte ein USB2.0-Serial mit gelbem Ausrufezeichen, installiere den CH341SER-Treiber des Chipherstellers WCH und steck das Board neu ein. Aktuelle macOS-Versionen bringen den Treiber mit; der Port heißt /dev/cu.usbserial-…, und zusätzlich installierte alte Treiber können Konflikte verursachen. Unter Linux steckt der Treiber im Kernel; verschwindet der Port unter Ubuntu 22.04 oder neuer gleich nach dem Einstecken, schnappt sich das Screenreader-Paket brltty den CH340, und wenn du es nicht brauchst, entfernst du es mit sudo apt remove brltty. Alle Port- und Treiberprobleme behandelt Arduino Sketch lässt sich nicht hochladen, die Unterschiede der USB-Seriell-Chips USB-TTL-Wandler.

Code hochladen: ATmega328P oder Old Bootloader?

1. Wähle in der Arduino IDE Werkzeuge > Board > Arduino AVR Boards > Arduino Nano.
2. Steck das Board ein und wähle unter Werkzeuge > Port den neu erschienenen Port (etwa COM3 unter Windows oder /dev/cu.usbserial-… unter macOS).
3. Versuche unter Werkzeuge > Processor zuerst, das Blink-Beispiel mit der Option ATmega328P hochzuladen.
4. Wiederholt die Ausgabe zehn Versuche lang programmer is not responding oder not in sync, stell Processor auf ATmega328P (Old Bootloader) und lade erneut hoch.
5. Klappt es immer noch nicht, nimm einen anderen USB-Port, entferne die Kabel an D0 und D1 und prüfe, ob die L-LED beim Drücken des Reset-Tasters kurz schnell blinkt.
6. Notiere dir, welche Option funktioniert hat; andere Nanos vom selben Händler brauchen sehr wahrscheinlich dieselbe Einstellung.

Der Grund für dieses Durcheinander ist eine Änderung aus dem Jahr 2018. Arduino ersetzte den alten 2-KB-Bootloader (ATmegaBOOT) des Nano durch den nur 512 Byte großen Optiboot des Uno. Optiboot empfängt Code mit 115200 Baud, der alte Bootloader erwartet 57600 Baud; passen die Geschwindigkeiten nicht zusammen, scheint das Board gar nicht zu antworten. Weil Klonhersteller noch jahrelang Boards mit dem alten Bootloader auslieferten, bietet die IDE beide Optionen an, und eine falsche Wahl schadet dem Board nicht. Wenn du willst, kannst du einen zweiten Arduino als ArduinoISP nutzen und den neuen Bootloader auf den Nano brennen: Uploads werden schneller, und auch die Endlos-Reset-Schleife des alten Bootloaders nach einem Watchdog-Reset verschwindet.

Platzierung auf dem Breadboard und Löten

Stecke den Nano so ins Breadboard, dass die beiden Pinreihen links und rechts des Mittelkanals sitzen. So landet jeder Pin in seinem eigenen Streifen, und du kannst über die freien Löcher des Streifens Kabel an diesen Pin anschließen. Da die Platine den Kanal und die Löcher zwischen den Pins abdeckt, bleiben neben jedem Pin nur wenige Löcher frei; bei üblichen Breadboards mit 830 Kontakten bleiben, wenn du das Board mittig über den Kanal setzt, auf einer Seite 2 und auf der anderen 3 Löcher frei. Zeigt die USB-Buchse zur kurzen Kante des Breadboards, lässt sich das Kabel bequem einstecken. Verbinde dann 5V und GND des Nano mit der roten und der blauen Versorgungsschiene des Breadboards, damit du von dort Sensoren versorgen kannst. Wie ein Breadboard innen verbunden ist, liest du in Was ist ein Breadboard? nach.

• Stiftleisten anlöten: Bei Klonen mit losen Stiftleisten steckst du die Leisten zuerst ins Breadboard, legst den Nano darauf und lötest ihn so fest; das Breadboard hält die Leisten gerade und genau 0,6 Zoll auseinander. Die Technik findest du in Richtig löten.
• Herausziehen: Wer die Platine an einem Ende anhebt, verbiegt die Pins; heb beide Enden abwechselnd ein Stück an oder schieb einen flachen Schraubendreher darunter und zieh sie gleichmäßig heraus.
• Wackelkontakte: Bei alten oder billigen Breadboards leiern die Federn aus; der Nano startet hin und wieder neu oder ein Sensor fällt zeitweise aus. Setz das Board probeweise auf einen anderen Bereich des Breadboards.
• Nano-Erweiterungsboard: In einem dauerhaften Projekt reduziert ein Nano-I/O-Shield mit Schraubklemmen oder 3-poligen Steckern, das für jeden Pin Signal, 5V und GND bereitstellt, das Kabelchaos enorm.
• Mini-Breadboard: Kleine Breadboards mit 170 Kontakten haben keine Versorgungsschienen; leg 5V und GND auf eigene Streifen und markiere sie mit Kabelfarben.

Pin-Zuordnung zwischen Arduino Uno und Nano

Wie die Tabelle zeigt, musst du beim Umzug einer Uno-Schaltung auf den Nano nur die Kabel an die Pins mit denselben Nummern stecken: Ein Servo an D9 des Uno kommt beim Nano ebenfalls an D9, ein I2C-Display an A4/A5 bleibt an A4/A5. Die einzige Änderung im Code ist die Auswahl von Arduino Nano unter Werkzeuge > Board. Shields, die direkt auf den Uno passen, lassen sich allerdings nicht auf den Nano stecken; dafür gibt es Adapterplatinen, die den Nano auf das Uno-Layout bringen. Die genaue Rolle jedes Pins am Uno findest du in Arduino Uno Pinbelegung, Hilfe bei der Boardwahl in Welchen Arduino soll ich kaufen?.

Nano Every und Nano ESP32: Unterschiede zum klassischen Nano

Der Nano Every ist eine leistungsstärkere Version des klassischen Nano in gleicher Größe und mit gleicher Pinbelegung. In ihm steckt ein ATmega4809, er läuft mit 5 V und bietet 48 KB Flash und 6 KB SRAM; OLED- und LED-Streifen-Projekte, die beim klassischen Nano am RAM scheitern, bekommen also Luft. Auf der USB-Seite arbeitet ein SAMD11 als Brücke, und der Code wird über die UPDI-Schnittstelle hochgeladen, deshalb gibt es keinen Ärger mit dem Old Bootloader. Um das Board zu nutzen, installierst du im Boardverwalter das Paket Arduino megaAVR Boards. Diese Unterschiede solltest du kennen: PWM gibt es nur an D3, D5, D6, D9 und D10 (D11 hat kein PWM), A6 und A7 funktionieren auch digital, jeder digitale Pin kann als externer Interrupt dienen, und D0 und D1 bilden einen von USB unabhängigen Serial1-Port. Die Einstellung Werkzeuge > Registers emulation > ATMEGA328 emuliert Port-Register wie PORTB, aber alter Code, der direkt in Timer- oder ADC-Register schreibt, läuft trotzdem nicht. Der Sketch unten zeigt zwei Besonderheiten des Every auf einmal: Er spricht bei geöffnetem seriellen Monitor mit einem Modul an D0/D1 und nutzt A7 als Tastereingang mit internem 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}

Der Nano ESP32 dagegen ist im selben Format eine ganz andere Welt: Der ESP32-S3 im u-blox-Modul NORA-W106 läuft mit 240 MHz und bietet WLAN und Bluetooth LE. Der wichtigste Unterschied ist die Spannung: Alle Pins arbeiten mit 3,3 V und sind nicht 5-V-tolerant; ein Sensor mit 5-V-Ausgang, den du direkt an einen klassischen Nano hängen würdest, kann den Nano ESP32 beschädigen. Wo der klassische Nano seinen 5V-Pin hat, sitzt ein VBUS-Pin, der nur dann 5 V liefert, wenn das Board über USB versorgt wird; bei Versorgung über VIN bleibt dieser Pin tot. Anstelle von AREF und dem RST-Pin auf der Analogseite findest du BOOT0 und BOOT1. Programmiert wird das Board mit dem Paket Arduino ESP32 Boards, und das Menü Werkzeuge > Pin Numbering bietet zwei Optionen: In der Standardeinstellung By Arduino pin gelten die aufgedruckten D- und A-Namen, bei By GPIO number sind die Zahlen die GPIO-Nummern des ESP32. D2 ist zum Beispiel eigentlich GPIO5; im GPIO-Modus konfigurierst du mit pinMode(2, OUTPUT) stattdessen den Pin A1. Wenn du Pins immer mit Namen wie D2 und A0 schreibst, funktioniert dein Code in beiden Modi richtig.

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}

Die analogen Eingänge des Nano ESP32 messen mit 12 Bit und liefern Werte von 0 bis 4095, während analogReadMilliVolts() mithilfe der Kalibrierdaten des Chips das Ergebnis direkt in Millivolt ausgibt. Die RGB-LED auf der Platine arbeitet mit invertierter Logik, sie leuchtet also, wenn du LOW schreibst. Lässt sich kein Code hochladen und verschwindet das Board aus der Portliste, bringst du es in den Bootloader-Modus, indem du den Reset-Taster zweimal schnell hintereinander drückst. Mehr über die WLAN-Seite des ESP32 erfährst du in Was ist der ESP32?, bei der Boardwahl hilft Arduino oder ESP32?. Von den übrigen Familienmitgliedern bringt der Nano R4 denselben Renesas RA4M1 mit 48 MHz wie der Uno R4 ins 5-V-Nano-Format, liefert aber nur 8 mA pro Pin, während Nano 33 IoT und Nano 33 BLE wie der Nano ESP32 mit 3,3 V arbeiten.

Projektideen mit dem Arduino Nano

• Taschenthermometer: Zeig die mit einem DHT11 gemessene Temperatur auf einem kleinen OLED-Display an; Nano und Display passen in eine Streichholzschachtel.
• Mini-Roboterauto: Die geringe Größe des Nano spart Platz auf dem Chassis; steuere die Motoren mit einem L298N und folge den Schritten in Roboterauto bauen.
• Linienfolger: Acht analoge Eingänge reichen locker, um eine Leiste mit fünf Sensoren auszulesen; Details stehen in Linienfolger-Roboter.
• Bluetooth-Fernbedienung: Schließ ein HC-05-Modul per SoftwareSerial an D8 und D7 an und steuere eine LED oder ein Relais mit dem Handy; D0 und D1 bleiben fürs Hochladen frei.
• Licht zum Anziehen: Bau mit einem batteriebetriebenen Nano und ein paar WS2812B-LEDs ein leuchtendes Namensschild oder ein Licht für die Tasche.
• Tastenfeld an einem Pin: Bau die Widerstandsleiter von oben an A6 und an A7 auf, erhalte so ein Menü mit acht Tasten und halte die digitalen Pins für Display und Motoren frei.
• Du willst eine USB-Tastatur? Der ATmega328P des klassischen Nano hat kein eingebautes USB und kann sich deshalb nicht als Tastatur oder Maus am Computer anmelden; dafür brauchst du Boards mit ATmega32U4 wie den Leonardo und Pro Micro.

Häufige Fehler und ihre Lösungen

Der Arduino Nano ist der einfachste Weg, alles, was du am Uno gelernt hast, in kleine, dauerhafte Projekte zu bringen; solange du die Besonderheiten bei A6/A7, 3V3 und dem Bootloader kennst, erlebst du keine Überraschungen. Wenn du zu den Grundlagen zurückwillst, fang mit Was ist Arduino? an. In der BlueGrays-App findest du Schritt-für-Schritt-Projekte mit Schaltplänen und fertigem Code: LED blinken lassen, LED mit Taster, Licht messen mit dem LDR, Entfernung mit dem HC-SR04, Temperatur und Luftfeuchtigkeit mit dem DHT11, RGB-LED, Servo mit Potentiometer und serielle Kommunikation zwischen zwei Arduinos; alle funktionieren auf dem Nano mit denselben Pinnummern.