Der Ultraschallsensor HC-SR04 zählt in der Mikroelektronik definitiv zu den bekanntesten Bauteilen. Mit Hilfe von Ultraschallsensoren können wir den Abstand von Objekten sehr genau messen. Du bist in deinem Alltag bestimmt auch schon Ultraschallsensoren begegnet: Die kleinen Sensoren werden zum Beispiel in Autos verbaut. Dort unterstützen Sie uns beim Einparken und melden, wenn wir zu dicht an ein Hindernis (zum Beispiel an eine Wand) heranfahren.
Dieses Szenario möchten wir jetzt nachstellen: dabei soll der Ultraschallsensor permanent einen Abstand erfassen.
Wenn der Sensor in mehr als 30 Zentimetern Abstand kein Hindernis erkennt, soll die grüne LED leuchten.
Wenn der Abstand zum Objekt weniger als 30 Zentimeter beträgt, soll die rote LED leuchten.
Als Objekt für die Abstandsmessung kannst du deine Hand über den Sensor halten, wenn der Funduino Cube flach auf dem Tisch liegt.
Wir starten zunächst mit unserer ROBOTERKONFIGURATION. Den Block für den Ultraschallsensor findest du im Menüpunkt „Sensoren„.
Der Block für den Ultraschallsensor ist etwas versteckt: scrolle mit dem Mausrad in der Menüansicht weit nach unten, bis du den Baustein aus der Abbildung Schritt 2 entdeckst.
Füge den Block anschließend mit einem Klick der linken Maustaste zu deiner ROBOTERKONFIGURATION hinzu.
Super! Jetzt müssen wir den Baustein nur noch konfigurieren.
Deine ROBOTERKONFIGURATION sollte jetzt so wie in Abbildung Schritt 3 dargestellt aussehen.
Jetzt schauen wir uns den Block mal ein wenig genauer an:
Damit wir im späteren Verlauf den Überblick nicht verlieren, legen wir zuerst den Namen für unseren Baustein fest. Unser Block soll den namen „Ultraschallsensor“ tragen.
Jetzt wird es kniffliger: Wie misst eigentlich ein Ultraschallsensor Entfernungen?
Ultraschallsensoren geben durchgehend Ultraschallwellen aus. Dieser Vorgang wird Sendeimpuls genannt (trigger). Sobald sich ein Objekt im Erkennungsradius eines Ultraschallsensors befindet, reflektiert dieses Objekt die Ultraschallwellen zum Sensor zurück (Echo).
Diese reflektierten Wellen werden vom Ultraschallsensor erkannt. Dabei misst der Sensor die Zeit, die zwischen dem Versenden und dem Empfangen der Ultraschallwellen vergeht und leitet daraus einen Zahlenwert ab, welchen wir mit unserem Mikrocontroller auswerten und verarbeiten können.
Schaue doch einmal auf deinen Funduino Cube und versuche herauszufinden, an welchem digitalen Pin der trigger (Sendeimpuls) des Ultraschallsensors mit dem Mikrocontroller verbunden ist.
Sehr gut! Das war nicht einfach, toll gemacht! Der Trigger, im Block mit „trig“ abgekürzt, liegt an Pin D6 an.
Jetzt müssen wir noch festlegen, an welchem digitalen Pin das Echo (reflektierte Ultraschallwellen) des Ultraschallsensors mit dem Mikrocontroller verbunden ist.
Schaue hierfür erneut auf deinen Funduino Cube.
Auch das hast du hervorragend gemacht!
Das Echo ist an Pin D5 mit dem Mikrocontroller verbunden. Nachdem du auch diesen Wert in deiner ROBOTERKONFIGURATION ergänzt hast, sind wir schon fast am Ziel. Es fehlen eigentlich nur noch die beiden LEDs.
Die Bausteine für die beiden LEDs findest du im Menüpunkt „Aktion„.
Wir verbinden die rote LED mit dem digitalen Pin D12 und die grüne LED mit dem digitalen Pin D10.
Wenn du alle Bausteine richtig konfiguriert hast, sieht dein Aufbau wie in Abbildung Schritt 8 aus.
Toll gemacht!
Unsere ROBOTERKONFIGURATION ist somit abgeschlossen. Wir können uns jetzt also dem Programm zuwenden.
Kurze Erinnerung zur Aufgabenstellung:
Wenn der Sensor in mehr als 30 Zentimetern Abstand kein Hindernis erkennt, soll die grüne LED leuchten.
Wenn der Abstand zum Objekt weniger als 30 Zentimeter beträgt, soll die rote LED leuchten.
Wir navigieren zunächst in den Menüpunkt PROGRAMM und wählen das Untermenü Kontrolle aus.
In Lektion 3 haben wir den Umgang mit Kontrollstrukturen erlernt. Eine solche Struktur wird jetzt wieder benötigt.
Kontrollstrukturen werden immer dann eingesetzt, wenn eine Aktion in Folge einer Abhängigkeit erfolgen soll.
In unserem Aufbau soll eine LED immer dann aufleuchten, wenn der Ultraschallsensor einen Abstand von mehr oder weniger als 30cm zu einem Objekt erkennt.
Den dafür notwendigen Baustein findest du im Untermenü Kontrolle.
Den Block mit „wenn-mache-sonst“, fügen wir mit einem Linksklick zu unserem PROGRAMM hinzu.
Wenn du alles richtig gemacht hast, sieht dein PROGRAMM jetzt so aus wie in Abbildung Schritt 3 dargestellt.
Jetzt benötigen wir noch den Block für den Ultraschallsensor.
Dieser Block ist ein wenig versteckt: Du findest den entsprechenden Baustein im Menüpunkt Kontrolle, relativ weit unten.
Den Baustein fügen wir ebenfalls mit einem Linksklick zu unserem PROGRAMM hinzu. Anschließend nehmen wir einige Einstellungen vor.
Du wirst feststellen, dass sich dieser Baustein aus mehreren einzelnen Unterbausteinen zusammensetzt. Das mag auf den ersten Blick etwas verwirrend erscheinen, hat jedoch einen ganz klaren Zweck, welchen wir uns jetzt Schritt für Schritt langsam ansehen.
Wir beginnen damit, den hellblau hinterlegten Teil des Bausteins vom orangefarbigen Baustein zu trennen.
Den Baustein-Teil „Warte bis…“ benötigen wir für die Lösung unserer Aufgabenstellung nicht. Du kannst diesen Teil mit einem Linksklick auswählen und mit dem Drücken der „Entf-Taste“ auf deiner Tastatur löschen.
Den hellblau hinterlegten Teil können wir jetzt an die „wenn-Bedingung“ in unserer Schleife anfügen.
Toll gemacht!
Dein Aufbau sieht jetzt so aus, wie in Abbildung Schritt 6 dargestellt.
Jetzt klicken wir mit der linken Maustaste in den grün hinterlegten Teil des Bausteins „gib analogen Wert Sensor…„.
Es öffnet sich ein neues Menü, in welchem wir jetzt unseren Ultraschallsensor HC-SR04 auswählen können.
Praktisch: Der Menüpunkt „Abstand cm Ultraschallsensor HC-SR04“ beschreibt genau die Funktion, die wir zur Lösung unserer Aufgabenstellung benötigen.
„Wenn der Sensor in mehr als 30 Zentimetern Abstand kein Hindernis erkennt, soll die grüne LED leuchten.
Wenn der Abstand zum Objekt weniger als 30 Zentimeter beträgt, soll die rote LED leuchten.“
Gut gemacht!
Dein PROGRAMM sieht jetzt aus wie in Abbildung Schritt 8 dargestellt. Der grün hinterlegte Teil des Bausteins enthält sogar den Namen unseres Ultraschallsensors!
Jetzt wählen wir den sogenannten Operatoren aus.
Operatoren sind Logikbausteine, die uns bei der Verarbeitung von Signalen helfen.
Wenn du in das Feld für den Operatoren klickst (siehe Abbildung Schritt 8), öffnet sich ein neues Untermenü. In diesem Untermenü findest du die Operatoren
wieder.
Kannst du erkennen, welchen Operatoren wir auswählen müssen, um unsere Aufgabe zu erfüllen?
„Wenn der Sensor in mehr als 30 Zentimetern Abstand kein Hindernis erkennt, soll…“
Genau! Wir benötigen den Operatoren „>„, also „größer„.
Jetzt müssen wir nur noch eine letzte kleine Anpassung vornehmen. Im dunkelblau hinterlegten Feld unseres Blocks können wir den Abstand in Zentimetern eintragen.
In unserer Aufgabenstellung soll der Abstand, bei dem die LEDs entweder rot oder grün zu leuchten beginnen, 30 Zentimeter. Wir tragen hier also die Zahl „30„ ein.
Wow! Das war ganz schön kompliziert. Nehmen wir uns jetzt doch einen kurzen Augenblick Zeit und schauen uns unser Ergebnis genauer an.
Würden wir unser Programm in unsere Sprache übersetzen, wäre die Aussage wie folgt:
„Wenn der Abstand zwischen dem Ultraschallsensor und einem Objekt mehr als 30 Zentimeter beträgt…“
Toll gemacht! Damit haben wir unseren Block erfolgreich eingestellt.
Jetzt müssen wir nur noch unsere beiden LEDs ergänzen.
Wir starten mit der grünen LED.
„Wenn der Sensor in mehr als 30 Zentimetern Abstand kein Hindernis erkennt, soll die grüne LED leuchten.“
Anschließend ergänzen wir noch unsere rote LED.
„Wenn der Abstand zum Objekt weniger als 30 Zentimeter beträgt, soll die rote LED leuchten.“
Gratulation! Wir haben das PROGRAMM damit erfolgreich abgeschlossen.
Was kannst du auf deinem Funduino Cube beobachten, wenn du das Programm jetzt hochlädst?
Wenn der Ultraschallsensor kein Objekt mit weniger als 30 Zentimetern Abstand zum Ultraschallsensor erkennt, leuchtet die grüne Leuchtdiode auf.
Sobald ein Objekt mit weniger als 30 Zentimetern Abstand vom Ultraschallsensor erkannt wird, leuchtet zusätzlich die rote Leuchtdiode auf.
Wir müssen unser bestehendes PROGRAMM deshalb um zwei weitere Bausteine ergänzen.
Die Programmbausteine für das Ausschalten der roten Leuchtdiode, sowie für das Ausschalten der grünen Leuchtdiode fügen wir anschließend in unser Programme ein.
Dabei schalten wir die rote Leuchtdiode immer dann aus, wenn wir die grüne Leuchtdiode einschalten und die grüne Leuchtdiode aus, wenn wir die rote Leuchtdiode einschalten.
Lade das Programm jetzt auf deinen Funduino Cube hoch und beobachte, was passiert!
Den Ultraschallsensor könnt ihr euch wie eine Fledermaus vorstellen. Eine Fledermaus verschickt Ultraschallwellen, um herauszufinden, wie weit ein Objekt entfernt ist. Diese Wellen werden von Objekten reflektiert und landen wieder bei der Fledermaus. Die Fledermaus weiß dann anhand der Wartezeit, wie weit Objekte von ihr entfernt sind.
Der Ultraschallsensor verhält sich dabei so ähnlich, wie die Fledermaus in der Natur. Der Sensor verschickt also Ultraschallwellen und wartet, bis diese von Objekten reflektiert werden. Sobald die Ultraschallwellen zum Modul zurückgekommen sind, sendet der Ultraschallsensor ein Spannungssignal (5V) an den Mikrocontroller. Aus der Zeit, in der die Ultraschallwelle unterwegs war, kann der Mikrocontroller die Entfernung zum Objekt berechnen.
Aber wie funktioniert die Technik dahinter? Lasst es uns im nächsten Schritt genauer angucken…
Der Ultraschallsensor unterscheidet sich von den vorherigen Bauteilen. Bislang hatte jedes Bauteil einen einzelnen Signalpin, aber der Ultraschallsensor verfügt über zwei Signalpins: „Trigger“ und „Echo“.
Der Trigger-Pin gibt dem Ultraschallsensor das Startsignal, um mit der Abstandsmessung zu beginnen. Dazu muss er mindestens 10ms lang eine Spannung vom Arduino erhalten.
Wenn das Modul die reflektierten Ultraschallwellen empfängt, sendet es eine Spannung an den Mikrocontroller.
Die Ultraschallwellen bewegen sich mit Schallgeschwindigkeit. Wie schnell das ist, wird mit dem nächsten Beispiel deutlich.
Wir nehmen an, zwei Personen sitzen sich gegenüber. Der Abstand sollte dabei in etwa einen Meter betragen. Die Ultraschallwelle braucht für diese Entfernung nur den Bruchteil einer Sekunde. Sie brauchen für diese Distanz ca. 0,03 Sekunden.
Bis zum jetzigen Schritt konnten wir immer mit ganzen Zahlen arbeiten und haben als Datentyp immer den „Integer“, abgekürzt „int“ verwendet. Da die Ultraschallwellen zu schnell sind, benötigen wir einen anderen Datentyp: Die Fließkommazahlen. Der Datentyp dafür heißt „Float„ und steht für „Floating-Pint-Number“ was auf Deutsch „Fließkommazahl“ bedeutet. Mit diesem Datentypen können wir typische Kommazahlen, wie zum Beispiel 1,23 verarbeiten.
float fließkommazahl = 1.23;
Jetzt erstellen wir die Variablen für diese Lektion. Die rote LED ist mit dem Pin 12 des Mikrocontrollers verbunden. Der Trigger des Ultraschallsensors ist mit dem Pin 6 des Mikrocontrollers verbunden. Der Echo-Pin vom Ultraschallsensor ist mit dem Pin 5 des Mikrocontrollers verbunden.
Um die Entfernung zu ermitteln, brauchen wir folgende Formel:
Entfernung = (Gemessene Zeit / 2) * Schallgeschwindigkeit
Wie wir mit dieser Formel rechnen können, erklären wir dir später.
Wir teilen diese Formel jetzt in Variablen auf und kommen auf folgende vier Variablen:
Die Variablen „entfernung“, „gemessene_Zeit“ und „zeit_eine_strecke“ bekommen den Startwert 0. Die Variable „schallgeschwindigkeit“ bekommt den Wert 0,034 zugewiesen. Dieser Zahlenwert steht für die Schallgeschwindigkeit in Zentimeter pro Mikrosekunde.
In der rechten Abbildung seht ihr eine Übersicht aller Variablen.
/* Variablen - Bauteile */
int modul_led_rot = 12;
int modul_ultraschallsensor_trigger = 6;
int modul_ultraschallsensor_echo = 5;
float entfernung = 0;
float gemessene_zeit = 0;
float zeit_eine_strecke = 0;
float schallgeschwindigkeit = 0.034;
Im Setup definieren wir die Ein- und Ausgänge.
Da der Trigger-Pin Spannung vom Arduino benötigt, um Ultraschallwellen zu senden, legen wir die Trigger-Variable als Ausgang fest. Da über den Echo-Pin des Ultraschallsensors eine Spannung an den Mikrocontroller zurückgegeben wird, wird der Pin als Eingang definiert.
Die LED wird wie üblich als Ausgang deklariert, da sie vom Arduino mit Spannung versorgt wird.
/* Variablen - Bauteile */
int modul_led_rot = 12;
int modul_ultraschallsensor_trigger = 6;
int modul_ultraschallsensor_echo = 5;
float entfernung = 0;
float gemessene_zeit = 0;
float zeit_eine_strecke = 0;
float schallgeschwindigkeit = 0.034;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_rot, OUTPUT);
pinMode(modul_ultraschallsensor_trigger, OUTPUT);
pinMode(modul_ultraschallsensor_echo, INPUT);
} // ende setup
Im Loop angekommen, starten wir mit der Entfernungsmessung.
Um genaue Messwerte zu erhalten, muss der Ultraschallsensor zuerst spannungsfrei sein. Erst dann ist gewährleistet, dass keine Störsignale an den Trigger-Pin des Ultraschallsensors anliegen. Der Pin muss dafür mindestens 5ms lang ausgeschaltet werden.
Um nun die Entfernungsmessung zu starten, muss der Trigger-Pin mindestens 10ms lang eine Spannung vom Arduino erhalten.
Nach den 10ms schalten wir den Trigger wieder auf LOW.
Jetzt wartet der Ultraschallsensor auf die Reflexion der Schallwelle. Wie das funktioniert, schauen wir uns im nächsten Schritt genauer an.
/* Variablen - Bauteile */
int modul_led_rot = 12;
int modul_ultraschallsensor_trigger = 6;
int modul_ultraschallsensor_echo = 5;
float entfernung = 0;
float gemessene_zeit = 0;
float zeit_eine_strecke = 0;
float schallgeschwindigkeit = 0.034;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_rot, OUTPUT);
pinMode(modul_ultraschallsensor_trigger, OUTPUT);
pinMode(modul_ultraschallsensor_echo, INPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
// entfernung
digitalWrite(modul_ultraschallsensor_trigger, LOW);
delay(5);
digitalWrite(modul_ultraschallsensor_trigger, HIGH);
delay(10);
digitalWrite(modul_ultraschallsensor_trigger, LOW);
Mit dem setzen des „modul_ultraschallsensor_trigger“ auf „HIGH“ im vorherigen Schritt, wurden Ultraschallwellen ausgesendet.
Zu Erinnerung: Um die Entfernung messen zu können, müssen wir wissen, wie lange die Ultraschallwellen benötigen, um zum Objekt und wieder zurück zu gelangen.
Dafür verwenden wir jetzt den Befehl pulseIn(Pin, HIGH/LOW). Achtung der vorletzte Buchstabe ist ein großes „i“. Mit diesem Befehl wird die Zeit gemessen, die vergeht, bis das 5V Signal vom Echo-Pin des Ultraschallsensors am Mikrocontroller detektiert wird. Denn das 5V-Signal des Echo-Pins wird vom Ultraschallsensor aktiviert, wenn die Schallwelle zum Sensor zurück gekommen ist.
Mit dem Befehl „pulseIn„ prüft der Mikrocontroller permanent den Status des Echo-Pins. Diese Überprüfung soll ermitteln, ob sich der Status des Pins verändert hat. Der Mikrocontroller möchte also erfahren, ob eine Spannung anliegt, die als Wechsel von einem LOW auf ein HIGH Signal interpretiert werden kann. Wenn ein solcher Signalwechsel erfolgt, bedeutet das, dass die zuvor ausgesendeten Ultraschallwellen wieder am Ultraschallsensor eingetroffen sind und wir unsere Zeitmessung beenden können. Die Zeit bis zum Eintreffen des Echos wird mithilfe des Befehls „gemessene_zeit=pulseIn(modul_Ultraschallsensor_echo, HIGH);“ in der Variablen „gemessene_zeit“ gespeichert.
/* Variablen - Bauteile */
int modul_led_rot = 12;
int modul_ultraschallsensor_trigger = 6;
int modul_ultraschallsensor_echo = 5;
float entfernung = 0;
float gemessene_zeit = 0;
float zeit_eine_strecke = 0;
float schallgeschwindigkeit = 0.034;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_rot, OUTPUT);
pinMode(modul_ultraschallsensor_trigger, OUTPUT);
pinMode(modul_ultraschallsensor_echo, INPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
// entfernung
digitalWrite(modul_ultraschallsensor_trigger, LOW);
delay(5);
digitalWrite(modul_ultraschallsensor_trigger, HIGH);
delay(10);
digitalWrite(modul_ultraschallsensor_trigger, LOW);
gemessene_zeit = pulseIn(modul_ultraschallsensor_echo, HIGH);
In der Variablen „gemessene_zeit“ haben wir die Zeit gespeichert, die die Ultraschallwelle vom Aussenden am Ultraschallsensor, bis hin zum erneuten Eintreffen am Sensor benötigt hat.
Diese Zeitdauer misst also den Hinweg und den Rückweg zu dem Objekt (Hand/Wand).
Zur Berechnung des Abstandes eines Objektes benötigen wir allerdings nur die Zeitdauer einer Strecke, also dem Hin- oder Rückweg zum Objekt. Deshalb teilen wir die gemessene Zeit durch zwei und speichern das Ergebnis in der Variablen „zeit_einer_strecke“.
/* Variablen - Bauteile */
int modul_led_rot = 12;
int modul_ultraschallsensor_trigger = 6;
int modul_ultraschallsensor_echo = 5;
float entfernung = 0;
float gemessene_zeit = 0;
float zeit_eine_strecke = 0;
float schallgeschwindigkeit = 0.034;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_rot, OUTPUT);
pinMode(modul_ultraschallsensor_trigger, OUTPUT);
pinMode(modul_ultraschallsensor_echo, INPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
// entfernung
digitalWrite(modul_ultraschallsensor_trigger, LOW);
delay(5);
digitalWrite(modul_ultraschallsensor_trigger, HIGH);
delay(10);
digitalWrite(modul_ultraschallsensor_trigger, LOW);
gemessene_zeit = pulseIn(modul_ultraschallsensor_echo, HIGH);
// mathe
zeit_eine_strecke = gemessene_zeit / 2;
Jetzt können wir auch die Entfernung bestimmen. Wir multiplizieren hierfür die Variable „zeit_einer_strecke“ mit der Variable „schallgeschwindigkeit“. Das Ergebnis speichern wir in der Variable „entfernung“.
/* Variablen - Bauteile */
int modul_led_rot = 12;
int modul_ultraschallsensor_trigger = 6;
int modul_ultraschallsensor_echo = 5;
float entfernung = 0;
float gemessene_zeit = 0;
float zeit_eine_strecke = 0;
float schallgeschwindigkeit = 0.034;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_rot, OUTPUT);
pinMode(modul_ultraschallsensor_trigger, OUTPUT);
pinMode(modul_ultraschallsensor_echo, INPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
// entfernung
digitalWrite(modul_ultraschallsensor_trigger, LOW);
delay(5);
digitalWrite(modul_ultraschallsensor_trigger, HIGH);
delay(10);
digitalWrite(modul_ultraschallsensor_trigger, LOW);
gemessene_zeit = pulseIn(modul_ultraschallsensor_echo, HIGH);
// mathe
zeit_eine_strecke = gemessene_zeit / 2;
entfernung = zeit_eine_strecke * schallgeschwindigkeit;
Die Entfernung zwischen Ultraschallsensor und Objekt ist nun in der Variable „entfernung“ gespeichert. Zur Lösung unserer Aufgabenstellung müssen wir jetzt noch überprüfen, ob die gemessene Entfernung größer als 30 cm ist. Hierfür nutzen wir eine If-Abfrage. In der Bedingung geben wir an, dass der Mikrocontroller überprüfen soll, ob der Abstand größer als 30 cm ist.
Wenn diese Bedingung erfüllt ist, wird innerhalb der If-Abfrage die rote LED eingeschaltet. Die LED leuchtet für fünf Sekunden und wird danach wieder ausgeschaltet.
/* Variablen - Bauteile */
int modul_led_rot = 12;
int modul_ultraschallsensor_trigger = 6;
int modul_ultraschallsensor_echo = 5;
float entfernung = 0;
float gemessene_zeit = 0;
float zeit_eine_strecke = 0;
float schallgeschwindigkeit = 0.034;
/* setup */
void setup()
{ // start setup
pinMode(modul_led_rot, OUTPUT);
pinMode(modul_ultraschallsensor_trigger, OUTPUT);
pinMode(modul_ultraschallsensor_echo, INPUT);
} // ende setup
/* loop */
void loop()
{ // start loop
// entfernung
digitalWrite(modul_ultraschallsensor_trigger, LOW);
delay(5);
digitalWrite(modul_ultraschallsensor_trigger, HIGH);
delay(10);
digitalWrite(modul_ultraschallsensor_trigger, LOW);
gemessene_zeit = pulseIn(modul_ultraschallsensor_echo, HIGH);
// mathe
zeit_eine_strecke = gemessene_zeit / 2;
entfernung = zeit_eine_strecke * schallgeschwindigkeit;
// if
if (entfernung > 30)
{ // start if
digitalWrite(modul_led_rot, HIGH);
delay(500);
digitalWrite(modul_led_rot, LOW);
} // ende if
} // ende loop
Falls du Unterstützung bei der Verwendung deines Funduino Cubes benötigen solltest, steht dir unser kompetentes Support Team jederzeit gerne zur Verfügung!
Du erreichst uns am Besten per Mail unter info@funduino.de oder von Montags bis Freitags, zwischen 09:00 und 17:00 Uhr unter der Rufnummer (+49) 5921 9704030.