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
- Beispiel 3 – ein Drehpotentiometer am analogen Pin auslesen
- Beispiel 4 – einen Taster programmieren
- Beispiel 5 – einen Piezo Buzzer programmieren
- Beispiel 6 – einen Servomotor Typ SG90 programmieren
- Beispiel 7 – einen digitalen Temperatur & rel. Luftfeuchtigkeitssensor DHT11 anschließen und auslesen
- Beispiel 8 – ein 16×2 I2C LCD-Display anschließen und Sensordaten anzeigen
- Beispiel 9 – Ultraschall-Abstandssensor HC-SR04 anschließen und programmieren
- Beispiel 10 – serielle Verbindung zweier Mikrocontroller
- Download der Beispiele als ZIP-Datei
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.
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.
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.
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.
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:
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.
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.
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).
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.
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.
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!
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.
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.
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.
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.
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.
Der Piezo Buzzer hat zwei Pins wobei es bei diesem Bauteil egal ist wie du diesen Anschließt.
Zusätzlich muss dieser Piezo Buzzer an einen der 6 möglichen PWM Pins angeschlossen werden!
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
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:
| Komponente | Arduino UNO R4 Minima |
|---|---|
| Servomotor Typ SG90 | |
| braun | GND |
| rot | 5 V |
| orange | D11~ |
| Drehpotentiometer | |
| Pin 1 | 3.3 V |
| Pin 2 | A0 |
| Pin 3 | GND |
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.
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.
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.
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.
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.
Zusätzlich zeige ich dir, wie du die Sensorwerte im seriellen Plotter der Arduino IDE visualisieren kannst.
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.)
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.
Ausgeben von Zeichen auf dem LCD-Display mit der LiquidCrystal Bibliothek
Auf dem hier verwendeten Display können wir 16 Zeichen pro Zeile anzeigen.
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
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.
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.
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.
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.
Über die Pins D0 (RX) & D1 (TX) kannst du jeweils kreuzweise die Verbindung zwischen diesen beiden Mikrocontrollern aufbauen. Jedoch musst du diese Verbindung vor dem Upload eines neuen Sketches auf den Mikrocontroller trennen. Um dieses zu umgehen, kannst du auch ein SoftwareSerial einrichten und bist somit in der Wahl der Pins frei (es muss jedoch zwei der 14 digitalen Pins verwendet werden).
Wie die Daten zwischen zwei Mikrocontroller austauscht werden und du von einem der beiden Mikrocontroller eine LED am anderen aktivieren kannst, zeige ich dir im nachfolgenden YouTube-Video.
Aufbau der Schaltung
Wir müssen hier zwischen Sender & Empfänger unterscheiden. Der Sender verfügt hier lediglich über einen Taster und der Empfänger über eine LED. Beide Mikrocontroller sind über zwei Breadboardkabel via RX & TX verbunden.
Sender
- ein Printtaster,
- zwei Breadboardkabel,
- ein 170 Pin Breadboard
Empfänger
- eine 5 mm LED,
- ein 220 Ohm Vorwiderstand,
- zwei Breadbordkabel,
- ein 170 Pin Breadboard
Programmieren
In dem Aufbau verwende ich wie erwähnt den Arduino UNO R3 und den neuen UNO R4 Minima. Der UNO R4 Minima hat zwei serielle Schnittstellen, daher brauchen wir beim Upload des Programmes an diesem die serielle Verbindung nicht zu trennen. Der UNO R3 hat nur eine serielle Schnittstelle und hier müssen wir explizit die beiden Breadboardkabel an RX & TX vor dem Upload entfernen!
Sender
Der Sender verfügt lediglich über einen Taster und die serielle Verbindung mit dem anderen Mikrocontroller.
//Bibliothek zum entprellen eines Tasters
#include <Bounce2.h>
//Taster am digitalen Pin D4 angeschlossen
#define taster 4
//initialisieren eines Bounce2-Button Objektes
Bounce2::Button button = Bounce2::Button();
//Feld zum speichern des Zustandes
bool state = false;
void setup() {
//beginn der seriellen Kommunikation mit 9600 baud
Serial.begin(9600);
//Der Taster ist über den internen 10 kOhm PullUp Widerstand angeschlossen
button.attach(taster, INPUT_PULLUP);
//Intervall für das entprellen
button.interval(5);
//Wenn der Taster gedrückt ist, dann soll dieses als LOW interpretiert werden.
button.setPressedState(LOW);
}
void loop() {
//aktualisieren des Button Objektes
button.update();
//Wenn der Taster betätigt wird, dann...
if (button.pressed()) {
//Umkehren des Status, dieses wird über das Ausrufezeichen gemacht.
state = !state;
//Senden des Textes "AN" wenn der Status true ist und "AUS" wenn dieser
//false ist.
Serial.println(state ? "AN" : "AUS");
}
}
Empfänger
Der Empfänger wiederum verfügt über eine LED welche mit dem Taster des anderen Mikrocontrollers aktiviert / deaktiviert wird.
//LED am digitalen Pin D4 angeschlossen
#define led 4
void setup() {
//beginn der seriellen Kommunikation mit 9600 baud
//über Serial1 (RX & TX Pins)
Serial1.begin(9600);
//Pin der LED als Ausgang definieren
pinMode(led, OUTPUT);
}
void loop() {
//Wenn Daten am Serial1 anliegen, dann...
if (Serial1.available() > 0) {
//Auslesen der gesamten Zeile (bis zu einem Zeilenumbruch)
String val = Serial1.readString();
//Entfernen des Zeilenumbruchs und des Zeilenvorschubs (\r\n)
val.replace("\r", "");
val.replace("\n", "");
//Wenn der Wert der Variable val gleich "AN" ist, dann...
if (val == "AN") {
//Ausgeben des Textes "LED AN!" auf die serielle Schnittstelle
//am USB-Anschluss
Serial.println("LED AN!");
} else if (val == "AUS") {
//Ausgeben des Textes "LED AUS!" auf die serielle Schnittstelle
//am USB-Anschluss
Serial.println("LED AUS!");
} else {
//Manchmal werden zusätzliche Zeichen übertragen dann soll eine
//Fehlermeldung ausgegeben werden.
Serial.println("Fehler!");
}
//aktivieren oder deaktieren der LED je nach Wert der Variable val.
digitalWrite(led, val == "AN" ? 1 : 0);
}
}
Download der Beispiele als ZIP-Datei
Wenn du dir etwas Schreibarbeit sparen möchtest, dann kannst du dir hier alle gezeigten Beispiele als ZIP-Datei herunterladen.