- RGB LED
- Eine LED per Taste aktivieren
- Potentiometer
- Neigungssensor
- Feuchtigkeits-Sensor
- Tropfensensor
- Relais
- Bewegungsmelder
- Ultraschall-Abstandsmesser
- Ultraschallmesser mit LCD Display
- Fernbedienung
- RFID Kit
- Übersichtseite mit Sensoren für Arduino
- Servo-Motoren
- Schritt-Motoren
Themen heute
Funduino – Anleitungen für Arduino

Das teilweise hier im Kurs verwendete Funduino Standard-UNO Lernset und viele der hier gezeigten Arduino-Scripte orientieren sich an dieser gut gemachten Website
Elegoo StarterKit

Das Elegoo-Arduino-StarterKit verwendet teilweise andere Libraries als Funduino.
Achtung
Alle, die ein Elegoo-Arduino-StarterKit bekommen haben, müssen sich diese Libraries installieren, damit die Beispiele und Übungen funktionieren!
Verwendete Libraries
Bitte ladet deswegen die Elegoo-Libraries herunter und fügt diese bei den Arduino-Libraries ein!
- Am Mac findet Ihr die Libraries bei Documents/Arduino/libraries
- Am PC sind die Libraries hier zu finden: My Documents\Arduino\libraries\
Elegoo Tutorials
Diese befinden sich auf der beigefügten CD-ROM – ich habe Euch hier die deutsche Version zum Download vorbereitet!
Temperatur- und Luftfeuchtigkeits-Sensor-Kombination

Der Sensor kombiniert das Messen von Temperatur und Luftfeuchtigkeit
Alle 4 Sekunden werden die Temperatur- und Feuchtigkeitswerte ausgelesen und auf dem Serial Monitor angezeigt
- schwarzes Kabel zu GRD
- rotes Kabel zu 5V
- gelbes Kabel zu PIN 2
Arduino
//www.elegoo.com
//2018.10.25
#include <dht_nonblocking.h>
#define DHT_SENSOR_TYPE DHT_TYPE_11
static const int DHT_SENSOR_PIN = 2;
DHT_nonblocking dht_sensor( DHT_SENSOR_PIN, DHT_SENSOR_TYPE );
void setup( ){
Serial.begin( 9600);
}
void loop( ){
float temperature;
float humidity;
/* Measure temperature and humidity. If the functions returns
true, then a measurement is available. */
if( measure_environment( &temperature, &humidity ) == true )
{
Serial.print( "T = " );
Serial.print( temperature, 1 );
Serial.print( " deg. C, H = " );
Serial.print( humidity, 1 );
Serial.println( "%" );
}
}
// =========== externe Funktion ============
/*
* Poll for a measurement, keeping the state machine alive. Returns
* true if a measurement is available.
*/
static bool measure_environment( float *temperature, float *humidity ){
static unsigned long measurement_timestamp = millis( );
/* Measure once every four seconds. */
if( millis( ) - measurement_timestamp > 3000ul )
{
if( dht_sensor.measure( temperature, humidity ) == true )
{
measurement_timestamp = millis( );
return( true );
}
}
return( false );
}
RGB LED

Die RGB-LED kann in verschiedenen Farben leuchten…
3x Widerstand mit 200 Ω einbauen!
Beachtet Zeilen 33 – 37:
In diesen Zeilen ist eine externe Funktion definiert, die aus der loop-Funktion aufgerufen wird. Das ist besser lesbar und hält den Code kürzer…
Arduino
int ledBlau = 3; // blau = Pin 3
int ledRot = 5; // rot = Pin 5
int ledGruen = 6; // grün = Pin 6
int helligkeit = 100; // Helligkeitswert
int vzLang = 1500; // lange Verzögerung
int vzKurz = 500; // kurze Verzögerung
void setup(){
pinMode(ledBlau, OUTPUT);
pinMode(ledGruen, OUTPUT);
pinMode(ledRot, OUTPUT);
}
void loop(){
analogWrite(ledBlau, helligkeit); // blau ein
delay(vzLang);
allesAus();
delay(vzKurz);
analogWrite(ledRot, helligkeit); // rot ein
delay(vzLang);
allesAus();
delay(vzKurz);
analogWrite(ledGruen, helligkeit); // grün ein
delay(vzLang);
allesAus();
delay(vzKurz);
}
// externe Funktion – praktisch, um den Code lesbarer zu halten!
void allesAus(){
analogWrite(ledBlau, 0);
analogWrite(ledRot, 0);
analogWrite(ledGruen, 0);
}
Gemischte Farben
Durch das gleichzeitige Einschalten von mehreren integrierten LEDs kann man natürlich auch Farben mischen…
Arduino
// Code von https://funduino.de/nr-20-rgb-led
int LEDblau = 3; // Farbe blau an Pin 3
int LEDrot = 5; // Farbe rot an Pin 5
int LEDgruen = 6; // Farbe gruen an Pin 6
int p = 1000; // p ist eine Pause mit 1000ms also 1 Sekunde
int brightness1a = 150; // Zahlenwert zwischen 0 und 255 – gibt die Leuchtstärke der einzelnen Farbe an
int brightness1b = 150; // Zahlenwert zwischen 0 und 255 – gibt die Leuchtstärke der einzelnen Farbe an
int brightness1c = 150; // Zahlenwert zwischen 0 und 255 – gibt die Leuchtstärke der einzelnen Farbe an
int dunkel = 0; // Zahlenwert 0 bedeutet Spannung 0V – also LED aus
void setup() {
pinMode(LEDblau, OUTPUT);
pinMode(LEDgruen, OUTPUT);
pinMode(LEDrot, OUTPUT);
}
void loop() {
analogWrite(LEDgruen, brightness1c); // gruen und rot ein = gelb
analogWrite(LEDrot, brightness1b);
delay(p);
analogWrite(LEDgruen, dunkel); // gruen und rot aus = gelb aus
analogWrite(LEDrot, dunkel);
analogWrite(LEDgruen, brightness1c); // gruen und blau ein = türkis
analogWrite(LEDblau, brightness1b);
delay(p);
analogWrite(LEDgruen, dunkel); // gruen und blau aus = türkis aus
analogWrite(LEDblau, dunkel);
analogWrite(LEDrot, brightness1b); // rot und blau ein = lila
analogWrite(LEDblau, brightness1b);
delay(p);
analogWrite(LEDrot, dunkel); // rot und blau aus = lila aus
analogWrite(LEDblau, dunkel);
}
mehr dazu bei https://funduino.de/nr-20-rgb-led
Eine LED per Taste aktivieren

Baut einen Widerstand mit 1 KΩ beim Schalter ein!
Die LED leuchtet, solange die Taste gedrückt ist…
Arduino
int led = 13;
int taste = A0;
int tastenzustand = LOW; // statt HIGH/LOW kann man auch 0/1 verwenden!
void setup() {
pinMode(led, OUTPUT);
pinMode(taste, INPUT);
}
void loop() {
// liest den Tastenzustand in eine Variable
tastenzustand = digitalRead(taste);
// nur wenn die Taste gedrückt ist, ist die LED an
if (tastenzustand == HIGH) {
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}
}
mehr dazu unter: https://funduino.de/nr-5-taster-am-arduino
Eine LED per Taste 5 Sekunden aktivieren

Der Aufbau ist identisch mit dem vorherigen – nur im Arduino Sketch ist eine neue Zeile enthalten!
Die LED leuchtet für 5 Sekunden, nachdem die Taste gedrückt wurde…
Arduino
int led = 13;
int taste = A0;
int tastenzustand = LOW;
void setup() {
pinMode(led, OUTPUT);
pinMode(taste, INPUT);
}
void loop() {
tastenzustand = digitalRead(taste);
// nur wenn die Taste gedrückt ist, geht die LED an
if (tastenzustand == HIGH) {
digitalWrite(led, HIGH);
delay(5000); // hiermit bleibt die LED 5 Sekunden an
} else {
digitalWrite(led, LOW);
}
}
mehr dazu unter: https://funduino.de/nr-5-taster-am-arduino
LED per Taste toggeln

Die LED leuchtet, nachdem die Taste gedrückt ist, beim nächsten Tastendruck geht die LED wieder aus
Arduino
int led = 13;
int taste = A0;
int tastenZustand = 0;
int ledZustand = -1; // 1 = led an, -1 = led aus
void setup() {
pinMode(led, OUTPUT);
pinMode(taste, INPUT);
Serial.begin(9600);
}
void loop() {
tastenZustand = digitalRead(taste);
// immer wenn taste gedrück wurde, ändert sich ledZustand…
if (tastenZustand == HIGH) {
// bei jedem Betätigen der Taste wird der ledZustand getoggelt
ledZustand = -ledZustand;
}
if (ledZustand == 1) {
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}
Serial.print("ledZustand: ");
Serial.println(ledZustand);
delay(200);
}
mehr dazu unter: https://funduino.de/nr-5-taster-am-arduino
Übung 8: LED mit 2 Tasten ansteuern

Wie müsst Ihr den Aufbau erweitern?
Aufgabe
Erweitert den Sketch so, dass es zwei Tasten (und zwei Widerstände mit 1 KΩ) gibt:
- Drückt man auf die 1. Taste, bleibt die LED 5sek an
- Drückt man auf die 2. Taste, bleibt die LED 0,5sek an
Speichert den Sketch unter led_via_2_tasten
Potentiometer

Der Drehregler legt hier fest, in welcher Geschwindigkeit die LED blinkt!
Achtung: Die Kontakte des Potentiometers im Breadboard sind nicht gut – ich habe die Kabel-Anschlüsse in die selben Löcher gesteckt wie die „Krallen“ des Drehreglers, sonst ging es nicht…
Arduino
int poti= A0; // Der Drehregler
int led = 13;
int potiWert = 0; // Werte zwischen 0 und 1023
void setup() {
pinMode (led, OUTPUT);
Serial.begin(9600);
}
void loop(){
// Werte des Potentiometers werden in die Variable "potiWert" eingelesen
potiWert =analogRead(poti); //Drehregler (Poti) zwischen 0 und 1023
// blink-Ablauf
digitalWrite (led, HIGH);
delay (potiWert);
digitalWrite (led, LOW);
delay (potiWert);
Serial.print("potiWert: ");
Serial.println(potiWert);
}
mehr dazu bei https://funduino.de/nr-7-potentiometer
Übung 9: Kombi aus Taste, Potentiometer und Piezo-Element

Erweitert den Versuchsaufbau entsprechend!
Aufgabe
Erweitert den gerade aufgebauten Potentiometer-Sketch um folgendes:
- die LED soll erst blinken, wenn davor die Taste gedrückt wurde
- auch das Piezo-Element soll erst dann Töne von sich geben, wenn die Taste gedrückt wurde
- die Töne sollen sich analog zum Blinken der LED verändern, wenn man am Potentiometer dreht
- bei einem erneuten Drücken der Taste hört die LED auf, zu blinken und auch das Piezo-Element verstummt
Passt folgende Codezeile auf die Werte des Potentiometers an:
// https://www.arduino.cc/reference/en/language/functions/math/map/
int pitch = map(sensorValue, sensorLow, sensorHigh, 50, 4000);
Schaut Euch dazu noch mal das entsprechende Script zu Piezo-Elementen an!
Speichert diesen Sketch unter taste_piezo_potentiometer
Neigungssensor

Dieser Sensor erkennt nur zwei Stufen, nämlich “geneigt” oder “nicht geneigt”. Dazu rollen im Inneren des Sensors zwei frei bewegliche Metallkugeln umher. Sobald der Sensor so gekippt ist, dass eine der Kugeln im Inneren gegen die zwei Kontakte stößt, werden diese beiden Kontakte miteinander verbunden. Das ist dann so, als wäre ein Taster gedrückt, und der elektrische Strom kann von einem Kontakt zum anderen Kontakt fließen.
Neigungssensor

Verwendet dazu einen 1kΩ Widerstand!
Arduino
int led = 13; // eingebaute LED
int neigungsPin = 7; // Neigungssensor an PIN 7 angeschlossen
int neigung = LOW; // kann nur LOW oder HIGH sein
void setup() {
pinMode(led, OUTPUT);
pinMode(neigungsPin, INPUT);
}
void loop() {
neigung = digitalRead(neigungsPin);
if (neigung == HIGH) {
digitalWrite(led, LOW);
} else {
digitalWrite(led, HIGH);
}
// Verzögerung als Dämpfung, sonst flackert LED sehr leicht
// kommentiert nächste Zeile mal aus…
delay(200);
}
Weiterführendes bei https://funduino.de/nr-09-arduino-neigungssensor
Dieser Neigungssensor ist sehr grob – er kennt fast nur 90° Neigungen. In Euren Smartphones sind deutlich empflindlichere Sensoren eingebaut…
Feuchtigkeits-Sensor

Ihr könnt den Sensor auch direkt in das Breadboard stecken
Achtung: Feuchtigkeitssensor ist im Elegoo-StarterKit (kleine Schachtel) nicht enthalten!

Sensor kann z.B. verwendet werden, um die Boden-Feuchtigkeit zu messen und somit genau zu wissen, ob eine Pflanze gegossen werden muß…
Steckt den Sensor mal in feuchte Hände oder ein Glas Wasser und beobachtet, wie sich die Sensor-Werte ändern!
Arduino
int sensorPin = A0; // PIN A0 für Sensor-Kabel
int sensorValue = 0; // Wert des Sensors
int LED = 13;
void setup() {
Serial.begin(9600);
pinMode(LED, OUTPUT);
}
void loop() {
// Wert zwischen 0 und 1023
sensorValue = analogRead(sensorPin);
Serial.print("Feuchtigkeit: " );
Serial.println(sensorValue);
// wenn Wert > 90, geht die LED an
if (sensorValue > 90){
digitalWrite(LED, HIGH);
} else {
digitalWrite(LED, LOW);
}
// Messung jede Sekunde
delay(1000);
}
Übungen 10: Feuchtigkeitssensor mit LED und Piezo

Achtung: Feuchtigkeitssensor ist im Elegoo-StarterKit (kleine Schachtel) nicht enthalten!
Erweitert den gerade gezeigten Sketch mit dem Feuchtigkeitssensor um eine grüne LED und ein Piezo-Element:
- die grüne LED leuchtet, wenn die Feuchtigkeit ausreicht
- das Piezo-Element gibt Geräusche von sich, wenn der Feuchtigkeitssensor „trocken läuft“
Bitte legt selber die Grenzen fest, wann die Feuchtigkeitswerte einen Alarm auslösen!
Tropfensensor

Mit einem Tropfensensor oder auch Flüssigkeitssensor kann man wie es der Name schon sagt eine Flüssigkeit detektieren. Dazu muss sich die Flüssigkeit direkt auf dem Sensor befinden. Es reicht bereits ein kleiner Tropfen aus, um einen eindeutigen Messwert zu erhalten.
Man kann den Sensor zum Beispiel als Regensensor verwenden. Sobald ein Tropfen auf den Sensor trifft, kann das Arduino-Board eine Aktion ausführen wie z.B. eine Markise einrollen, Jalousien schließen, einen Alarm auslösen oder einen Scheibenwischer betätigen.
Warnung von funduino
Wir empfehlen, aufgrund der Elektrolyse durch das Wasser bzw. die Feuchtigkeit an den Sensoren, die Messungen nicht in einem Sekundenabstand durchzuführen. Aus Erfahrungen durch Tests direkt im Wasser, empfehlen wir einen Abstand von 15 Minuten zwischen jeder Messung. Bei Messungen im Sekundenbereich, bei direktem und durchgängigen Wasserkontakt, entstehen durch die Elektrolyse nach ca. 24 Stunden Schäden am Sensor.
Arduino
// https://funduino.de/nr-17-tropfensensor
int messwert = 0; //Unter der Variablen "messwert" wird später der Messwert des Sensors gespeichert.
void setup() {
Serial.begin(9600);
}
void loop() {
messwert = analogRead(A0); //Die Spannung an dem Sensor wird ausgelesen und unter der Variable „messwert“ gespeichert.
Serial.print("Feuchtigkeits-Messwert:"); //Ausgabe am Serial-Monitor: Das Wort „Feuchtigkeits-Messwert:"
Serial.println(messwert); //und im Anschluss der eigentliche Messwert.
delay(500); // Zum Schluss noch eine kleine Pause, damit nicht zu viele Zahlenwerte über den Serial-Monitor rauschen.
}
mehr dazu unter https://funduino.de/nr-17-tropfensensor
Relais
Beim Basteln mit Arduino sind Relais sehr wichtig. Relais sind Schalter, die einen größeren Strom fließen lassen können, als es vom Mikrocontroller aus möglich wäre. Mit dem Arduino aktiviert man über einen ganz kleinen Strom das Relais, welches dann auch größere elektrische Geräte betreiben kann.

Mit einem Relais kann man sogar 230V-Sachen ein- und ausschalten. Dies ist aber gefährlich, wenn Ihr nicht genau wisst, was Ihr tut!
Bewegungsmelder

Ein PIR Sensor nimmt Temperaturänderungen von bewegten, warmen Objekten in seiner Umgebung wahr…
Achtung
Der PIR-Sensor ist im Elegoo-StarterKit (kleine Schachtel) nicht enthalten! Ich habe ein paar Sensoren dabei…
Bei dem hier gezeigten Sketch fängt ein Piezo-Element an zu piepsen, wenn der Sensor Bewegung erkennt. Da der Sensor ca. 60sek benötigt, um „warmzuwerden“, ist bei „setup()“ eine 60.000 Milisekunde lange „Aufwärm-Pause“ eingebaut. Erst dann fängt der Sensor zum Arbeiten an. Damit man weiss, wann der Sensor aktiviert wurde, leuchtet dann eine rote LED.
Arduino
// mehr dazu bei https://funduino.de/nr-8-bewegungsmelder
int piezo = 5; // Anschluss des Piezo-Elementes
int pir = 7; // Anschluss des PIR-Bewegungsmelders
int pir_status = LOW; // Zustand des PIR-Bewegungsmelders, kann LOW oder HIGH sein
int LED = 13; // die (interne) LED leuchtet, wenn der Sensor arbeitet
void setup() {
pinMode(piezo, OUTPUT);
pinMode(LED, OUTPUT);
pinMode(pir, INPUT);
Serial.begin(9600);
Serial.println("PIR-Sensor braucht 60sek um warm zu werden.");
Serial.println("Sobald der Sensor startklar ist, geht die LED an!");
// ACHTUNG: Der PIR Sensor braucht ca. 60 sek um "warm" zu werden und vernünftig zu funktionieren!
// entsprechende Verzögerung hier eingebaut, so dass der Sensor erst nach 60.000 Milisek startet
delay(60000);
Serial.println("PIR-Sensor startklar!");
}
void loop() {
digitalWrite(LED, HIGH);
pir_status = digitalRead(pir);
Serial.print("pir_status: ");
if (pir_status == HIGH) { // Wenn Bewegung erkannt wird, soll Piezo Töne machen
Serial.println("Bewegung erkannt!");
playTone(300, 1600);
delay(3000); // nach 3sek soll Piepsen wieder aufhören
digitalWrite(piezo, LOW);
} else { // Wenn keine Bewegung erkannt wird, Ton aus
Serial.println("keine Bewegung!");
digitalWrite(piezo, LOW);
}
delay(500);
}
// duration in mSecs, frequency in hertz
void playTone(long duration, int freq) {
duration *= 1000;
int period = (1.0 / freq) * 1000000;
long elapsed_time = 0;
while (elapsed_time < duration) {
digitalWrite(piezo, HIGH);
delayMicroseconds(period / 2);
digitalWrite(piezo, LOW);
delayMicroseconds(period / 2);
elapsed_time += (period);
}
}
mehr dazu bei https://funduino.de/nr-8-bewegungsmelder
Zusammen mit einem Relais könnte man damit z.B. eine Leuchte, eine Stereoanlage, einen Ventilator, eine Kamera (.…) anschalten, sobald ein Tier oder ein Mensch in den Bereich des aktiven Bewegungsmelders kommt…
Ultraschall-Messungen

Arduino-kompatibler Ultraschall-Sensor
Ultraschallsensoren als Abstandssensoren sind in der Lage, Objekte berührungslos zu erkennen und ihre Entfernung zum Sensor zu messen. Der Ultraschallsensor strahlt zyklisch einen kurzen, hochfrequenten Schallimpuls aus. Dieser pflanzt sich mit Schallgeschwindigkeit in der Luft fort. Trifft der Ultraschallimpuls auf einen Gegenstand, wird er reflektiert. Das so entstehende Echo wird vom Sensor wieder aufgenommen und aus der Zeitspanne zwischen dem Senden und dem Empfangen des Schallimpulses, wird der Abstand zum Objekt berechnet. Ultraschall Sensoren für die Abstandsmessung sind in der Lage, Objekte aus unterschiedlichen Materialien zu erfassen wie Metall, Holz oder Kunststoff. Nur schalldämpfende Stoffe, wie z. B. Watte oder glatte schräg stehende Flächen können schlecht vom Ultraschallsensor erfasst werden.
Ihr kennt diese Sensoren bestimmt aus Autos, wo sie beim Einparken oder Rückwärtsfahren behilflich sind…
Ultraschall-Abstandsmesser

Achtung: Der Ultraschall-Sensor ist einer der wenigen Sensoren, der 4 Anschlüsse hat!
Arduino-Library
Damit der Sketch funktioniert, müsst Ihr die NewPing Arduino Library for Arduino herunterladen und bei Arduino hinzufügen:
Herunterladen und installieren
- Die Library NewPing auf den eigenen Rechner herunterladen
- Wie auf dem Screenshot gezeigt, anschliessend bei Arduino hinzufügen

Library einfügen
-
Bei dem gewünschen Sketch die Library "NewPing" auswählen
-
Sie sollte dann ganz oben im Sketch aufgeführt werden
#include <NewPing.h>
Achtung
Ihr müsst beim Serial Monitor eine Baud-Rate von 115200 einstellen – sonst geht es nicht!
Arduino
/*
Ultrasonic-Rangefinder
hat 4 PINS!
GND pin to ground
VCC pin to 5V
TRIG pin to digital pin 8
ECHO pin to digital 7
Quelle : https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home#!simple-newping-sketch
*/
// Library laden: https://bitbucket.org/teckel12/arduino-new-ping/downloads/NewPing_v1.9.1.zip
#include <NewPing.h>
const int TRIGGER_PIN = 8;
const int ECHO_PIN = 7;
const int Led = 13; // die LED
int MAX_DISTANCE = 200; // bis 200cm Abstand messen
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
void setup() {
Serial.begin(115200); // Serial Monitor entsprechend umschalten!
pinMode(Led, OUTPUT);
}
void loop() {
delay(50); // min 29
unsigned int cm = sonar.ping_cm();
Serial.print("Ping: ");
Serial.print(cm);
Serial.println("cm");
if (cm == 0 && digitalRead(ECHO_PIN) == HIGH) {
pinMode(ECHO_PIN, OUTPUT);
digitalWrite(ECHO_PIN, LOW);
delay(100);
pinMode(ECHO_PIN, INPUT);
}
// LED geht an, wenn etwas näher als 20cm ist
if (cm < 20) {
digitalWrite(Led, HIGH);
} else {
digitalWrite(Led, LOW);
}
}
Übung 11: Ultraschall-Sensor mit Piezo-Warnung

Wie müsst Ihr den gerade gezeigten Ultraschall-Sketch umbauen, damit ein Warnton erklingt, wenn sich ein Objekt näher als 50cm am Ultraschall-Sensor befindet?
Erweiterung
- Wie müsst Ihr den Code ändern, damit sich das Piezo-Geräusch verändert, wenn Ihr den Abstand zwischen Ultraschall-Sensor und Objekt verändert?
- Könnt Ihr eine LED einbauen, die immer heller wird, wenn sich der Abstand zwischen Ultraschall-Sensor und Objekt verändert? (Achtung: Das geht nicht mit der LED an PIN 13!)
Schaut Euch dazu den Sketch „Light Teremin – ein schauriges Musikinstrument“ an, den wir beim letzten Treffen durchgemacht haben!
Speichert den Sketch als Ultraschall_Piezo
LCD Display

Schaltkreis-Abbildung von Elegoo.com

Hängt das LCD Display entsprechend des hier gezeigten Schaltkreises an den Arduino
Arduino-Code
//www.elegoo.com
//2016.12.9
/*
LiquidCrystal Library - Hello World
Demonstrates the use of a 16x2 LCD display. The LiquidCrystal
library works with all LCD displays that are compatible with the
Hitachi HD44780 driver. There are many of them out there, and you
can usually tell them by the 16-pin interface.
This sketch prints "Hello World!" to the LCD
and shows the time.
The circuit:
* LCD RS pin to digital pin 7
* LCD Enable pin to digital pin 8
* LCD D4 pin to digital pin 9
* LCD D5 pin to digital pin 10
* LCD D6 pin to digital pin 11
* LCD D7 pin to digital pin 12
* LCD R/W pin to ground
* LCD VSS pin to ground
* LCD VCC pin to 5V
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)
Library originally added 18 Apr 2008
by David A. Mellis
Library modified 5 Jul 2009
by Limor Fried (http://www.ladyada.net)
Example added 9 Jul 2009
by Tom Igoe
Modified 22 Nov 2010
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/LiquidCrystal
*/
// include the library code:
#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("Hello, World!");
}
void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// print the number of seconds since reset:
lcd.print(millis() / 1000);
}
Übung 12: Ultraschallmesser mit LCD Display

Die Verkabelung des LCD Displays ist identisch zum vorherigen Sketch!
Kombiniert das LCD-Display mit dem Ultraschall-Abstandsmesser:
- lasst Euch die Abstands-Werte auf dem Display ausgeben
-
- Zeile: Abstand:
-
- Zeile: Aktueller Wert und Masseinheit "cm"
Infrarot-Fernbedienung

Mit Hilfe eines Infrarotempfängers kann das Arduinoboard die Befehle einer Infrarotfernbedienung auswerten. Die Daten werden dabei in Form von Infrarotlicht von der Fernbedienung zum Empfänger gesendet.

benötigte Library installieren
Library als Zip-Datei herunterladen und via „Include Library > Add ZIP-Library…“ installieren!
Arduino
/*
IRremote: IRrecvDemo - demonstrates
receiving IR codes with IRrecv
An IR detector/demodulator must be
connected to the input RECV_PIN.
Version 0.1 July, 2009
Copyright 2009 Ken Shirriff
http://arcfn.com
*/
//Infromationen über das ursprüngliche Programm „IrrecvDemo“.
// Library als Zip-Datei herunterladen und installieren!
// https://downloads.arduino.cc/libraries/github.com/z3t0/IRremote-2.2.3.zip
#include <IRremote.h> // Das Programm greift an dieser Stelle auf eine „Library“ zurück. Das erleichtert einem viel Arbeit. Denn das Infrarotlicht wird mit einem Code verschlüsselt gesendet. Um diesen Code selber auszulesen und in passende Werte umzuwandeln, wären sehr viele Zeilen Code erforderlich.
int RECV_PIN = 11; // Der Kontakt der am Infrarotsensor die Daten ausgibt, wird mit Pin 11 des Arduinoboards verbunden.
IRrecv irrecv(RECV_PIN); // An dieser Stelle wird ein Objekt definiert, dass den Infrarotsensor an Pin 11 ausliest.
decode_results results; // Dieser Befehl sorgt dafür, dass die Daten, die per Infrarot eingelesen werden unter „results“ abgespeichert werden.
void setup() {
Serial.begin(9600); //Im Setup wird die Serielle Verbindung gestartet, damit man sich die Empfangenen Daten der Fernbedienung per seriellen Monitor ansehen kann.
pinMode (13, OUTPUT);
irrecv.enableIRIn(); //Dieser Befehl initialisiert den Infrarotempfänger.
}
void loop() { //Der loop-Teil fällt durch den Rückgriff auf die „library“ sehr kurz aus.
if (irrecv.decode(&results)) { //Wenn Daten empfangen wurden,
Serial.println(results.value, DEC); //werden sie als Dezimalzahl (DEC) an den Serial-Monitor ausgegeben.
// die Ausgabewerte wieder in Buchstaben/Zahlen übersetzen,
// die man auf der Fernbedienung gedrückt hat
wertUebersetzen();
irrecv.resume(); //Der nächste Wert soll vom IR-Empfänger eingelesen werden
}
}
// ACHTUNG, Werte von "meiner" Fernbedienung
// kann bei Euch anders sein – im Serial Monitor bitte selber auslesen!
void wertUebersetzen() {
if (results.value == 16738455) {
Serial.println("Taste 1 gedrueckt");
} else if (results.value == 16750695) {
Serial.println("Taste 2 gedrueckt");
} else if (results.value == 16756815) {
Serial.println("Taste 3 gedrueckt");
} else if (results.value == 16724175) {
Serial.println("Taste 4 gedrueckt");
} else if (results.value == 16718055) {
Serial.println("Taste 5 gedrueckt");
} else if (results.value == 16753245) {
Serial.println("Taste A gedrueckt");
}
}
mehr dazu unter https://funduino.de/nr-11-fernbedienung
Anwendungen
… mit diesem Knowhow kann man sich dann auch z.B. Programmierbarer Fernauslöser für Digitalkameras bauen und somit Zeitrafferbilder machen.
Universal Arduino Remote

Übung 13: Kombination aus Infrarot-Fernbedienung und LCD-Display

Kombiniert die Infrarot-Fernbedienung mit dem LCD-Display. Lasst den Arduino auf dem LCD-Display die Ziffern und Buchstaben ausgeben, die Ihr auf der Fernbedienung drückt.
Extra-Aufgabe
Was müsst Ihr noch eingeben, dass eine LED auf PIN 13 angegeht, wenn Ihr auf der Fernbedienung die Taste "A" betätigt? Wie bekommt Ihr die LED wieder aus, wenn eine andere Taste gedrückt wird?
Tip
Schaut Euch beim vorherigen Sketch mal an, was ich in der Funktion wertUebersetzen() gemacht habe…
Speichert den Sketch als fernbedienung_lcd_display
RFID Kit

Der RFID („radio-frequency identification“) Reader wird verwendet, um von RFID Sendern (auch „RFID Tags“ genannt) per Funk einen bestimmten Code auszulesen. Jeder Sender hat dabei nur einen einmaligen ganz individuellen Code. Damit lassen sich mit dem Arduino Schließanlagen oder ähnliche Projekte verwirklichen, bei denen sich eine Person mit einem Sender identifizieren soll.
Verkabelung
Die Verkabelung ist relativ umfangreich – schaut Euch das Schema von Funduino an:

Library bei Arduino hinzufügen
Bitte fügt in Arduino via Include Library > Manage Libraries die Library „MFRC522“ hinzu. Dazu im Bibliothekenverwalter den Suchbegriff „RFID“ eingeben und dann die Library „Adafruit MFRC630 RFID“ installieren.
Arduino
// https://funduino.de/nr-18-rfid-kit
#include <SPI.h> // SPI-Bibiothek hinzufügen
#include <MFRC522.h> // RFID-Bibiothek hinzufügen
#define SS_PIN 10 // SDA an Pin 10
#define RST_PIN 9 // RST an Pin 9
MFRC522 mfrc522(SS_PIN, RST_PIN); // RFID-Empfänger benennen
void setup() {
Serial.begin(9600); // Serielle Verbindung starten (Monitor)
SPI.begin(); // SPI-Verbindung aufbauen
mfrc522.PCD_Init(); // Initialisierung des RFID-Empfängers
}
void loop() {
// Wenn keine Karte in Reichweite ist...
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return; // ...springt das Programm zurück vor die if-Schleife, womit sich die Abfrage wiederholt.
}
// Wenn kein RFID-Sender ausgewählt wurde
if ( ! mfrc522.PICC_ReadCardSerial()) {
return; // ...springt das Programm zurück vor die if-Schleife, womit sich die Abfrage wiederholt.
}
Serial.print("Die ID des RFID-TAGS lautet:"); // "Die ID des RFID-TAGS lautet:" wird auf den Serial Monitor geschrieben.
for (byte i = 0; i < mfrc522.uid.size; i++) {
Serial.print(mfrc522.uid.uidByte[i], HEX); // Dann wird die UID ausgelesen, die aus vier einzelnen Blöcken besteht und der Reihe nach an den Serial Monitor gesendet. Die Endung Hex bedeutet, dass die vier Blöcke der UID als HEX-Zahl (also auch mit Buchstaben) ausgegeben wird
Serial.print(" "); // Der Befehl „Serial.print(" ");“ sorgt dafür, dass zwischen den einzelnen ausgelesenen Blöcken ein Leerzeichen steht.
}
Serial.println(); // Mit dieser Zeile wird auf dem Serial Monitor nur ein Zeilenumbruch gemacht .
}
mehr dazu unter https://funduino.de/nr-18-rfid-kit
Übersichtseite mit Sensoren für Arduino

http://linksprite.com/wiki/index.php5?title=Advanced_Sensors_Kit_for_Arduino
Hier sind fast alle Sensoren, die bei „40 in 1 Sensorkit for Arduino“ enthalten sind, zusammen mit Beispiel-Code aufgelistet: https://tkkrlab.nl/wiki/Arduino_37_sensors
Servo-Motor ansteuern

Verbindet den Motor – wie auf dem Foto unten gezeigt – mit Breadboard und Arduino. Verwendet dabei möglichst die gleichen Farben, damit Ihr den Motor richtig anschliessen könnt. Es kann sein, dass bei Eurem Motor die Farben anders sind…
Achtung
Die am Samstag installierten Libraries von Elegoo enthalten auch die Library Servo, die sich nicht mit der Default-Library von Arduino „verträgt“ – bitte löscht die von Elegoo eingefügte und startet Arduino neu.
Die Libraries findet Ihr hier:
- Am Mac findet Ihr die Libraries bei Documents/Arduino/libraries
- Am PC sind die Libraries hier zu finden: My Documents\Arduino\libraries\
Arduino
// http://www.oomlout.com/oom.php/products/ardx/circ-04
// Libary einfügen!
#include <Servo.h>
// create servo object to control a servo
// a maximum of eight servo objects can be created
Servo myservo;
int zeit = 1000; // wie lange soll der Arm in der Position stehen bleiben
int counter = 0; // der Servo soll nur eine bestimmte Anzahl machen und dann aufhören
void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop() {
// der Servo soll nur eine bestimmte Anzahl machen und dann aufhören
if (counter < 5) {
// Mitte
myservo.write(90); // Gradangabe! nur Werte zwischen 0 und 180 möglich!
delay(zeit);
myservo.write(0);
delay(zeit);
myservo.write(90);
delay(zeit);
myservo.write(180);
delay(zeit);
// Kurzschreibweise von counter = counter + 1;
counter++;
}
}

Übung 14: Scheibenwischer

Erweitert den Aufbau um einen Button und den dazugehörigen, richtigen Widerstand!
Erweitert den gerade gezeigten Servo-Motor-Code so, dass sich der Motor wie ein Scheibenwischer verhält und dreimal „die Scheibe wischt“, nachdem der Knopf gedrückt wurde.
Stellt sicher, dass Ihr den Knopf immer wieder betätigen könnt und der „Scheibenwischer“ jedesmal von neuen anfängt zu arbeiten!
Foto meines Aufbaus

Temperatur-Anzeige analog

Beachtet, wie ich im Arduino-Code einige Zeilen des Code als externe Funktionen ausgelagert habe – das macht den Code besser lesbar, oder?
Schaut Euch auch an, wie den externen Funktionen die Werte temperature übergeben werden!
Arduino
// Arduino Project Book, Seite 43ff
// http://www.oomlout.com/oom.php/products/ardx/circ-04
// ======== Servo-Sachen =============
// Libary einfügen!
#include <Servo.h>
// create servo object to control a servo
// a maximum of eight servo objects can be created
Servo myservo;
// ========= Temperatur-Sensor =========
#include <dht_nonblocking.h>
#define DHT_SENSOR_TYPE DHT_TYPE_11
static const int DHT_SENSOR_PIN = 2;
DHT_nonblocking dht_sensor( DHT_SENSOR_PIN, DHT_SENSOR_TYPE );
// ============ LED auf 13 ==========
int ledPin = 13;
// Grenzwert-Temperatur, wenn LED an/ausgehen soll
float grenzwert = 25.0;
void setup() {
pinMode(ledPin, OUTPUT);
myservo.attach(9); // attaches the servo on pin 9 to the servo object
Serial.begin(9600);
}
void loop() {
float temperature;
float humidity;
/* Measure temperature and humidity. If the functions returns
true, then a measurement is available. */
if ( measure_environment( &temperature, &humidity ) == true )
{
// in diesem Sketch werden nur die Temperatur-Werte verwendet!
serielleAusgabe(temperature);
ledAnAus(temperature);
temperaturAnzeigeAnalog(temperature);
}
// externe Funktionen mit Übergabe des Temperatur-Wertes
// mehr zu ext. Funktionen: https://canvas.instructure.com/courses/1054116/pages/arduino-coding-writing-functions-4-examples
}
// =========== externe Funktionen ============
void serielleAusgabe(float wert) {
Serial.print( "T = " );
Serial.print( wert, 1 );
Serial.println( " deg. C" );
}
void ledAnAus(float wert) {
// Wenn die Temperatur unter einen bestimmten Wert fällt, soll die LED angehen
if (wert < grenzwert) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}
void temperaturAnzeigeAnalog(float wert) {
// zur Sicherheit Limits eingebaut, damit der Servo nicht kaputt geht
// wenn die Werte < 0 oder > 180 werden
// deswegen werden nur Werte zwischen 0° und 60° zugelassen
if (wert > 0 && wert < 45) {
// Temperatur mit 4 multipliziert, damit man merkt, wenn sich die Temperatur ändern
// z.b. wenn man mit der Hand an das Termometer fasst
myservo.write(wert * 4);
}
}
/*
Poll for a measurement, keeping the state machine alive. Returns
true if a measurement is available.
*/
static bool measure_environment( float *temperature, float *humidity ) {
static unsigned long measurement_timestamp = millis( );
/* Measure once every second. */
if ( millis( ) - measurement_timestamp > 1000ul )
{
if ( dht_sensor.measure( temperature, humidity ) == true )
{
measurement_timestamp = millis( );
return ( true );
}
}
return ( false );
}
Analoge Temperaturanzeige
hier eingeschränkt auf den Bereich von 0° bis 45° Celsius – also ein Zimmerthermometer…
Hinter der analogen Anzeige wäre dann der Servo-Motor verbaut…
Aufbau

Schrittmotor

Aufbau entsprechend des Elegoo-Tutorials
Typische Anwendungsgebiete sind Drucker, vor allem Matrixdrucker, oder der Antrieb des Schreib-/Lesekopfes in einem Diskettenlaufwerk. Aufgrund ihrer hohen Genauigkeit werden sie auch in computergesteuerten Werkzeugmaschinen zur Positionierung der Werkzeuge verwendet.
Schrittmotoren finden auch in 3D-Druckern ihren Einsatz – und werden dort oft von Arduinos angesteuert…
Arduino
//www.elegoo.com
//2018.10.25
/*
Stepper Motor Control - one revolution
This program drives a unipolar or bipolar stepper motor.
The motor is attached to digital pins 8 - 11 of the Arduino.
The motor should revolve one revolution in one direction, then
one revolution in the other direction.
*/
#include <Stepper.h>
// typische Anzahl von Schritten für eine komplette Rotation (360°)
int stepsPerRevolution = 2048;
// Geschwindigkeit des Motors kann zwischen 0 und max. 17 rpm (Umdrehung pro Minute) sein
// mehr und der Motor „verschluckt“ Steps und wird ungenau…
int rolePerMinute = 15;
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);
void setup() {
// Geschwindigkeit des Motors festlegen
myStepper.setSpeed(rolePerMinute);
Serial.begin(9600);
}
void loop() {
// Motor macht 2048 Steps im Uhrzeigersinn und somit eine volle Umdrehung
Serial.println("clockwise");
// Motor führt 2048 Stufen aus und macht somit eine vollständige Drehung
myStepper.step(stepsPerRevolution);
// kurze Pause danach
delay(500);
// Motor macht 2048 Steps gegen den Uhrzeigersinn und somit ebenfalls eine volle Umdrehung
Serial.println("counterclockwise");
// Motor macht nur eine halbe Umdrehung (1024 Schritte)
myStepper.step(-stepsPerRevolution / 2);
// kurze Pause danach
delay(500);
}

Schrittmotor und Potentiometer

Durch Drehen am Potentiometer kann man die Geschwindigkeit und die Richtung des Schrittmotors verändern:
Arduino
/*
MotorKnob
A stepper motor follows the turns of a potentiometer
(or other sensor) on analog input 0.
http://www.arduino.cc/en/Reference/Stepper
This example code is in the public domain.
*/
#include <Stepper.h>
// change this to the number of steps on your motor
#define STEPS 100
// create an instance of the stepper class, specifying
// the number of steps of the motor and the pins it's
// attached to
Stepper stepper(STEPS, 3, 5, 4, 6);
// the previous reading from the analog input
int previous = 0;
// Der Drehregler
int poti = A0;
void setup() {
// set the speed of the motor to 30 RPMs
stepper.setSpeed(30);
}
void loop() {
// get the sensor value
int val = analogRead(poti);
// move a number of steps equal to the change in the
// sensor reading
stepper.step(val - previous);
// remember the previous value of the sensor
previous = val;
}
Leiterplatine statt Kabelsalat


Details aus der Bachelor-Arbeit von David Mitlewski
Danke
Diesen Arduino-Workshop habe ich 2021 komplett aufgezeichnet – Ihr könnt Euch das gerne hier noch mal ansehen!