Arduino UNO R3 Einsteiger-Tutorial: Dein erstes Projekt

Warum der Arduino UNO R3 der perfekte Einstieg ist

Die Welt der Mikrocontroller kann einschüchternd wirken. ESP32, STM32, Raspberry Pi Pico, Nano, Mega – die Auswahl ist riesig, und jede Plattform hat ihre Eigenheiten. Genau deshalb ist der Arduino UNO R3 seit über einem Jahrzehnt der Goldstandard für Einsteiger. Hier sind die Gründe:

Im Vergleich zum kleineren Nano V3 punktet der UNO R3 vor allem durch die bessere Zugänglichkeit: Die Pins sind beschriftet, die Buchsenleisten nehmen handelsübliche Jumper-Kabel auf, und das Breadboard-Layout ist Standard. Du musst nicht löten und kannst jede Schaltung in Sekunden umbauen. Und falls doch mal was schiefgeht: Der austauschbare ATmega328P im DIP-Gehäuse lässt sich bei einem Defekt einfach tauschen – bei SMD-Boards undenkbar.

Unser UNO R3 Entwicklungsboard mit USB-C ist vollständig Arduino-IDE-kompatibel, wird per CH340-Treiber erkannt und kostet einen Bruchteil des Originals – bei identischer Funktion.

Was du für dieses Tutorial brauchst

Hier ist die Einkaufsliste. Alle Teile findest du direkt bei makeroo – so sparst du Versand und bekommst alles aus einer Hand.

Zusätzlich brauchst du ein USB-C-Kabel (Datenkabel, kein reines Ladekabel!) und einen Computer mit installierter Arduino IDE. Die IDE ist kostenlos unter arduino.cc/en/software erhältlich. Installation: Herunterladen, starten, fertig.

Vorbereitung: Arduino IDE einrichten

Bevor wir die erste LED zum Blinken bringen, muss die Entwicklungsumgebung laufen. Das ist in 5 Minuten erledigt:

1. Arduino IDE installieren: Von arduino.cc herunterladen und installieren. Fertig.
2. UNO R3 per USB-C verbinden: Das Board wird mit Strom versorgt – die grüne Power-LED leuchtet. Windows erkennt das Board automatisch und installiert den CH340-Treiber. Falls nicht: CH340-Treiber einmalig von der Herstellerseite laden.
3. Board und Port auswählen: In der IDE oben auf Tools → Board → Arduino Uno stellen. Dann Tools → Port – den COM-Port (Windows) bzw. /dev/ttyUSB0 (Linux/Mac) auswählen, der auftaucht, sobald das Board verbunden ist.
4. Test mit Blink-Beispiel: Datei → Beispiele → 01.Basics → Blink öffnen und auf den Pfeil (Upload) klicken. Wenn die onboard-LED (Pin 13) nach ein paar Sekunden blinkt, ist alles bereit.

Projekt 1: LED blinken lassen – Dein „Hello World"

Das erste Programm in jeder neuen Programmiersprache ist „Hello World". In der Welt der Mikrocontroller ist es die blinkende LED. Dieses Projekt zeigt dir die absoluten Grundlagen: Digitaler Ausgang, pinMode(), digitalWrite() und delay().

Schaltungsaufbau

Der Aufbau ist simpel und benötigt nur drei Teile:

Aufbau auf dem Breadboard: Stecke das UNO Board so in die obere Hälfte des Breadboards, dass die Pin-Leisten beidseitig erreichbar sind. Verbinde Pin 13 über einen 220Ω Widerstand (rot-rot-braun) mit der Anode (langes Bein) der LED. Die Kathode (kurzes Bein) kommt direkt auf die GND-Schiene des Breadboards, die du mit einem Jumper-Kabel mit einem GND-Pin des UNO verbindest.

Der Code

Kopiere diesen Code in die Arduino IDE und lade ihn auf dein Board:

// Projekt 1: LED blinken lassen
// Schaltung: Pin 13 → 220Ω Widerstand → LED (Anode)
// LED Kathode → GND

void setup() {
  pinMode(13, OUTPUT);  // Pin 13 als Ausgang definieren
}

void loop() {
  digitalWrite(13, HIGH);  // LED einschalten
  delay(1000);             // 1000 Millisekunden = 1 Sekunde warten
  digitalWrite(13, LOW);   // LED ausschalten
  delay(1000);             // 1 Sekunde warten
}

So funktioniert's

Jedes Arduino-Programm besteht aus zwei Funktionen: setup() läuft genau einmal beim Start. Hier konfigurieren wir Pin 13 als OUTPUT. loop() läuft danach in einer Endlosschleife – immer und immer wieder. digitalWrite(13, HIGH) setzt den Pin auf 5V, die LED leuchtet. delay(1000) pausiert das Programm für 1000 Millisekunden. Dann schaltet digitalWrite(13, LOW) den Pin auf 0V, die LED erlischt. Nochmal 1 Sekunde warten – und von vorn.

Projekt 2: Taster steuert LED – Inputs verstehen

Eine LED einfach nur blinken zu lassen ist nett. Spannender wird es, wenn wir Interaktion ins Spiel bringen. In diesem Projekt schaltest du eine LED per Taster ein und aus – und lernst dabei digitale Eingänge, digitalRead() und den wichtigen INPUT_PULLUP-Modus kennen.

Schaltungsaufbau

Wir erweitern die Blink-Schaltung um einen Taster:

Wichtig: Der Taster kommt quer über die Mittelrinne des Breadboards. Taster haben vier Beine – die beiden auf einer Seite sind intern verbunden. Du verbindest eine Seite mit Pin 2, die gegenüberliegende mit GND. Kein externer Pull-Up-Widerstand nötig – wir nutzen den internen.

Der Code

// Projekt 2: Taster steuert LED
// Taster zwischen Pin 2 und GND
// LED an Pin 13 mit 220Ω Vorwiderstand

const int tasterPin = 2;   // Taster an Pin 2
const int ledPin = 13;     // LED an Pin 13
int tasterZustand = 0;     // Variable für den Tasterzustand

void setup() {
  pinMode(ledPin, OUTPUT);          // LED-Pin als Ausgang
  pinMode(tasterPin, INPUT_PULLUP); // Taster-Pin als Eingang mit Pull-Up
  Serial.begin(9600);               // Serielle Kommunikation starten
}

void loop() {
  tasterZustand = digitalRead(tasterPin);  // Taster auslesen

  if (tasterZustand == LOW) {        // Taster gedrückt? (LOW wegen PULLUP!)
    digitalWrite(ledPin, HIGH);      // LED einschalten
    Serial.println("Taster gedrückt - LED AN");
  } else {
    digitalWrite(ledPin, LOW);       // LED ausschalten
    Serial.println("Taster losgelassen - LED AUS");
  }

  delay(50);  // Kleine Pause zur Entprellung
}

So funktioniert's

Hier passiert etwas Neues: INPUT_PULLUP. Ein „Pull-Up"-Widerstand zieht den Pin im Ruhezustand auf HIGH (5V). Wenn der Taster gedrückt wird, verbindet er den Pin mit GND – der Pin wird LOW. Deshalb prüfen wir auf LOW für „Taster gedrückt". Der große Vorteil: Du brauchst keinen externen Widerstand – der ATmega328P hat 20kΩ Pull-Ups eingebaut. Weniger Bauteile, weniger Fehlerquellen.

Serial.begin(9600) startet die serielle Kommunikation. Mit Serial.println() schicken wir Nachrichten an den Computer. Öffne in der Arduino IDE den Serial Monitor (Tools → Serial Monitor oder Strg+Shift+M), um die Ausgaben live zu sehen – perfekt zum Debuggen!

Variante: Umschaltender Taster (Toggle)

Statt die LED nur beim Drücken leuchten zu lassen, kannst du sie mit jedem Tastendruck umschalten – wie ein Lichtschalter. Ersetze den loop()-Teil durch diesen Code:

bool ledAn = false;
bool letzterTasterZustand = HIGH;
unsigned long letzteEntprellZeit = 0;
const unsigned long entprellVerzoegerung = 50;

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

  if (lesen != letzterTasterZustand) {
    letzteEntprellZeit = millis();  // Zeitstempel zurücksetzen
  }

  if ((millis() - letzteEntprellZeit) > entprellVerzoegerung) {
    if (lesen == LOW) {              // Taster stabil gedrückt
      ledAn = !ledAn;                // Zustand umschalten
      digitalWrite(ledPin, ledAn);
      delay(200);                    // Warten gegen Doppelauslösung
    }
  }

  letzterTasterZustand = lesen;
}

Jetzt schaltet jeder Tastendruck die LED um. Die millis()-Funktion liefert die Millisekunden seit Programmstart – damit entprellen wir den Taster sauber ohne blockierendes delay().

Projekt 3: Temperatur und Luftfeuchtigkeit messen mit dem DHT22

Jetzt wird es praktisch: Wir lesen einen digitalen Sensor aus. Der DHT22 (auch als AM2302 bekannt) misst Temperatur und relative Luftfeuchtigkeit mit hoher Genauigkeit – und kommuniziert über nur einen einzigen Daten-Pin. Das ist typisch für viele Sensoren und ein Konzept, das dir immer wieder begegnet.

Warum der DHT22?

Der DHT22 ist seinem kleinen Bruder DHT11 in jeder Hinsicht überlegen:

• Temperatur: -40 °C bis +80 °C mit ±0,5 °C Genauigkeit (DHT11: nur 0–50 °C, ±2 °C)
• Luftfeuchtigkeit: 0–100 % rH mit ±2 % Genauigkeit
• Abtastrate: Alle 2 Sekunden (0,5 Hz) – schnell genug für Raumklima-Überwachung

Schaltungsaufbau

Die Verkabelung des DHT22 ist denkbar einfach – nur drei Verbindungen. Das Modul hat vier Pins, aber wir nutzen nur drei, weil ein Pin (NC = Not Connected) unbeschaltet bleibt:

Zwischen VCC und DATA gehört ein 4,7kΩ Pull-Up-Widerstand. Viele DHT22-Module von makeroo haben diesen bereits auf der kleinen Platine integriert – ein Blick auf die Rückseite zeigt, ob ein kleiner SMD-Widerstand vorhanden ist. Falls nicht: 4,7kΩ aus dem Widerstände-Set zwischen VCC und DATA schalten.

Bibliothek installieren

Damit der DHT22 funktioniert, brauchst du eine Bibliothek. In der Arduino IDE: Sketch → Bibliothek einbinden → Bibliotheken verwalten. Such nach „DHT sensor library" von Adafruit und installiere sie. Die IDE installiert automatisch auch die benötigte „Adafruit Unified Sensor"-Bibliothek mit.

Der Code

// Projekt 3: Temperatur & Luftfeuchtigkeit mit DHT22
// DHT22 DATA-Pin an Pin 7
// VCC an 5V, GND an GND
// 4,7kΩ Pull-Up zwischen VCC und DATA (oft bereits auf dem Modul)

#include "DHT.h"

#define DHT_PIN 7       // Daten-Pin des DHT22
#define DHT_TYPE DHT22  // Sensortyp: DHT22 (AM2302)

DHT dht(DHT_PIN, DHT_TYPE);

void setup() {
  Serial.begin(9600);
  Serial.println("=== DHT22 Raumklima-Monitor ===");
  Serial.println("Starte Sensor...");
  dht.begin();
  delay(2000);  // Sensor braucht 2 Sekunden zum Stabilisieren
}

void loop() {
  delay(2000);  // DHT22 maximal alle 2 Sekunden abfragen

  float luftfeuchtigkeit = dht.readHumidity();
  float temperatur = dht.readTemperature();

  // Fehlerbehandlung
  if (isnan(luftfeuchtigkeit) || isnan(temperatur)) {
    Serial.println("FEHLER: Sensor konnte nicht ausgelesen werden!");
    Serial.println("Prüfe: Verkabelung, Pull-Up-Widerstand, VCC (5V)");
    return;  // loop() neu starten
  }

  // Ergebnisse ausgeben
  Serial.print("Luftfeuchtigkeit: ");
  Serial.print(luftfeuchtigkeit);
  Serial.print(" %\t");

  Serial.print("Temperatur: ");
  Serial.print(temperatur);
  Serial.println(" °C");

  // Hitze- / Kälte-Warnung
  if (temperatur > 30.0) {
    Serial.println("WARNUNG: Hohe Temperatur – Lüften empfohlen!");
  } else if (temperatur < 15.0) {
    Serial.println("INFO: Recht kühl – Heizung prüfen.");
  }
}

So funktioniert's

Nach dem Upload öffnest du den Serial Monitor (9600 Baud einstellen!). Alle zwei Sekunden erscheinen die aktuellen Messwerte. Puste sanft auf den Sensor – die Temperatur und Luftfeuchtigkeit sollten sich sichtbar verändern. Damit hast du deinen ersten funktionierenden digitalen Sensor ausgelesen.

Die Funktion isnan() prüft, ob der Sensor einen gültigen Wert geliefert hat. isnan steht für „is Not a Number" und ist essentiell für robuste Messprogramme – der DHT22 kann bei Kommunikationsfehlern ungültige Werte liefern. Ohne diese Prüfung würdest du „nan" im Serial Monitor sehen und im schlimmsten Fall falsche Entscheidungen im Programm treffen.

Häufige Fehler und wie du sie behebst

Jeder, der mit Mikrocontrollern arbeitet, macht Fehler. Das ist Teil des Lernprozesses. Hier die häufigsten Stolperfallen – und wie du sie in 30 Sekunden behebst:

Grundregel beim Debuggen: Immer nur eine Sache gleichzeitig ändern. Sonst weißt du nie, welche Änderung das Problem gelöst hat. Und: Der Serial Monitor ist dein bester Freund. Wenn etwas nicht funktioniert, gib mit Serial.println() aus, was dein Programm gerade tut – so siehst du sofort, wo es hakt.

Nächste Schritte: Vom UNO R3 zum Nano V3 und mehr

Du hast jetzt drei Projekte erfolgreich umgesetzt – Gratulation! Dein UNO R3 ist ein fantastisches Einstiegs-Board, aber irgendwann willst du vielleicht mehr. Kleinere Projekte, mehr Leistung, drahtlose Kommunikation. Hier ist dein Upgrade-Pfad:

Unser Nano V3 mit USB-C ist der logische nächste Schritt. Gleicher ATmega328P, gleiche Arduino IDE, gleiche Programmierung – nur kompakter und günstiger. Viele Maker haben einen UNO R3 zum Experimentieren auf dem Schreibtisch und mehrere Nano V3 in fertigen Projekten.

Bei den Sensoren lohnt sich nach dem DHT22 vor allem der HC-SR04 Ultraschallsensor für Abstandsmessungen. Von der einfachen Parkhilfe bis zum interaktiven Kunstprojekt – Ultraschall ist vielseitig und einfach anzusteuern. Oder stöbere in unseren Kategorien: