Arduino Nano V3 Einsteiger-Tutorial: Vom ersten Blink zum Sensor-Projekt auf dem Breadboard

Warum ausgerechnet der Nano?

Der UNO R3 ist das klassische Lern-Board, aber sobald ein Projekt vom Steckbrett in ein Gehäuse wandern soll, wird er unhandlich. Der Nano löst das Problem: Er ist gerade einmal 45 × 18 mm groß, hat zwei Pin-Reihen im 2,54-mm-Raster und steckt damit über die Mittelrille eines Breadboards – links und rechts bleibt jeweils eine Kontaktreihe für deine Verkabelung frei. Kein Kabelsalat mit Jumperkabeln zum Board, sondern ein kompakter Aufbau, den du am Ende einfach so auf eine Lochrasterplatine löten kannst.

Der hier verwendete Nano nutzt einen USB-C-Anschluss und den CH340-USB-Seriell-Chip. Das ist wichtig zu wissen, denn genau dieser Chip braucht unter Umständen einen eigenen Treiber – dazu später mehr im Troubleshooting.

Das Pinout in 2 Minuten

Damit du dich beim Verkabeln nicht verzählst, hier die wichtigsten Pin-Gruppen des Nano:

Was du brauchst

Arduino IDE einrichten

1. 1Arduino IDE 2.x installieren und starten. Kein Zusatz-Boardpaket nötig – der Nano ist bereits an Bord.
2. 2Board auswählen: Werkzeuge → Board → Arduino AVR Boards → Arduino Nano.
3. 3Prozessor einstellen: Bei den meisten aktuellen Nano-Klonen funktioniert ATmega328P (Old Bootloader), wenn der normale Upload scheitert. Erst normalen Modus probieren, dann umstellen.
4. 4Port wählen: Unter Werkzeuge → Port den COM-Port (Windows) bzw. /dev/ttyUSB* (Linux/Mac) auswählen, der beim Einstecken neu erscheint.

Code 1: Blink – das Hallo-Welt der Elektronik

Der Nano hat eine On-Board-LED an Pin 13. Der klassische erste Sketch lässt sie im Sekundentakt blinken – und beweist, dass Board, Kabel und Treiber zusammenspielen.

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);   // Pin 13 = eingebaute LED
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // LED an
  delay(1000);                       // 1 Sekunde warten
  digitalWrite(LED_BUILTIN, LOW);    // LED aus
  delay(1000);
}

Klick auf den Upload-Pfeil. Blinkt die LED, hast du die halbe Miete. Jetzt bauen wir eine externe LED aufs Breadboard – mit dem richtigen Vorwiderstand.

Code 2: Externe LED + der richtige Vorwiderstand

Eine LED darf nie direkt an einen Pin – sie zieht sonst zu viel Strom und stirbt. Ein Vorwiderstand begrenzt den Strom. Die Faustformel nach dem Ohmschen Gesetz:

R = (U_quelle - U_LED) / I_LED

Beispiel rote LED an 5V:
R = (5 V - 2,0 V) / 0,015 A = 200 Ohm

-> naechster Normwert: 220 Ohm (gelb-violett-braun)

Verkabelung: Pin D9 → 220-Ω-Widerstand → lange LED-Beinchen (Anode, +) → kurzes Beinchen (Kathode, −) → GND. Dann dieser Sketch, der die LED sanft auf- und abdimmt (PWM):

const int ledPin = 9;   // PWM-faehiger Pin (~)

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // langsam heller
  for (int hell = 0; hell <= 255; hell++) {
    analogWrite(ledPin, hell);
    delay(6);
  }
  // langsam dunkler
  for (int hell = 255; hell >= 0; hell--) {
    analogWrite(ledPin, hell);
    delay(6);
  }
}

Code 3: Taster einlesen – mit sauberer Entprellung

Mechanische Taster „prellen“: Beim Drücken flackert der Kontakt mikrosekundenschnell zwischen an und aus. Ohne Gegenmaßnahme zählt der Nano einen Druck als fünf. Die Lösung ist eine Software-Entprellung. Verkabele einen Taster zwischen D2 und GND – den internen Pullup aktivieren wir per Code, ein externer Widerstand ist nicht nötig.

const int tasterPin = 2;
const int ledPin = 13;

bool ledAn = false;
int letzterStand = HIGH;
unsigned long letzteAenderung = 0;
const unsigned long entprellZeit = 50;   // Millisekunden

void setup() {
  pinMode(tasterPin, INPUT_PULLUP);   // interner Pullup
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int stand = digitalRead(tasterPin);

  if (stand != letzterStand) {
    letzteAenderung = millis();   // Zeitpunkt merken
  }

  if (millis() - letzteAenderung > entprellZeit) {
    // Signal ist stabil -> nur auf gedrueckten Flankenwechsel reagieren
    static int stabilerStand = HIGH;
    if (stand != stabilerStand) {
      stabilerStand = stand;
      if (stand == LOW) {          // Taster gedrueckt (gegen GND)
        ledAn = !ledAn;            // umschalten
        digitalWrite(ledPin, ledAn);
        Serial.println(ledAn ? "LED an" : "LED aus");
      }
    }
  }
  letzterStand = stand;
}

Öffne den seriellen Monitor (9600 Baud) und drücke den Taster – die LED schaltet bei jedem Druck sauber um, ohne Mehrfachauslösungen.

Code 4: HC-SR04 Ultraschall-Abstandsmesser

Jetzt ein echter Sensor. Der HC-SR04 misst Entfernungen von 2 cm bis rund 4 m, indem er einen Ultraschall-Impuls aussendet und die Zeit bis zum Echo stoppt. Verkabelung:

const int trigPin = 9;
const int echoPin = 10;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
}

float messeAbstandCm() {
  // sauberer 10-us-Trigger-Impuls
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Echo-Laufzeit messen (Timeout 30 ms = ~5 m)
  long dauer = pulseIn(echoPin, HIGH, 30000);
  if (dauer == 0) return -1;          // kein Echo
  return dauer * 0.0343 / 2.0;        // Schallgeschwindigkeit
}

void loop() {
  float abstand = messeAbstandCm();
  if (abstand < 0) {
    Serial.println("Kein Echo (zu weit oder zu schraeg)");
  } else {
    Serial.print("Abstand: ");
    Serial.print(abstand, 1);
    Serial.println(" cm");
  }
  delay(200);
}

Code 5: DHT22 Temperatur-Logger

Zum Abschluss messen wir Temperatur und Luftfeuchte mit dem präzisen DHT22 (AM2302). Installiere über den Bibliotheksverwalter die Bibliotheken DHT sensor library und Adafruit Unified Sensor von Adafruit. Verkabelung: VCC → 5V, GND → GND, DATA → D4. Zwischen DATA und VCC gehört ein 10-kΩ-Pullup-Widerstand (bei vielen Modulen bereits aufgelötet).

#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
  Serial.println("Zeit(s)\tTemp(C)\tFeuchte(%)");
}

void loop() {
  float temp = dht.readTemperature();
  float feuchte = dht.readHumidity();

  if (isnan(temp) || isnan(feuchte)) {
    Serial.println("Lesefehler am DHT22!");
  } else {
    Serial.print(millis() / 1000);
    Serial.print("\t");
    Serial.print(temp, 1);
    Serial.print("\t");
    Serial.println(feuchte, 1);
  }
  delay(2000);   // DHT22: max. alle 2 s messen
}

Die Ausgabe ist bewusst als Tabelle mit Tabs formatiert – so kannst du sie im seriellen Monitor mitlesen oder über den Micro-SD-Kartenleser dauerhaft als CSV mitschreiben.

Troubleshooting