Tutorien - Rookie

Die folgenden Tutorien beziehen sich auf das in den Grundlagen vorgestellte Arduino-Entwicklungskit. An dieser Stelle möchte ich nochmals betonen, dass sich dieses Tutorium an diejenigen richtet, die bislang keine oder wenig Erfahrung haben im Umgang mit Elektronik und der Programmierung von Microkontrollern.

Dank der Arduino-Entwicklungsumgebung wird uns aber genau hier die Angst vor dem Thema genommen!

Das Tutorium glieder sich folglich in diese inhaltlichen Punke.

Inhalt

• Tutorium 2 - Das "Blink"-Beispiel
• Tutorium 3 - Das Wechselblink-Beispiel
• Tutorium 4 - Das Stimmungslicht-Modul oder "Wie steuere ich eine RGB LED an"
• Tutorium 5 - Datenübertragung vom Arduino zum PC
• Tutorium 6 - Der digitale Temperatur-Luftfeuchte-Sensor DHT11

Tutorium 2 - Das "Blink"-Beispiel ↑

Eines der wohl einfachsten Beispiele, um zunächst unsere Werkzeugkette aus Text-Editor, Compiler und Programmierer zu prüfen ist das "Blink"-Beispiel. Das Beispiel heißt deshalb so, weil dadurch - wie in unserem Fall - eine Leuchtdiode (=LED) zum Leuchten gebracht wird.

Tutorium 2 - Material

Was benötigst du für dieses Tutorium?

• das Microkontroller-Modul aus dem Kit


• das Steckbrett und Steckbrücken aus dem Kit


• eine LED


• einen Fest-Widerstand mit 270 Ohm


• weitere Fest-Widerstände zum experimentieren

Tutorium 2 - Durchführung des Experiments

Im ersten Programmier-Tutorium machen wir uns das Leben noch einfach, denn es hat sich bereits jemand die Mühe gemacht, den Text für uns zu schreiben - zumindest den Anfang davon.

Es geht zunächst nicht vorrangig darum, dass du selbst programmierst sondern vielmehr, dass du ein Gefühl für deine Werkzeuge bekommst.

1. Zuerst bauen wir die Experimentierschaltung auf. Dazu platzieren wir das Microkontroller-Modul am linken Rand des Steckbrett, so dass die USB-Schnittstelle nach links zeigt. Für nachfolgende Experimente bereiten wir außerdem noch folgenden Grundaufbau vor: es werden vier Drahtbrücken eingefügt, wie in der Abbildung gezeigt (von 3V3 am Nano an den mit "+" markierten horizontalen Verbinder, von GND am Nano an den mit "-" markierten horizontalen Verbinder, und je eine Brücke zwischen den beiden horizontalen Verbinder-Bereichen).



2. starte die Arduino-IDE

3. mit einem Klick auf den Menüpunkt Datei > Beispiele > 01.Basics > Blink öffnest du den bereits geschriebenen Beispiel-Programmtext.



Als Ergebnis solltest du in etwa den folgeden Text in deinem Editor sehen.

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

4. verbinde den PC oder Laptop über das USB Kabel mit dem Microkontroller-Modul.

5. übertrage den Programmtext wie im Tutorium 1 beschrieben auf das Microkontroller-Modul.

Jetzt sollte die LED auf dem Microkontroller-Modul anfangen zu blinken.

Tutorium 2 - Wie funktioniert es und was macht der Programmtext?

Die Arduino-IDE macht uns den Einstieg leicht, denn eigentlich ist das Schreiben von Programmtext etwas aufwändiger, wie wir vielleicht später einmal sehen werden.

Zunächst schauen wir uns den Programmtext genauer an und erkennen zwei Blöcke. Der eines fängt an mit "void setup() .." und der zweite mit "void loop() .." - in der Fachsprache sind dies Funktionen. Alles was zur Funktion dazugehört stehe direkt dahinter in geschweiften Klammern .- mit "{" fängt der Funktionsteill an und mit "}" wird er beendet.

Die Funktion setup() wird grundsätzlich nur einmal aufgerufen und wird dazu verwendet, um die Grundeinstellung (oder im Englischen "setup") für das Microkontroller-Programm vorzunehmen. Konkret wird durch pinMode() - das sieht aus wie eine Funktion, ist aber ein Funktionsaufruf - die Einstellung eines der vielen Beinchen (oder auch kurz "pin") am Microkontroller-Modul vorgenommen.

Der Pin LED_BUILTIN wird als Ausgang, also OUTPUT eingestellt oder in der Fachsprache "konfiguriert". Was sich hinter LED_BUILTIN verbirgt lernen wir noch im Fortgang dieses Tutoriums.

Doch zunächst schauen wir uns noch die Funktion loop() genauer an: "loop" ist der englische Begriff für Schleife und alles was in dieser Funktion steht wird vom Microkontroller unendlich lange wiederholt, wie in einer Endlosschleife.

Durch den Funktionsaufruf digitalWrite() wird der Pin am Microkontroller-Modul wie ein Lichtschalter betätigt und mit dem Wert HIGH ein- und mit LOW ausgeschaltet. LOW und HIGH sind hier Gleichbedeutend für die Zahlen 0 und 1. Ah, wirst du sagen, denn das kommt dir vielleicht bekannt vor und jetzt bekommt der Begriff "digital" in der Funktion für dich auch einen Sinn.

Der dann folgende Funktionsaufruf delay() bewirkt eine Verzögerung im Programmablauf. Die Länge der Verzögerung wird durch die Zahl in Klammern angegeben und entspricht einer Zeit in Millisekunden.

Tutorium 2 - Änderung des Experiments

Nun wollen wir uns ansehen, wie wir eine LED, die an einem beliebigen Pin angeschlossen ist blinken lassen können.

1. trenne den PC oder Laptop über das USB Kabel vom Microkontroller-Modul

2. verändere die Experimentierschaltung ab, indem du wie folgt erweiterst:
a. stecke eine LED in zwei isolierte vertikale Verbinder, das lange Beinchen links das kurze Beinchen rechts
b. stecke einen Widerstand mit Wert 270 Ohm zwischen dem Microkontroller-Modul Pin D2 und dem langen Beinchen der LED - solltest du die Bauteile etwas weiter auseinander platziert haben nutze Steckbrücken
c. stecke eine Brücke zwischen dem kurzen Beinchen der LED und dem mit "-" markierten horizontalen Verbinder



3. verbinde den PC oder Laptop über das USB Kabel mit dem Microkontroller-Modul.

Du wirst sehen, dass die hinzugefügte LED NICHT blinkt. Kann sie auch nicht, weil der Microkontroller davon nichts weiß

4. um die hinzugefügte LED blinken zu lassen, ändere den Programmtext wie folgt ab (die Änderungen sind dick hervorgehoben):

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  //pinMode(LED_BUILTIN, OUTPUT); // diese Zeile ist jetzt auskommentiert 
				// und wird vom Kompiler ignoriert
  pinMode(2, OUTPUT); // an Pin D2 befindet sich die hinzugefügte LED
}

// the loop function runs over and over again forever
void loop() {
  //digitalWrite(LED_BUILTIN, HIGH);   // wird nicht kompiliert
  digitalWrite(2, HIGH);	  // LED an
  delay(1000);                       // wait for a second
  //digitalWrite(LED_BUILTIN, LOW);    // wird nicht kompiliert
  digitalWrite(2, LOW);    // LED aus
  delay(1000);                       // wait for a second
}

5. kompiliere und lade auf das Microkontroller-Modul hoch

Jetzt muss die hinzugefügte LED blinken und die LED auf dem Modul ändert ihren Status nicht.
Hätten wir die LED an den Pin D3 angeschlossen, müsste im Funktionsaufruf digitalWrite() eine "3" anstelle der "2" stehen usw. Und - nicht zu vergessen - im Initialisierungsteil setup() den Funktionsaufruf pinMode() anpassen.

Probiere es selber aus!



6. speichere deinen Programmtext für weitere Experimente ab und nenne ihn "tutorium2_blink_D2"

Tutorium 3 - Das Wechselblink-Beispiel ↑

In diesem Tutorium will ich die Bedeutung des Begriffs "LOW"-drive und "HIGH"-drive, oder kurz "LOW" und "HIGH" verständlich machen. Dazu gehört leider auch ein wenig elektornische Schaltungstheorie.

Tutorium 3 - Material

Was benötigst du für dieses Tutorium?

• den Versuchsaufbau aus Tutorium 2, nachdem du diesen wie beschrieben geändert hast


• eine weitere LED


• einen weiteren Fest-Widerstand mit 270 Ohm

Tutorium 3 - Durchführung des Experiments

1. Baue die Experimentierschaltung das Tutorium 2 auf und füge die beschriebene Änderung ein.

2. Ergänze nun die Schaltung wie in der nachfolgenden Abbildung gezeigt um die weiteren Bauteile.
a. stecke die weitere LED in zwei isolierte vertikale Verbinder, das lange Beinchen links das kurze Beinchen rechts
b. stecke den weiteren Widerstand mit Wert 270 Ohm zwischen dem Microkontroller-Modul Pin D2 und dem kurzen(!) Beinchen der LED - solltest du die Bauteile etwas weiter auseinander platziert haben nutze Steckbrücken
c. stecke eine Brücke zwischen dem langen(!) Beinchen der LED und dem mit "+" markierten horizontalen Verbinder



Jetzt kommt noch ein wenig Theorie ins Spiel: in der Elektrotechnik ist es üblich, einen Versuchsaufbau zu dokumentieren oder viel mehr vor dem Aufbau zu planen. Dafür werden sogenannten Schaltpläne verwendet. Diese zeigen, welche Bauteile verwendet werden und wie diese Bauteile miteinander verbunden werden sollen. Die folgenden Abbildung zeigt den Schaltplan für unseren Versuchsaufbau.



Wie du vielleicht erkennen kannst, ist unser Microkontroller-Pin D2 zwischen den beiden LEDs D1 und D2 angeschlossen. Zudem kannst du die zwei Widerstände R1 und R2 erkennen. Die LED D1 ist an das 3V3-Signal, die LED D2 an das GND-Signal angeschlossen.

3. starte nun die Arduino-IDE und lade dir deinen Programmtext "tutorium2_blink_D2" (siehe Tutorium 2)

4. speichere deinen Programmtext jetzt unter dem neuen Namen "tutorium3_wechselblink" ab

5. verbinde den PC oder Laptop über das USB Kabel mit dem Microkontroller-Modul.

6. kompiliere und lade den Programmtext unverändert auf das Microkontroller-Modul hoch

Jetzt müssen die beiden LEDs im wechsel an und ausgehen

Tutorium 3 - Wie funktioniert es und was macht der Programmtext?

Um zu verstehen, was genau passiert, sehen wir uns zuerst an was am Microkontroller-Pin passiert. Dazu soll die folgenden Abbildung helfen. Sie zeigt das Innenleben im Microkontroller stark vereinfacht.



Wenn wir einen Microkontroller-Pin als digitalen Ausgang verwenden (OUTPUT), so können wir uns vorstellen, dass im Innern des Microkontroller zwei Schaltern S1 und S2 existieren. Diese werden durch eine Steuerlogik bedient, in Abhä,ngigkeit zum Inhalt des Programmtext. Wir erinnern uns and die Funktion digitalWrite(), die neben dem Pin auch den Status LOW oder HIGH bekommt.

Da ein Pinstatus nicht gleichzeitig LOW und HIGH sein kann, wird dadurch der Pin D2 entweder über Schalter S1 gegen die Versorgungsspannung (also 3V3), oder S2 gegen Masse (also GND) gelegt. Es ist also ein bischen anders, als ein Lichtschalter. Da genügt es, einfach die Verbindung zur Versorgungsspannung zu unterbrechen. Der Microkontroller erlaubt es, gezielt eine Verbindung zu Masse herzustellen.

Schauen wir uns noch einmal im Detail an, was mit unserer Experimentierschaltung passiert. Wird zunächst der Schalter S1 geschlossen, so wird die LED D1 leuchten, weil der
sogenannte Stromkreis geschlossen ist. An D2 liegt die Versorgungsspannung.

Jetzt wirst du vielleicht sagen "Ja, aber die LED D2 ist doch noch immer in der Schaltung und einen Stromkreis mit der LED D2 habe ich doch gar nicht unterbrochen!" - das ist richtig. Damit aber die LED leuchtet, muss ein Strom durch sie hindurchfließen. Das passiert aber nur, wenn auch ein Spannungsunterschied existiert. Durch das Schließen von Schalter S1 machen wir aber einen Kurzschluss über LED D2 und deren Vorwiderstand R2.

Damit kann keine Spannung abfallen und folglich auch kein Strom fließen.



Wird jetzt der Schalter S2 geschlossen - folglich muss der Schalter S1 nun offen sein, da beide Schalter nicht gleichzeitig geschlossen sein können - so erzeugen wir einen Kurzschluss über R1 und D1, damit geht die LED D1 aus und D2 muss leuchten.



Somit haben wir jetzt mit Hilfe von einem Microkontroller-Pin einen Wechselblinker realisiert. In der Fachsprache werden die Begriffe "LOW"-drive und "HIGH"-drive verwendet, um die jeweilige Art der Ansteuerung zu beschreiben. Somit ist die LED D2 "LOW"-drive und die LED D1 "HIGH"-drive. Der englische Begriff "drive" heißt in diesem Zusammenhang soviel wie "ansteuern" oder "antreiben".

Tutorium 4 - Das Stimmungslicht-Modul oder "Wie steuere ich eine RGB LED an" ↑

In diesem Tutorium wirst du neben der bereits bekannten Ansteuerung und Nutzung eines Microkontroller-Pins als Digital-Ausgang (siehe Tutorium 2 und 3, digitalWrite()) lernen, was ein pulsweitenmoduliertes Signal ist und wie sich dieses für eine nicht-digitale Ansteuerung (der Fachbegriff ist "analoge Ansteuerung") nutzen läßt. Wir lernen hier, wie der Funktionsaufruf analogWrite() funktioniert.

Tutorium 4 - Material

Folgendes Material benötigst du für dieses Tutorium:

• das Microkontroller-Modul aus dem Kit


• das Steckbrett und Steckbrücken aus dem Kit


• das Stimmungslicht-Modul aus dem Kit

Tutorium 4 - Durchführung des Experiments

1. Zuerst bauen wir die Experimentierschaltung auf. Dazu nutzen wir den Grundaufbau aus Tutorium 2 (allerdings ohne externe LED). Stattdessen stecken wir das Stimmungslicht-Modul mit etwas Abstand rechts neben das Microkontroller-Modul. Dann verbinden wir mit Steckbrücken die Masse und Spannungsversorgung des Stimmungslicht-Moduls (Pin 1 ist Masse, Pin 5 ist Spannung). Die Steuerleitung für die Farbe Blau (Pin 2) wird mit dem Microkontroller-Pin D6 und die Farbe Grün (Pin 3) wird mit dem Microkontroller-Pin D5 verbunden.



2. eine Steckbrücke muss noch zwischen Pin 4 des Stimmungslicht-Modul und dem Microkontroller-Pin D3 gesteckt werden - damit wird dann die Farbe Rot gesteuert.




3. jetzt geht es an das Schreiben des Programmtext. Öffne dazu die Arduino-IDE und starte mit einem neuen Dokument (klicke dazu Datei > Neu). Speichere den Programmtext als "tutorium4_stimmungslich". Bevor wir jedoch mit dem eingentlichen Experiment, nämlich der "pulsweitenmodulierten Ansteuerung" beginnen, prüfen wir zunächst die grundlegende Ansteuerung des Stimmungslicht-Moduls. Starte daher mit folgendem Programmtext:

#define ROT 3
#define GRUEN 5
#define BLAU 6

void setup() {
  // put your setup code here, to run once:
  pinMode(ROT,OUTPUT);
  pinMode(GRUEN,OUTPUT);
  pinMode(BLAU,OUTPUT);
  digitalWrite(ROT,HIGH); // Zustand initialisieren
  digitalWrite(GRUEN,HIGH); // Zustand initialisieren
  digitalWrite(BLAU,HIGH); // Zustand initialisieren
}

void loop() {
  // put your main code here, to run repeatedly:
  // alle Farben nacheinander ein und wieder ausschalten
  digitalWrite(ROT,LOW);
  delay(500);
  digitalWrite(ROT,HIGH);
  delay(500);
  digitalWrite(GRUEN,LOW);
  delay(500);
  digitalWrite(GRUEN,HIGH);
  delay(500);
  digitalWrite(BLAU,LOW);
  delay(500);
  digitalWrite(BLAU,HIGH);
  delay(500);
}

Tutorium 4 - Wie funktioniert es und was macht der Programmtext?

Zu Beginn des Programmtext werden drei sogenannte "defines" (English = Definitionen) erstellt mittels #define. Diese Definitionen helfen uns, den Programmtext leichter lesbar zu machen. Die Definition ROT bekommt den Wert 3 was unserem Microkontroller-Pin entspricht usw.

Den Namen einer Definition (also ROT) kannst du frei wählen solange keine Zahlen enthalten sind. Leerzeichen und Umlaute gehen auch nicht. Viele Programmierer verwenden nur Großbuchstaben und den Unterstrich. Bei einem define handelt es sich technisch um eine Kompileranweisung, d.h. der Kompiler ersetzt, für uns unsichtbar jedes define durch den damit verbundenen Wert. Beachte auch, dass ein Zeile mit einem #define nie mit einem Semikolon abgeschlossen wird.

Der übrige Programmtext sollte sich für dich bereits von selbst erklären. Wenn nicht, schau dir bitte nochmals die vorangegangenen Tutorien an.

Tutorium 4 - Änderung des Experiments

Das Stichwort heißt analogWrite(). Wenn du willst, kannst du über die Arduino-Webseite selber ein wenig nachforschen. Siehe dir dazu das Kapitel Resources > References auf der Webseite an.

Nun aber zum eigentlichen Experiment:

1. Speichere den Programmtext aus dem vorherigen Abschnitt unter dem neunen Namen "tutorium4_stimmungslich2" ab.

2. Entferne den Programmtext innerhalb der loop() und ersetzte durch den folgenden:

  int pwmWert;

  for (pwmWert=255; pwmWert>0; pwmWert--) {
    analogWrite(ROT,pwmWert);
	delay(100);
  }
  for (pwmWert=0; pwmWert<=255; pwmWert++) {
    analogWrite(ROT,pwmWert);
	delay(100);
  }

3. Lade den Programmtext auf das Microkontroller-Modul hoch.

Jetzt muss folgendes passieren: die Farbe Rot wird langsam heller und dann wieder dunkler.

Wie kommt das und was hat es mit "for(...)" auf sich?

In jeder Programmiersprache gibt es sogenannte Kontrollfunktionen. Bei for() handelt es sich um eine solche Kontrollfunktion. Diese wird auch Schleifenfunktion genannt, oder kurz for-Schleife. Die Funktion nimmt drei Parameter auf: Startwert eines Zählers, End-Bedingung und um wie viel der Wert des Zählers verändert wird.

In unserem Beispiel heißt der Zähler "pwmWert" - es handelt sich dabei um eine sogenannte Variable. Bevor wir eine Variable benutzen können, muss diese deklariert werden. Dies geschieht am Anfang mit der Zeile "int pwmWert;". Was int bedeutet will ich später erklären.
Unser Startwert wird also in der ersten for-Schleife mit dem Wert 255 belegt. Die Schleife läuft dann so lange den Teil innerhalb der geschweiften Klammern "{}" aus, solange der Wert größer als 0 ist. Der Wert wird dabei mit jedem Schleifendurchlauf um den Wert 1 verkleinert (dafür bedienen wir und einer lustig anmutenden Schreibweise "pwmWert--", mit zwei Minuszeichen).

Die Schleife macht also folgendes, sie zählt rückwärts von 255 bis einschließlich 0 und dann wird die zweite for-Schleife ausgeführt. Dort starten wir bei 0 und zählen bis einschließlich 255.

Was passiert aber innerhalb der Schleifen?

Dort rufen wir jedes mal die Funktion analogWrite() mit den dazugehörigen Parametern auf. Das ist wie bei digitalWrite() der Pin und der "Analogwert", den der Pin ausgeben soll - hier dargestellt durch unsere Variable "pwmWert". Dabei passiert im Vergleich zum digitalWrite() jetzt etwas ganz anderes: der Microkontroller-Pin nimmt nun keinen statischen Zustand LOW oder HIGH an sondern schaltet ganz schnell zwischen LOW und HIGH hin und her.

Das macht er aber nicht zufällig sondern nach einem bestimmen Schema, welches wir mit Hilfe von dem Parameter, den wir an den Funktionsaufruf übergeben beeinflussen.
Der Zusand LOW wird bei einem solchen Signal als Pause und HIGH als Puls bezeichnet. Durch den Parameter (hier also pwmWert) wird das Zeitverhältnis zwischen Puls- und Pausendauer beeinflusst. Da das Hin- und Herschalten zwischen Puls und Pause so schnell geht nehmen wir als Menschen dies in Form einer Abschwächung der Helligkeit der LED wahr, je länger die LED aus ist.

Tutorium 5 - Datenübertragung vom Arduino zum PC ↑

In diesem Tutorium erläutere ich die Verwendung der seriellen Datenschnittstelle auf dem Mikrokontroller-Modul, um Informationen an den PC zu übertragen.

Tutorium 5 - Material

Folgendes Material benötigst du für dieses Tutorium:

• das Microkontroller-Modul aus dem Kit

Tutorium 5 - Durchführung des Experiments

1. Es gibt nicht viel aufzubauen, außer das Microkontroller-Modul über die USB-Leitung am PC anzuschließen

2. Öffne die Arduino-IDE und lade aus den Beispielen "ASCIITable" (Datei > Beispiele > 04.Communication > ASCIITable)

3. Lade den Programmtext auf das Microkontroller-Modul

4. Starte nun den "Serieller Monitor" unter Werkzeuge > Serieller Monitor und es öffnet sich folgendes Fenster:



Was macht der Monitor? Ganz simple, er ermöglicht dir, Informationen, die über die Datenschnittstelle des Arduino an den PC gesendet werden, anzuzeigen.

Damit das funktioniert, musst du aber mit dem kleinen Auswahlfeld rechts unten die sogenannte Datenrate der Datenschnittstelle korrekt einstellen. Den Wert kannst du aus dem Programmtext an folgender Stelle entnehmen:

void setup() {
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // prints title with ending line break
  Serial.println("ASCII Table ~ Character Map");
}

Mit Serial.begin(9600); wird die Schnittstelle initialisiert und zwar mit 9600 baud - "baud" ist die Einheit und ist gleichbedeutend mit "Zeichen pro Sekunde". Folglich muss im Monitor auch "9600" ausgewählt werden.

Tutorium 5 - Wie funktioniert es und was macht der Programmtext?

Der Programmtext (den ich hier nur auszugsweise wiedergeben werde) besteht im Wesentlichen aus drei Funktionsaufrufen: Serial.write, Serial.print und Serial.println. Zudem gibt es noch die Variable "thisByte".

  ...
  Serial.write(thisByte);

  Serial.print(", dec: ");
  ...
  Serial.print(thisByte);
  ...
  Serial.print(", hex: ");
  ...
  Serial.print(thisByte, HEX);
  Serial.print(", oct: ");
  ...
  Serial.print(thisByte, OCT);
  ...

Mit dem Funktionsaufruf Serial.write wird der in Klammern angegebene Funktionsparameter ausgegeben. Dabei wird aus der Zahl, die in der Variablen "thisByte" gespeichert ist als Zeichen ausgegeben. Wie wird aus einer Zahl ein Zeichen, wirst du fragen? Auf PCs wird ein Zeichensatz kodiert, indem jedem Zeichen (z.B. "A" oder "B") eine Nummer zugewiesen wird bzw. umgekehrt: aus einer Zahl wird ein Buchstabe, Sonderzeichen, Nummer usw. Zugrunde liegt oftmals der sogenannte ASCII-Zeichensatz.

Mit dem Funktionsaufruf Serial.print macht das Programm genau das, es zeicht uns als Dezimal-, Hexadezimal- oder Oktalzahl den Wert (also die Zahl, mit der das Zeichen kodiert wurde) an. Dazu nimmt der Funktionsaufruf neben dem Ausgabewert noch den Parameter HEX oder OCT optional mit auf. Wird der Parameter zum Ausgabeformat nicht angegeben, wird der Ausgabewert als Dezimalwert angegeben (optinal kann aber auch DEC) mitgegeben werden.

Soll ein Text ausgegeben werden, so muss dieser in Anführungszeichen ("...") stehen. Die Angabe des Ausgabeformat gilt nur für Zahlenwerte.

Tutorium 6 - Der digitale Temperatur-Luftfeuchte-Sensor DHT11 ↑

Nun wollen wir uns im sechsten Tutorium ansehen, wie Umweltdaten wie Temperatur und Luchfeuchtigekeit erfasst und am PC angezeigt werden können. Du solltest das Tutorium 5 zumindest durchlesen, um die Funktion der Datenübertratgung zum und Anzeige auf dem PC zu verstehen.

Tutorium 6 - Material

Folgendes Material benötigst du für dieses Tutorium:

• das Microkontroller-Modul aus dem Kit


• das Steckbrett und Steckbrücken aus dem Kit


• das Temperatur-Sensor-Modul DHT11

Tutorium 6 - Durchführung des Experiments

1. Zuerst bauen wir die Experimentierschaltung auf. Dazu nutzen wir den Grundaufbau aus Tutorium 2 (allerdings ohne externe LED).

2. Der Grundaufbau muss(!) wie folgt geändert werden:


a. Entferne die 3V3-Brücke(!)
b. Füge eine Brücke vom Microkontroller-Modul "5V" zum horizontalen Verbinder der mit "+" markiert ist ein



3. Stecke das Sensor-Modul mit etwas Abstand zum Microkontroller-Modul in das Steckbrett

4. Schließe nun das Sensor-Modul an die Versorgungsspannung und Masse an

5. Füge eine Verbindung der Datenleitung vom Sensor-Modul zum Microkontroller-Modul an Pin D3 ein

6. Öffne die Arduino-IDE und lade aus den Beispielen "DHT11Default" (Datei > Beispiele > SimpleDHT > DHT11Default)



7. Schließe das Microkontroller-Modul über die USB-Leitung am PC an und lade den Programmtext hoch

8. Starte nun den "Serieller Monitor" unter Werkzeuge > Serieller Monitor

9. Kontrolliere die Einstellung der Datenrate wie in Tutorium 5 erläutert