Skip to content

Technik Blog

Programmieren | Arduino | ESP32 | MicroPython | Python | Raspberry Pi | Raspberry Pi Pico

Menu
  • Smarthome
  • Arduino
  • ESP32 & Co.
  • Raspberry Pi & Pico
  • Solo Mining
  • Über mich
  • Deutsch
  • English
Menu

Programmieren lernen mit dem Arduino UNO R4 Minima: ­10 praktische Beispiele

Posted on 31. Juli 20234. März 2025 by Stefan Draeger

In diesem Beitrag zeige ich dir 10 spannende Beispiele mit dem Arduino UNO R4 Minima. Wir werden Schritt für Schritt durch jeden Aufbau und die Programmierung führen, sodass du ein tieferes Verständnis für diesen Mikrocontroller gewinnst.

Du erinnerst dich vielleicht an die Projekte, die ich dir bereits für den Arduino UNO R3 vorgestellt habe. Diesmal wirst du jedoch sicherlich Neues entdecken und lernen. Auch wenn du noch ein Anfänger bist, keine Sorge! Die Projekte sind speziell für Menschen wie dich konzipiert, um dir einen praktischen Einstieg in die Welt der Programmierung zu ermöglichen.

Von der Steuerung von LED-Blinkmustern bis hin zur Nutzung von Sensoren wie Temperatur- und Ultraschallsensoren – wir werden eine Vielzahl von Anwendungen erkunden. Ich bin mir sicher, dass du jede Menge Spaß haben wirst, während du dein Wissen erweiterst.

Also schnapp dir deinen Arduino UNO R4 Minima und lass uns beginnen! Gemeinsam werden wir die Grundlagen meistern und faszinierende Projekte realisieren.

Die Beispiele sind von ganz leicht bis etwas anspruchsvoll, aber trotzdem oder gerade für Anfänger bestens geeignet. Zu jedem Beispiel werde ich dir eine kleine Liste mit Bezugsquellen für die benötigten Bauteile bereitstellen. Wobei du jedoch den Arduino UNO R4 Minima derzeit nur exklusiv im Arduino Store bekommst.

Inhaltsverzeichnis

  • Anschluss an den PC und einrichten der Arduino IDE 2.0 für den Arduino UNO R4 Minima
  • Beispiel 1 – Ausgabe von Text auf der seriellen Schnittstelle
  • Beispiel 2 – eine Leuchtdiode (LED) programmieren
    • LED blinken lassen
    • zwei LEDs wechsel blinken
    • eine Ampelschaltung mit drei LEDs
    • RGB LED programmieren
  • Beispiel 3 – ein Drehpotentiometer am analogen Pin auslesen
    • Auslesen des analogen Wertes vom Drehpotentiometer
    • Regeln der Helligkeit einer LED mit einem Drehpotentiometer
  • Beispiel 4 – einen Taster programmieren
    • Prellen eines Tasters verhindern
      • Lösung 1 – entprellen mit einem delay
      • Lösung 2 – entprellen mit der Bibliothek Bounce2
  • Beispiel 5 – einen Piezo Buzzer programmieren
    • Funktion tone() & noTone()
    • Funktion tone() mit Intervall
    • Ein Lied abspielen
  • Beispiel 6 – einen Servomotor Typ SG90 programmieren
    • Einen Servomotor mit dem Drehpotentiometer steuern
  • Beispiel 7 – einen digitalen Temperatur & rel. Luftfeuchtigkeitssensor DHT11 anschließen und auslesen
    • Installieren der Bibliothek für den DHTx Sensor
    • Anschluss des DHT11 Sensors an den Arduino UNO R4 Minima
  • Beispiel 8 – ein 16×2 I2C LCD-Display anschließen und Sensordaten anzeigen
    • Installieren der Bibliothek für das I2C LCD-Display
    • Ausgeben von Zeichen auf dem LCD-Display mit der LiquidCrystal Bibliothek
    • Aufbau der Schaltung und programmieren in der Arduino IDE
  • Beispiel 9 – Ultraschall-Abstandssensor HC-SR04 anschließen und programmieren
  • Beispiel 10 – serielle Verbindung zweier Mikrocontroller

Anschluss an den PC und einrichten der Arduino IDE 2.0 für den Arduino UNO R4 Minima

Bevor wir jedoch mit der Programmierung beginnen können, müssen wir den Mikrocontroller einrichten. Dieser wird zwar in der Arduino IDE 2.0 erkannt, aber den kompletten Leistungsumfang (Speicher & CPU) können wir nur nutzen, wenn wir den Boardtreiber installieren.

Den Boardverwalter finden wir in der Arduino IDE 2.0 in der Symbolleiste auf der linken Seite (1) dort suchen wir dann nach „arduino uno r4“ (2) und wählen dort die Schaltfläche „INSTALL“ (3).
Wenn der Boardtreiber installiert wurde, dann wird dieses über einen Text „<Versionsnummer> installed“ (4) angezeigt und die Schaltfläche „INSTALL“ wird zu „REMOVE“.

Nun finden wir unter dem Pfad „Tools > Board:xyz > Arduino UNO R4 Boards“ das Board „Arduino Uno R4 Minima“.

Beispiel 1 – Ausgabe von Text auf der seriellen Schnittstelle

Im ersten Beispiel wollen wir einen Text auf der seriellen Schnittstelle ausgeben. Dieses können wir unter anderem dazu nutzen, um zusätzliche Ausgaben in unseren Quellcode einzubauen und so auf Fehlersuche zu gehen.

//Funktion setup wird einmalig beim Starten
//des Mikrocontrollers ausgeführt.
//Diese wird auch ausgeführt, wenn du die Reset-Taste
//auf dem Board drückst.
void setup() {
  //begin der seriellen Kommunikation
  //mit 9600 baud
  Serial.begin(9600);
}

//Die Funktion loop wird fortlaufen ausgeführt.
void loop() {
  //Ausgabe des Textes "Hallo Welt!"
  Serial.println("Hallo Welt!");
  //einlegen einer kleinen Pause
  //von 500 Millisekunden
  delay(500);
}

Wenn du den obigen Quellcode auf dem UNO R4 Minima ausführst, dann solltest du im Intervall von 0,5 Sekunden die Ausgabe von „Hallo Welt!“ sehen.

Beispiel 2 – eine Leuchtdiode (LED) programmieren

Eine Leuchtdiode kannst du mit einer kleinen Glühbirne vergleichen, jedoch wird diese nicht warm und verbraucht nur einen Bruchteil des Stromes. Die Leuchtdiode hat zwei Pins / Beinchen, wovon einen kürzer ist, am Gehäuse findest du zusätzlich noch eine abgeflachte Stelle. Dieses beide sind Indikatoren für die Kathode, welche der Minuspol der LED ist.

Aufbau einer LED
Aufbau einer LED

Bei einer LED ist die Einbaurichtung zu beachten, denn dieses Bauteil leitet den Strom nur in eine Richtung. Du musst also immer GND an Kathode und die 5 V an die Anode (das lange Beinchen). ABER niemals darfst du eine LED ohne einen Vorwiderstand an eine Stromquelle anschließen. Im Grunde kannst du mit einem Vorwiderstand von 220 Ohm an einer 5 V Stromquelle nichts falsch machen.

Arduino UNO R4 Minima - #1 LEDs programmieren
Dieses Video auf YouTube ansehen.

LED blinken lassen

Fangen wir mit einer einfachen Schaltung und einem ebenso einfachen Programm an und lassen eine LED blinken.
Dazu schließen wir die Leuchtdiode mit einem 220 Ohm Vorwiderstand an den digitalen Pin D13 an.

eine LED am Arduino UNO
eine LED am Arduino UNO

Im Code müssen wir uns nun ein Feld mit dem Pin belegen und diesen in der Funktion setup als Ausgang definieren. In der loop wird jetzt fortwährend immer der Pin aktiviert und nach einer Pause wieder deaktiviert.

#define ledBlau 13

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

void loop() {
  digitalWrite(ledBlau, HIGH);
  delay(500);
  digitalWrite(ledBlau, LOW);
  delay(500);
}

zwei LEDs wechsel blinken

Im nächsten Schritt bauen wir eine zweite LED ein und erweitern unser Programm um diese so das beide LEDs im wechsel blinken.

zwei LEDs am Arduino UNO
zwei LEDs am Arduino UNO

Das Wechselblinken entsteht dadurch, dass wir immer nur eine LED aktiv haben.

#define ledBlau 13
#define ledGruen 8

void setup() {
  pinMode(ledBlau, OUTPUT);
  pinMode(ledGruen, OUTPUT);
}

void loop() {
  digitalWrite(ledBlau, HIGH);
  digitalWrite(ledGruen, LOW);
  delay(500);
  digitalWrite(ledBlau, LOW);
  digitalWrite(ledGruen, HIGH);
  delay(500);
}

eine Ampelschaltung mit drei LEDs

Mit drei kleinen farbigen LEDs und der Erkenntnis von den beiden vorherigen Beispielen können wir nun eine Ampelschaltung programmieren.

Eine Ampelschaltung besteht aus den vier nachfolgenden Phasen:

Wechsellichtzeichen nach §37 Abs.2 StVO
Wechsellichtzeichen nach §37 Abs.2 StVO

Die rote LED schließen wir am digitalen Pin D13, die gelbe am digitalen Pin D12 und die grüne am Pin D11 an. Natürlich jeweils mit einem 220 Ohm Vorwiderstand.

Schaltung - Ampelphasen am Arduino UNO
Schaltung – Ampelphasen am Arduino UNO

Im Code fügen wir eine weitere Funktion hin zu welcher wir als Parameter die Status der LEDs übergeben. Mit dieser Funktion halten wir unseren Code deutlich kürzer und wir verhindern doppelten Code.

#define ledRot 13
#define ledGelb 12
#define ledGruen 11

void setup() {
  pinMode(ledRot, OUTPUT);
  pinMode(ledGelb, OUTPUT);
  pinMode(ledGruen, OUTPUT);
}

//Funktion zum setzen der Status der LEDs 
void setLEDs(bool ledR, bool ledGe, bool ledGr) {
  digitalWrite(ledRot, ledR);
  digitalWrite(ledGelb, ledGe);
  digitalWrite(ledGruen, ledGr);
  delay(450);
}

void loop() {
  setLEDs(false, false, true);
  setLEDs(false, true, false);
  setLEDs(true, false, false);
  setLEDs(true, true, false);
}

Wenn wir den Code auf dem Arduino UNO R4 Minima ausführen, dann sollten wir an den LEDs die vier Ampelphasen sehen.

Ampelschaltung am Arduino UNO R4 Minima

RGB LED programmieren

Es gibt aber auch LEDs welche drei Farben in einem haben, dieses sind die RGB LEDs. Wobei hier die Abkürzungen RGB für die Farben rot, grün und blau stehen. Nachfolgend zeige ich dir ein kleines Beispiel, wie du diese RGB LED an den UNO R4 anschließt und programmierst.

In diesem Beispiel verwenden wir eine reine RGB LED, also kein NeoPixel oder eine WS18B20 LED, welche einen größeren Farbraum abdecken würde.

Die RGB LED verfügt über vier Kontakte, wobei jeweils ein Kontakt für jede Farbe dient und ein gemeinsamer Minuspol (GND).

Pinout der 10mm RGB LED
Pinout der 10 mm RGB LED

An den Mikrocontroller schließen wir die RGB LED wiefolgt an:

  • rot > D11,
  • blau > D10,
  • grün > D9,
  • GND > GND

Die verwendeten Pins sind PWM Pins und somit können wir die Farben mixen und somit theoretisch aus dem 32bit Farbraum eine Farbe einstellen.

Schaltung - RGB LED am Arduino UNO
Schaltung – RGB LED am Arduino UNO

Die Kontakte der RGB LED werden mit PWM Pins des UNOs verbunden, somit können wir nicht nur eine der drei Grundfarben Rot, Blau und Grün anzeigen, sogar auch eine mischen.

#define ledRot 11
#define ledBlau 10
#define ledGruen 9

//Konstante für die Pause
const int PAUSE = 1000;

void setup() {
  pinMode(ledRot, OUTPUT);
  pinMode(ledBlau, OUTPUT);
  pinMode(ledGruen, OUTPUT);
}

//Funktion zum setzen eines PWM Wertes an der RGB LED
void setLEDsValues(int valR, int valB, int valG) {
  analogWrite(ledRot, valR);
  analogWrite(ledBlau, valB);
  analogWrite(ledGruen, valG);
}

void loop() {
  //Rot
  setLEDsValues(255, 0, 0);
  delay(PAUSE);
  //Blau
  setLEDsValues(0, 255, 0);
  delay(PAUSE);
  //Grün
  setLEDsValues(0, 0, 255);
  delay(PAUSE);

  //Farben mischen
  setLEDsValues(128, 0, 55);
  delay(PAUSE);
}

Der Code bewirkt, dass die 3 Grundfarben Rot, Blau & Grün angezeigt werden. Zusätzlich wird noch eine Farbe gemischt.

Beispiel 3 – ein Drehpotentiometer am analogen Pin auslesen

Wie ein Drehpotentiometer aufgebaut ist, habe ich dir im Beitrag Bauteile: 50kOhm Drehpotentiometer gezeigt. Des Weiteren habe ich dir in diversen Beiträgen auch bereits gezeigt, wie man diesen am Arduino programmiert. Gerne möchte ich hier nun dir zeigen, wie dieser Drehpoti am Arduino UNO R4 Minima angeschlossen und programmiert wird.

Auslesen des analogen Wertes vom Drehpotentiometer

Zunächst schließen wir einen Drehpotentiometer am UNO R4 am analogen Pin A0 an.

Drehpotentiometer am Arduino UNO
Drehpotentiometer am Arduino UNO

Den Wert eines analogen Sensors kann man mit der Funktion analogRead auslesen. Man erhält von dieser Funktion je nach verwendeter Spannung einen der beiden Wertebereiche:

  • bei 3.3V – 0 bis 679,
  • bei 5 V – 0 bis 1023
//der Drehpotentiometer ist
//am analogen Pin A0 angeschlossen
#define rotaryResistor A0

//Feld für das speichern des
//Wertes für den Drehpoti
int value = 0;

void setup() {
  //begin der seriellen Kommunikation
  //mit 9600 baud
  Serial.begin(9600);
  //definieren das der Pin A0
  //als Eingang dient
  pinMode(rotaryResistor, INPUT);
}

void loop() {
  //lesen des aktuellen Wertes vom Pin A0
  value = analogRead(rotaryResistor);
  //ausgeben des Wertes auf 
  //der seriellen Schnittstelle
  Serial.println(value);
  //einlegen einer kleinen Pause 
  //von 25 Millisekunden
  delay(25);
}

In dem nachfolgenden Video siehst du den Wert im seriellen Monitor der Arduino IDE. Dieser ändert sich mit dem Drehen des angeschlossenen Drehpoti.

Regeln der Helligkeit einer LED mit einem Drehpotentiometer

Nachdem wir wissen, wie man den Wert eines Drehpoti auslesen kann, wollen wir nun dieses Bauteil nutzen, um die Helligkeit einer LED zu regeln.

Man muss jedoch darauf achten, dass die LED an einen der sechs PWM Pins angeschlossen wird!

Schaltung - Arduino UNO mit Drehpotentiometer und LED
Schaltung – Arduino UNO mit Drehpotentiometer und LED

Im Code müssen wir den analogen Wert, welcher zwischen 0 und 1023 liegen kann auf den PWM Wert welcher wiederum zwischen 0 und 255 liegt mappen. Dafür gibt es die Funktion map welche uns die Arbeit abnimmt.

//Drehpotentiometer am analogen Pin A0 angeschlossen
#define rotaryResistor A0
//LED am digitalen PWM Pin D3 angeschlossen
#define led 3

void setup() {
  //der Pin A0 als Eingang definieren
  pinMode(rotaryResistor, INPUT);
  //der Pin D3 als Ausgang definieren
  pinMode(led, OUTPUT);
}

void loop() {
  //auslesen des aktuellen Wertes vom Drehpoti
  int value = analogRead(rotaryResistor);
  //mappen des gelesenen Wertes 
  //von dem Gültigkeitsbereich eines analogen Wertes 
  //0 bis 1023 auf den Gültigkeitsbereich 
  //eines PWM Signals von 0 bis 255
  int ledBrigthness = map(value, 0,1023, 0,255);
  //schreiben des ermittelten Wertes an den Pin der LED
  analogWrite(led, ledBrigthness);
  //einlegen einer kleinen Pause von 25 Millisekunden
  delay(25);
}

Im folgenden YouTube Video erläutere ich dir den Aufbau der Schaltung sowie wie du das Programm in der Arduino IDE programmierst.

Arduino UNO R4 Minima - #2 Drehpotentiometer
Dieses Video auf YouTube ansehen.

Beispiel 4 – einen Taster programmieren

Im nächsten Beispiel soll es nun darum gehen, wie du einen Taster am Arduino UNO R4 Minima programmieren kannst.

Arduino UNO R4 Minima - #3 Taster programmieren
Dieses Video auf YouTube ansehen.

Es gibt hier diverse Möglichkeiten, einen Taster am Arduino zu programmieren. Zum einen mit einem PullUp oder PullDown Widerstand sowie über die internen 10kOhm Widerstände.

Die Lösung mit dem internen 10 kOhm Widerstand ist deutlich einfacher, da wir hier auf einen zusätzlichen Widerstand in unserer Schaltung verzichten können.

In der Grafik siehst du die 3 möglichen Anschlüsse eines Tasters am Arduino UNO.

3 Varianten zum Anschluss eines Tasters am Arduino UNO
3 Varianten zum Anschluss eines Tasters am Arduino UNO

Prellen eines Tasters verhindern

Das Problem mit einem Taster am Arduino ist, dass dieser prellt, das heißt, es werden mehrere Signale empfangen und ausgewertet.

Dieses sollten wir nach Möglichkeit verhindern. Aber auch hier gibt es Abhilfe, eine recht einfache brauchbare Lösung mit dem Aufruf der Funktion delay und eine deutlich bessere mit der Bibliothek Bounce2.

Lösung 1 – entprellen mit einem delay

Die wie erwähnt einfachste Lösung ist mit dem Aufruf der Funktion delay. Hier legen wir eine kleine Pause am Mikrocontroller ein, um dem Benutzer Zeit zu lassen, den Taster loszulassen.

//Taster am digitalen Pin D8 angeschlossen
#define button 8

void setup() {
  //begin der seriellen Kommunikation mit 9600 baud
  Serial.begin(9600);
  //der Taster wurde über den internen 10 kOhm
  //Widerstand angeschlossen
  pinMode(button, INPUT_PULLUP);
}

void loop() {
  //Wenn der Taster gedrückt ist, dann...
  if(digitalRead(button)==LOW){
    //Ausgeben des Textes
    Serial.println("Taster gedrückt!");
    //einlegen einer kleinen Pause von 125 Millisekunden
    delay(125);
  }
}

Im Video siehst du, dass wenn der Taster gedrückt wird, die Ausgabe „Taster gedrückt!“ im seriellen Monitor angezeigt wird.

Lösung 2 – entprellen mit der Bibliothek Bounce2

Die deutlich bessere Lösung ist die mit der Verwendung der Bibliothek Bounce2, hier können wir sogar drauf reagieren, wenn der Taster gedrückt und ebenso losgelassen wird. D.h. wir könnten den Taster mit einer zusätzlichen Funktion belegen.

Die Bibliothek Bounce2 findest du im Bibliotheksverwalter der Arduino IDE, indem wir dort nach „Bounce2“ suchen und die Schaltfläche „INSTALL“ betätigen.

Eintrag der Bounce2 Bibliothek im Bibliotheksverwalter der Arduino IDE
Eintrag der Bounce2 Bibliothek im Bibliotheksverwalter der Arduino IDE

Hier nun ein kleines Beispiel mit der Bibliothek, der Taster ist über den internen PullUp Widerstand verbunden.

#include <Bounce2.h>

//Taster am digitalen Pin D8 angeschlossen
#define button 8

//erstellen eines Button Objektes
Bounce2::Button btn = Bounce2::Button();

void setup() {
  //begin der seriellen Kommunikation mit 9600 baud
  Serial.begin(9600);
  //verbinden des Button Objektes mit dem Pin und
  //definieren das dieser über den internen 10 kOhm
  //Widerstand angeschlossen ist
  btn.attach(button, INPUT_PULLUP);
  //Intervall für das entprellen auf 5 Millisekunden
  btn.interval(5);
  //Wenn der Taster gedrückt ist wird dieses als LOW
  //interpretiert.
  btn.setPressedState(LOW);
}

void loop() {
  //aktualisieren des Button Objektes
  btn.update();
  
  //Wenn der Taster gedrückt ist, dann...
  if (btn.fell()) {
    Serial.println("Taster gedrückt!");
  }

  //Wenn der Taster wieder losgelassen wird, dann...
  if (btn.rose()) {
    Serial.println("Taster losgelassen!");
  }
}

dfsdg

Beispiel 5 – einen Piezo Buzzer programmieren

Mit dem Piezo Buzzer kannst du Töne und sogar auch ganze Lieder abspielen / wiedergeben.

Arduino UNO R4 Minima - #4 Piezo Buzzer programmieren
Dieses Video auf YouTube ansehen.

Der Piezo Buzzer hat zwei Pins wobei es bei diesem Bauteil egal ist wie du diesen Anschließt.

Piezo Buzzer
Piezo Buzzer

Zusätzlich muss dieser Piezo Buzzer an einen der 6 möglichen PWM Pins angeschlossen werden!

Piezo Buzzer am Arduino UNO
Piezo Buzzer am Arduino UNO

Damit wir einen Ton am Arduino mit dem Piezo Buzzer wiedergeben können, gibt es drei Funktionen, welche ich dir nun zunächst einmal vorstellen möchte.

Funktion tone() & noTone()

Einen Ton kannst du mit der Funktion tone() wiedergeben, dafür musst du als Parameter den Pin sowie die Frequenz übergeben. Der Ton wird dann so lange wiedergeben, bis die Funktion noTone() mit dem Pin aufgerufen wird.

//Buzzer am digitalen PWM Pin D3 angeschlossen
#define buzzer 3

//Pause von 500 Millisekunden
const int PAUSE = 500;
//Frequenz von 750 kHz
const int FREQUENZ = 750;

void setup() {
  //Pin des Piezo Buzzers als Ausgang definieren
  pinMode(buzzer, OUTPUT);
}

void loop() {
  //aktivieren des Buzzers mit der Frequenz
  tone(buzzer,FREQUENZ);
  //einlegen einer Pause
  delay(PAUSE);
  //deaktivieren des Buzzers
  noTone(buzzer);
  //einlegen einer Pause
  delay(PAUSE);
}

Funktion tone() mit Intervall

Die Funktion tone() gibt es zusätzlich noch mit dem Parameter für ein Intervall, hier übergibst du zusätzlich noch einen Wert in Millisekunden und der Ton deaktiviert sich quasi von selbst. Jedoch legt hier der Mikrocontroller eine Pause ein, d.h. es läuft nicht im Hintergrund!

//Buzzer am digitalen PWM Pin D3 angeschlossen
#define buzzer 3

//Wert für die Dauer des Tones
//in diesem Fall 250 Millisekunden
const int DAUER = 250;

//Frequenz von 750 kHz
const int FREQUENZ = 750;

void setup() {
  //Pin des Piezo Buzzers als Ausgang definieren
  pinMode(buzzer, OUTPUT);
}

void loop() {
  //aktivieren des Buzzers mit der Frequenz
  //und zusätzlich einer Dauer
  tone(buzzer, FREQUENZ, DAUER);
  //einlegen einer Pause
  delay(500);
}

Ein Lied abspielen

Im Beitrag Weihnachtsevent 2019 im JFZ Schöningen – „Löten eines Weihnachtsbaums mit Sound“ habe ich das Lied Jingle Bells auf einem Arduino Nano V3 abgespielt. Dieses kannst du 1:1 für den UNO R4 Minima wiederverwenden.

Im Internet findest du einige Seiten wo andere Lieder wie die Musik von Mario, Star Wars als INO-Datei angeboten wird. Die Seite Songs for Arduino bietet eine recht umfangreiche Liste, aus welcher du dich gut bedienen kannst.

Beispiel 6 – einen Servomotor Typ SG90 programmieren

Der Servomotor Typ SG90 kann recht einfach am Arduino UNO programmiert werden, hier benötigst du lediglich einen freien digitalen PWM Pin.

Der Servomotor hat drei Pins welche mit den Farben braun, rot & orange belegt sind. Diese werden wie folgt mit dem Arduino UNO verbunden:

  • braun > GND,
  • rot > 5 V,
  • orange > digitaler PWM Pin
Servomotor 9G Typ SG90
Servomotor 9G Typ SG90

Einen Servomotor mit dem Drehpotentiometer steuern

Ein cooles Beispiel ist das Steuern des Servomotors mit einem Drehpotentiometer. Wie du einen Drehpoti am Arduino UNO R4 Minima anschließt und ausliest sowie den analogen Wert mappen kannst habe ich dir bereits gezeigt.

Schließen wir nun erstmal den Servomotor sowie den Drehpoti an den UNO wie folgt an:

KomponenteArduino UNO R4 Minima
Servomotor Typ SG90
braunGND
rot5 V
orangeD11~
Drehpotentiometer
Pin 13.3 V
Pin 2A0
Pin 3GND
Servomotor & Drehpotentiometer am Arduino UNO
Servomotor & Drehpotentiometer am Arduino UNO

Den Drehpotentiometer habe ich in der Schaltung am 3.3V Pin angeschlossen, somit ergibt sich ein Gültigkeitsbereich für den analogen Wert von 0 bis 679.

//Bibliothek zum ansteuern eines Servomotors
#include <Servo.h>

//Drehpotentiometer am analogen Pin A0 angeschlossen
#define drehpoti A0

//Servomotor am digitalen PWM Pin D11 angeschlossen
#define servoPin 11

//erzeugen eines Servo Objektes
Servo servo;

void setup() {
  //der Pin des Servomotors soll als Ausgang dienen
  pinMode(servoPin, OUTPUT);

  //der Pin des Drehpotentiometers soll als Eingang dienen
  pinMode(drehpoti, INPUT);

  //verbinden des Servopins mit dem Servo Objekt
  servo.attach(servoPin);
}

void loop() {
  //auslesen der aktuellen Position des Drehpotis
  int value = analogRead(drehpoti);
  //mappen des Wertes vom Drehpoti auf den Gültigkeitsbereich des Servomotors
  //der Drehpoti ist in meinem Aufbau am 3.3V Pin angeschlossen, daher ist die
  //Range der analogen Werte 0 bis 679, solltest du diesen an 5V anschließen so ist
  //diese von 0 bis 1023.
  //Die letzten Beiden werde sind die möglichen Winkel des Servos,
  //der Servomotor Typ SG90 kann nur 180°
  int servoPosition = map(value, 0, 679, 0, 180);
  //schreiben der Servoposition
  servo.write(servoPosition);
  //ein kleine Pause einlegen
  delay(25);
}

Im nachfolgenden YouTube-Video erfährst du, wie ein Servomotor am Arduino UNO R4 Minima programmiert und zusätzlich mit einem Drehpotentiometer gesteuert wird.

Arduino UNO R4 Minima - #5 Servomotor programmieren
Dieses Video auf YouTube ansehen.

Beispiel 7 – einen digitalen Temperatur & rel. Luftfeuchtigkeitssensor DHT11 anschließen und auslesen

Mit dem digitalen Sensor DHT11 kannst du die Temperatur sowie die relative Luftfeuchtigkeit in einem annehmbaren Toleranzbereich messen.

Du bekommst den DHT11 Sensor in verschiedenen Varianten, wenn du diesen nur zum etwas herumbasteln besorgen möchtest, dann empfehle ich dir diesen als fertigen Baustein auf einer Platine, denn dann entfällt die Schaltung mit dem 4,7 kOhm Widerstand.

Varianten des DHT11 Sensors
Varianten des DHT11 Sensors

Wenn du einen Sensor mit einer besseren Toleranz und einem größeren Messbereich benötigst, dann empfehle ich dir den DHT22 Sensor. Im Beitrag Vergleich der Sensoren, AM2320, DHT11 und DHT22 habe ich dir einmal diesen Sensor mit dem DHT11 verglichen.

Installieren der Bibliothek für den DHTx Sensor

Für den DHT11 (sowie DHT22, AM2320) Sensor benötigst du eine zusätzliche Bibliothek, welche du im Bibliotheksmanager der Arduino IDE installieren kannst.

Dazu öffnest du den Bibliotheksmanager über das Icon auf der linken Seite (1) und suchst danach nach „adafruit dht11“ (2), in den Suchergebnissen wählst du am Eintrag „DHT sensor library by Adafruit“ die Schaltfläche „INSTALL“ (3), in meinem Fall habe ich diese bereits in der Version 1.4.4 installiert, welches du am Tag (4) erkennst.

Installieren der Bibliothek für den DHT11 Sensor über den Bibliotheksverwalter
Installieren der Bibliothek für den DHT11 Sensor über den Bibliotheksverwalter

Natürlich gibt es noch weitere Bibliotheken, welche man für diesen Sensor einsetzen kann, jedoch habe ich mit dieser Bibliothek meine Erfahrung gesammelt.

Anschluss des DHT11 Sensors an den Arduino UNO R4 Minima

Bauen wir nun kurz die Schaltung auf und geben die Daten des Sensors auf der seriellen Schnittstelle aus.

In der Grafik findest du die beiden möglichen Anschlüsse des DHT11 Sensors, zum einen mit einem 10 kOhm Widerstand und einmal wenn dieser Sensor bereits auf einer Platine ausgeliefert wird.

Schaltung - DHT11 Sensoren am Arduino UNO
Schaltung – DHT11 Sensoren am Arduino UNO

Das Programm zum Auslesen des Sensors ist jedoch gleich und kann für beide Aufbauarten verwendet werden.

//Bibliothek zum Kommunizieren mit dem DHTx Sensor
//Diese Bibliothek kann mit dem DHT11 & DHT22 Sensor
//verwendet werden.
#include <DHT.h>

//DHT11 Sensor am digitalen Pin D9 angeschlossen
#define sensor 9
//Der Typ des Sensors ist DHT11, wenn du einen
//DHT22 verwendest so musst du dieses hier anpassen
#define DHTTYPE DHT11

//initialisieren eines DHT Sensor Objektes
DHT dhtSensor(sensor, DHTTYPE);

void setup() {
  //beginn der seriellen Kommunikation mit 9600 Baud
  Serial.begin(9600);
  //begin der Kommunikation mit dem Sensor
  dhtSensor.begin();
}

void loop() {
  //der DHT Sensor liefert alle 1,5 Sekunden einen neuen Messwert
  delay(1500);
  //auslesen der Sensorwerte
  float humidityVal = dhtSensor.readHumidity();
  float tempVal = dhtSensor.readTemperature();
  float tempFahrenheitVal = dhtSensor.readTemperature(true);

  //prüfen ob die gelesenen Werte korrekt ausgelesen wurde
  if (isnan(humidityVal) || isnan(tempVal) || isnan(tempFahrenheitVal)) {
    Serial.println("Fehler beim lesen des Sensors!");
    //Bei einem Fehler soll die Funktion loop hier nun abgebrochen
    //werden.
    return;
  }

  //Ausgeben der Werte auf der seriellen Schnittstelle
  Serial.print("rel. Luftfeuchtigkeit:");
  Serial.print(humidityVal);
  Serial.println("%");

  Serial.print("Temperatur:");
  Serial.print(tempVal);
  Serial.print("°C | ");
  Serial.print(tempFahrenheitVal);
  Serial.println("°F");
}

Im nachfolgenden YouTube-Video zeige ich dir im Detail, wie du die Schaltung aufbaust und am Arduino UNO R4 Minima in der Arduino IDE 2.0 programmierst.

Arduino UNO R4 Minima - #6 DHT11 Sensor auslesen & visualisieren
Dieses Video auf YouTube ansehen.

Zusätzlich zeige ich dir, wie du die Sensorwerte im seriellen Plotter der Arduino IDE visualisieren kannst.

Visualisieren der Sensordaten im seriellen Plotter der Arduino IDE 2.0
Visualisieren der Sensordaten im seriellen Plotter der Arduino IDE 2.0

Beispiel 8 – ein 16×2 I2C LCD-Display anschließen und Sensordaten anzeigen

Auf dem 16×2 I2C LCD-Display können wir zweizeiligen Text mit maximal 16 Zeichen pro Zeile ausgeben. Dabei haben wir jedoch nur begrenzten Zugriff auf die ASCII-Tabelle. (Umlaute, und Sonderzeichen werden nicht zuverlässig angezeigt.)

16x2 I2C LCD-Display
16×2 I2C LCD-Display

Installieren der Bibliothek für das I2C LCD-Display

Damit wir Text auf dem Display etwas schreiben / darstellen können, benötigen wir zusätzlich eine Bibliothek. Diese Bibliothek installieren wir ebenso über den internen Bibliotheksverwalter (1) der Arduino IDE. Dort müssen wir zunächst nach „LiquidCrystal“ (2) suchen und dann dieses über die Schaltfläche „INSTALL“ (3) installieren. Wenn dieses erfolgreich war, dann wird an der Position (4) ein Text aus der Versionsnummer und „install“ angezeigt.

Installieren der Bibliothek LiquidCrystal über den Bibliotheksmanager der Arduino IDE
Installieren der Bibliothek LiquidCrystal über den Bibliotheksmanager der Arduino IDE

Ausgeben von Zeichen auf dem LCD-Display mit der LiquidCrystal Bibliothek

Auf dem hier verwendeten Display können wir 16 Zeichen pro Zeile anzeigen.

Zahlen und Sonderzeichen auf einem LCD-Display
Zahlen und Sonderzeichen auf einem LCD-Display

Das nachfolgende kleine Skript gibt die oben gezeigten Zeichen auf dem LCD-Display aus.

//Bibliothek zum ansteuern des LCD-Displays
#include <LiquidCrystal_I2C.h>

//initialisieren eines Objektes vom Typ LiquidCrystal_I2C
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  //begin der kommunikation mit dem konfigurierten LCD-Display
  lcd.init();
  //aktivieren der Hintergrundbeleuchtung
  lcd.backlight();
}

void loop() {
  //setzen des Cursors an die Spalte 0 (erster Parameter) und Zeile 0 (zweiter Parameter)
  lcd.setCursor(0, 0);
  //Ausgeben der Zahlen
  lcd.print("0123456789012345");
  //setzen des Cursors an die Spalte 0 (erster Parameter) und Zeile 1 (zweiter Parameter)
  lcd.setCursor(0, 1);
  //Ausgeben von Sonderzeichen
  lcd.print("()[]!?$%&/=+-_,:");
}

Aufbau der Schaltung und programmieren in der Arduino IDE

Wir haben nun die Bibliothek „LiquidCrystal“ installiert und können nun die kleine Schaltung aufbauen. Für diese Schaltung benötigen wir lediglich:

  • ein 16×2 I2C LCD-Display,
  • einen DHT11 Sensor,
  • sieben Breadboardkabel,
  • ein 170 Pin Breadboard
Arduino UNO mit DHT11 Sensor & 16x2 LCD-Display
Arduino UNO mit DHT11 Sensor & 16×2 LCD-Display

Im Code müssen wir nun die Sensordaten in einem Intervall auslesen und auf dem Display schreiben. Dazu müssen wir jedoch auf dem Display die zuvor angezeigten Sensordaten löschen, da sonst die Zeichen sich überlappen würden.

//Bibliothek zum ansteuern des LCD-Displays
#include <LiquidCrystal_I2C.h>
//Bibliothek zum auslesen des DHTx Sensors
#include <DHT.h>

//DHT11 Sensor am digitalen Pin D9 angeschlossen
#define sensor 9
//definieren das wir einen DHT Sensor vom Typ DHT11 verwenden
#define DHTTYPE DHT11

//initialisieren eines Objektes vom Typ LiquidCrystal_I2C
LiquidCrystal_I2C lcd(0x27, 20, 4);
//initialisieren eines Objektes vom Typ DHT
DHT dhtSensor(sensor, DHTTYPE);

void setup() {
  //begin der kommunikation mit dem DHT Sensor
  dhtSensor.begin();
  //begin der kommunikation mit dem konfigurierten LCD-Display
  lcd.init();
  //aktivieren der Hintergrundbeleuchtung
  lcd.backlight();
}

//Funktion zum schreiben eines Textes auf dem LCD-Display
void writeText(int line, String lbl, float value, String sign) {
  //setzen der Cursor-Position
  lcd.setCursor(0, line);
  //zusammensetzen und schreiben eines Textes
  //der Wert der Variable "value" wird auf eine Nachkommastelle gekürzt
  lcd.print(lbl + String(value, 1) + sign);
}

void loop() {
  //kleine Pause von 1500 Millisekunden
  delay(1500);
  //auslesen der Sensorwerte
  float humidityVal = dhtSensor.readHumidity();
  float tempVal = dhtSensor.readTemperature();

  //prüfen ob die Werte korrekt ausgelesen wurden
  if (isnan(humidityVal) || isnan(tempVal)) {
    Serial.println("Fehler beim lesen der Daten vom DHT11 Sensor!");
    return;
  }
  //den Text vom Display löschen
  lcd.clear();
  //schreiben der Temperatur auf die erste Zeile
  writeText(0, "Temp. ", tempVal, "C");
  //schreiben der rel. Luftfeuchtigkeit auf die zweite Zeile
  writeText(1, "rel.Lft. ", humidityVal, "%");
}

Die Schaltung sowie den Aufbau erläutere ich dir im Detail nochmal im nachfolgenden YouTube-Video.

Arduino UNO R4 Minima - #7 LCD-Display programmieren
Dieses Video auf YouTube ansehen.

Beispiel 9 – Ultraschall-Abstandssensor HC-SR04 anschließen und programmieren

Mit dem Ultraschall-Abstandssensor kannst du wie eine Fledermaus per Ultraschall auf Gegenstände reagieren. Damit könntest du zum Beispiel auf einem Förderband Gegenstände zählen oder auch eine kleine Überwachungsanlage mit einer akustischen Meldung programmieren.

Ultraschall - Abstandssensor HC-SR04
Ultraschall – Abstandssensor HC-SR04

Für den Ultraschall-Abstandssensor benötigst du keine zusätzliche Bibliothek. Der Sensor besteht aus einer Einheit welche Sendet und eine welche Empfängt. Dabei wird ein Ultraschallsignal abgesendet und nach einer Zeit x geprüft, ob dieses empfangen wurde. Aus dieser Zeit wird dann der Abstand berechnet.

Im Beitrag Arduino UNO R3 Projekt – Ultraschallabstandssensor HC-SR04 & Piezo Buzzer habe ich dir bereits ein kleines Projekt mit diesem gezeigt, hier möchte ich nun drei kleine LEDs nutzen, um den Abstand recht simple zu visualisieren.

Schaltung - Arduino UNO R4 Minima mit Ultraschallabstandssensor HC-SR04 und LEDs
Schaltung – Arduino UNO R4 Minima mit Ultraschallabstandssensor HC-SR04 und LEDs

Im Programm habe ich für die LEDs jeweils drei Schwellwerte eingerichtet. Die rote LED soll leuchten, wenn der maximale Wert erreicht wird, die gelbe LED bei 10 cm und die grüne darunter.

//Ultraschallabstandssensor
//Pin Trigger am digitalen Pin D3 angeschlossen
#define trigger 3
//Pin Echo am digitalen Pin D2 angeschlossen
#define echo 2

//LEDs
#define ledRot 4
#define ledGelb 5
#define ledGruen 6

//maximaler und minimaler Wert
//für das aktivieren der LEDs
const int MAX_VALUE = 20;
const int MIN_VALUE = 10;

void setup() {
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);

  pinMode(ledRot, OUTPUT);
  pinMode(ledGelb, OUTPUT);
  pinMode(ledGruen, OUTPUT);
}

float readUltraSonicSensor() {
  //Trigger Signal ausschalten
  digitalWrite(trigger, LOW);
  //2 ms warten
  delayMicroseconds(2);
  //Trigger Signal einschalten
  digitalWrite(trigger, HIGH);
  //10ms warten
  delayMicroseconds(10);
  //Trigger Signal ausschalten
  digitalWrite(trigger, LOW);
  //Das Empfangene Echo Signal in cm umrechnen
  float cm = pulseIn(echo, HIGH) / 58.0;
  //Da der Sensor mit einer Messgenauigkeit von 0,3cm arbeitet können wir das
  //Ergbnis auf 2 Nachkommastellen begrenzen
  return (int(cm * 100.0)) / 100.0;
}

void setLEDs(bool redLED, bool yellowLED, bool greenLED) {
  digitalWrite(ledRot, redLED);
  digitalWrite(ledGelb, yellowLED);
  digitalWrite(ledGruen, greenLED);
}

void loop() {
  //auslesen des Sensorwertes
  float sensorValue = readUltraSonicSensor();
  //Wenn der Sensorwert größer als der Maximale Wert ist, dann...
  if (sensorValue > MAX_VALUE) {
    setLEDs(true, false, false);
    //Wenn der Sensorwert kleiner als der Minimale Wert ist, dann...
  } else if (sensorValue < MIN_VALUE) {
    setLEDs(false, false, true);
  } else {
    //andernfalls, dann...
    setLEDs(false, true, false);
  }
}

Beispiel 10 – serielle Verbindung zweier Mikrocontroller

Im letzten Beispiel möchte ich dir zeigen, wie du per serieller Verbindung Daten zwischen zwei Mikrocontroller austauschen kannst.

Hier verwende ich den Arduino UNO R3 und den neuen Arduino UNO R4 Minima.

Arduino UNO R4 Minima
Arduino UNO R3
Arduino UNO R3
Arduino UNO R4 Minima

Schreibe einen Kommentar Antworten abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Fragen oder Feedback?

Du hast eine Idee, brauchst Hilfe oder möchtest Feedback loswerden?
Support-Ticket erstellen

Newsletter abonnieren

Bleib auf dem Laufenden: Erhalte regelmäßig Updates zu neuen Projekten, Tutorials und Tipps rund um Arduino, ESP32 und mehr – direkt in dein Postfach.

Jetzt Newsletter abonnieren

Unterstütze meinen Blog

Wenn dir meine Inhalte gefallen, freue ich mich über deine Unterstützung auf Tipeee.
So hilfst du mit, den Blog am Leben zu halten und neue Beiträge zu ermöglichen.

draeger-it.blog auf Tipeee unterstützen

Vielen Dank für deinen Support!
– Stefan Draeger

Kategorien

Tools

  • Unix-Zeitstempel-Rechner
  • ASCII Tabelle
  • Spannung, Strom, Widerstand und Leistung berechnen
  • Widerstandsrechner
  • 8×8 LED Matrix Tool
  • 8×16 LED Matrix Modul von Keyestudio
  • 16×16 LED Matrix – Generator

Links

Blogverzeichnis Bloggerei.de TopBlogs.de das Original - Blogverzeichnis | Blog Top Liste Blogverzeichnis trusted-blogs.com

Stefan Draeger
Königsberger Str. 13
38364 Schöningen

Tel.: 01778501273
E-Mail: info@draeger-it.blog

Folge mir auf

  • Impressum
  • Datenschutzerklärung
  • Disclaimer
  • Cookie-Richtlinie (EU)
©2025 Technik Blog | Built using WordPress and Responsive Blogily theme by Superb
Cookie-Zustimmung verwalten
Wir verwenden Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wir tun dies, um das Surferlebnis zu verbessern und um personalisierte Werbung anzuzeigen. Wenn Sie diesen Technologien zustimmen, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn Sie Ihre Zustimmung nicht erteilen oder zurückziehen, können bestimmte Funktionen beeinträchtigt werden.
Funktional Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt. Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
Optionen verwalten Dienste verwalten Verwalten von {vendor_count}-Lieferanten Lese mehr über diese Zwecke
Einstellungen anzeigen
{title} {title} {title}