Matthias Edler-Golla
matthias.edler-golla@hm.edu
http://matthias-edler-golla.de

ich hoffe nicht…

• Übersicht über Kursinhalte
• Definition „Phyiscal Computing“
• Massimo Banzi & Arduino
• Das Arduino Board
• Verbinden von Computer und Arduino
• Code auf den Arduino laden
• Ansteuern einer LED
• Auslesen von Werten einer Fotozelle (incl. Serial Monitor und Serial Plotter)
• Piezo-Element zum Ausgeben von Geräuschen
• Temperatur-Sensor

1. Semester: Interaktion Grundlagen ✔
2. Semester: Interface Design – Gestaltung von Bildschirmoberflächen (Smartphone-Apps…) ✔
3. Semester: Webdesign – Gestaltung und Programmierung einer Website (z.B. eigenes Portfolio zur Bewerbung fürs Praktikum…) ✔
4. Semester: Digitales Prototyping – Erstellen von digitalen Prototypen; Kombination aus den drei anderen Kursen (Internet of Things-Anwendungen mit Arduino und Raspberry Pi…)

https://matthias-edler-golla.de/index.php/DigitalesPrototyping/Sommersemester19

Gruppe X

1. 21.03.19 Einführung „Digitale Prototyping“, Grundlagen Arduino
2. 04.04.19 Arduino 2
3. 11.04.19 kein Unterricht | Exkursion mit den Masters nach Bozen
4. 02.05.19 Raspberry GUI; VNC-Viewer; SSH Connect;
5. 16.05.19 Raspberry Pi; Bash-Scripte, ImageMagic & SenseHat
6. 06.06.19 Raspberry Pi: Camera, Webinterface, Anschluss Arduino
7. 27.06.19 NodeRed (Prof. Gerhard Schillhuber)

Gruppe Y

1. 28.03.19 Einführung „Digitale Prototyping“, Grundlagen Arduino
2. 18.04.19 kein Unterricht | Ostern Abreisetag
3. 25.04.19 Arduino 2
4. 09.05.19 Raspberry GUI; VNC-Viewer; SSH Connect;
5. 23.05.19 Raspberry Pi; Bash-Scripte, ImageMagic & SenseHat
6. 13.06.19 Raspberry Pi: Camera, Webinterface, Anschluss Arduino
7. 04.07.19 NodeRed (Prof. Gerhard Schillhuber)

Das Teilmodul Digitales Prototyping ist als Fortsetzung des Kurses 301.2 Webdesign für ID-Studierende zu sehen. Die im Webdesign vermittelten Kenntnisse im Bereich von HTML/CSS/Javascript werden in diesem Kurs mit Grundlagen des „Physical Computings“ kombiniert:

Mit HTML/CSS/Javascript ist es relativ einfach möglich, interaktive Prototypen von Smartphone- bzw. Tablet-Applicationen (kurz „Apps“ genannt) zu erstellen. Kombiniert man diese Web-Apps mit Sensoren, Aktoren und Daten z.b. von Microcontrollern (Arduino, Raspberry Pi …) entstehen mehr oder weniger komplexe Prototypen digitaler Produkte, mit denen die Interaktion zwischen Mensch & Maschine getestet werden kann.

Die Grundlagen in Processing bzw. p5.js sind ein guter Start ins Physical Computing – das Programmieren von Arduino verwendet fast die gleiche Entwicklungsumgebung und Programmiersprache…

Video Tutorials

Daniel Shiffmann hat eine ganze Reihe super Tutorials zu Processing, p5.js (und mehr gemacht)

p5-Tutorials aus dem Wintersemester 17/18

Bitte schaut Euch diese noch mal:

• p5-Grundlagen
• p5 Teil 2
• p5 Teil 3

Am Ende des Kurses könnt Ihr folgendes realisieren:

• diverse Sensor-Daten mit Hilfe des Arduino auslesen
• Ausgabe der Sensor-Daten auf einem (lokalen) Webserver (u.a. auch mit p5.js)
• Aktoren wie LEDs oder (Servo-)Motoren ansteuern
• via VNC, SSH und FTP mit einem Raspberry Pi kommunizieren
• den Raspberry Pi dazu nützen, um z.B. Bilder stapelweise auf die richtige Größe zu bringen (Bash-Scripting)
• mit dem Kamera-Modul Zeitraffer-Filme erstellen
• mit Motion eine einfache Überwachungskamera erstellen und den Stream auf einem (lokalen) Webserver darstellen
• …

Das erste Board wurde 2005 von Massimo Banzi und David Cuartielles entwickelt. Der Name „Arduino“ wurde von einer Bar in Ivrea übernommen, in der sich einige der Projektgründer gewöhnlich trafen.

1. Das Arduino-Board bietet digitale Ein- und Ausgänge
2. Das Arduino-Board bietet analoge Ein- und Ausgänge
3. Das Board versorgt Komponenten (Sensoren, Aktoren…) mit Strom
4. Das Board selbst wird per USB oder Netzteil (bzw. Batterie) versorgt

Es gibt noch sehr viele andere Arduino-Boards für unterschiedliche Einsatzzwecke!

Achtung

1. Beim Bauen am Board muß immer die Stromversorgung bzw. der USB-Anschluss am Computer abgezogen sein! Sonst kann das Board kaputt gehen!
2. Die LED muss richtig herum eingesteckt sein! Langes Bein bei 13, kurzes Bein bei GND

Die Farbe der LED ist egal!

Arduino IDE

Macht Euch mit dem Buttons am oberen Rand des Fenster vertraut…

Arduino

// LED ein- und ausschalten

// Einstellungen am Anfang
void setup() {
  // LED auf 13 als OUTPUT
  pinMode(13, OUTPUT);
}

// diese Schleife läuft endlos…
void loop() {
  digitalWrite(13, HIGH);   // LED anschalten
  delay(1000);              // LED 1 sek anlassen
  digitalWrite(13, LOW);    // LED ausschalten
  delay(1000);              // LED 1 sek auslassen
}

Kopiert mal den Code und fügt ihn in Eure Arduino IDE ein…

Arduino hat ein „eingebautes“ Nachschlagewerk, dass auch offline funktioniert!

Dazu den gewünschten Begriff markieren und mit der rechten Mousetaste anklicken. Unter „Find in Reference“ wird dann ein Browserfenster geöffnet…

Klickt man dort auf Language, erhält man einen Überblick über die häufigsten Code-Elemente…

direkt in der Arduino IDE enthalten

Damit Ihr mit dem Arduino kommunizieren könnt, müsst Ihr das richtige Arduino-Board (hier Uno) und den richtigen Port auswählen!

Dann könnt Ihr den Blink-Sketch auf das Board hochladen und probieren, ob dieser funktioniert…

Schreibt einen eigenen Arduino-Sketch, der folgendes macht:

1. Die LED ist 3 Sekunden an
2. Die LED ist 0.5 Sekunden aus
3. Die LED ist 0.5 Sekunden an
4. die LED ist 2 Sekunden aus

…und dann geht es wieder von vorne los…

Sichert den Sketch unter doppelblink auf Eurem eigenen Rechner unter Dokumente>Arduino

Die LED blinkt nur 5 mal und hört dann auf…

Arduino

int ledPin = 13; // an welchem Pin ist die LED angeschlossen?
int anzahl = 5; // Anzahl der Wiederholungen
int i = 0; // Variable zum Zählen
int vz = 500; // Verzögerung in Milisekunden

// Einstellungen am Anfang
void setup() {
  pinMode(ledPin, OUTPUT);          // LED auf Pin 13 als OUTPUT
}

void loop() {

  if (i < anzahl) {
    digitalWrite(ledPin, HIGH);     // LED an
    delay(vz);
    digitalWrite(ledPin, LOW);      // LED aus
    delay(vz);

    i = i + 1; // bei jeder Runde 1 dazu

  } else {  // wenn die Zahl >= Anzahl ist…
    digitalWrite(ledPin, LOW);
  }

}

Ändern: Mit dem Code unten blinkt die LED nur 5 mal und hört dann auf…

Arduino

int ledPin = 13; // an welchem Pin ist die LED angeschlossen?
int anzahl = 5; // Anzahl der Wiederholungen
int i = 0; // Variable zum Zählen
int vz = 500; // Verzögerung in Milisekunden

// Einstellungen am Anfang
void setup() {
  pinMode(ledPin, OUTPUT);          // LED auf Pin 13 als OUTPUT
}

void loop() {

  if (i < anzahl) {
    digitalWrite(ledPin, HIGH);     // LED an
    delay(vz);
    digitalWrite(ledPin, LOW);      // LED aus
    delay(vz);

    i = i + 1; // bei jeder Runde 1 dazu

  } else {  // wenn die Zahl >= Anzahl ist…
    digitalWrite(ledPin, LOW);
  }

}

Am Breadboard sind an den äußeren Rändern die Bahnen + und – waagrecht miteinander verbunden. Im inneren Bereich sind die Bahnen senkrecht verknüpft…

Achtung

Der gezeigte Aufbau soll nur die Funktionsweise erklären.

Baut diesen so nicht auf – die LED wird überhitzt und brennt durch!

… es gibt auch 5-Band-Widerstände – die entsprechende Legende findet Ihr im Arduino Project Book auf Seite 41!

Lösung

1 | 0 | 10² | ±5% = 10 × 100 = 1000Ω = 1kΩ mit ±5% Toleranz

AnalogWrite bedeutet, dass man feine Abstufungen (hier 256 Stufen) einstellen kann. DigitalWrite lässt nur zwei Werte (an/aus, 0/1, ja/nein) zu…

Arduino

int led = 6; // An Pin 6 ist eine LED mit Widerstand 220 Ohm angeschlossen.

void setup() {
  // Den Pin zur Ausgabe festlegen.
  pinMode(led, OUTPUT);
}

void loop() {
  // max. Wert wäre hier 255
  // Die LED leuchtet nun mit 25 % Helligkeit.
  analogWrite(led, 64);
}

Ändert mal den Wert bei analogWrite(); – mehr als 255 geht nicht…

Arduino

int led = 6; // An Pin 6 ist eine LED mit Widerstand 220 Ohm angeschlossen.
int richtung = 1; // richtung gibt an, ob die LED heller oder dunkler werden soll
int i; // zum Hoch- und Runterzaehlen in der for-Schleife

void setup() {
  // Den Pin zur Ausgabe festlegen.
  pinMode(led, OUTPUT);

  // Ausgabe-Werte im Serial Monitor ermöglichen
  Serial.begin(9600);
}

void loop() {

  for (i = 0; i <= 255; i++) {

    analogWrite(led, i * richtung); // die LED wird langsam heller bzw. dunkler

    // Ausgabe der Werte im Serial-Monitor
    Serial.print(i);  // i als Wert im Serial-Monitor ausgeben
    Serial.print(", richtung: ");
    Serial.println(richtung);

    delay(10);  // 10 Milisekunden Verzögerung
  }

  // an den äußeren Rändern der Schleife ändert sich die Richtung
  if ((i >= 255) || (i <= 0)) {
    richtung = -richtung;
    i = 0;
  }
}

Serial Monitor

Öffnet diesen, indem Ihr auf das Lupen-Symbol klickt!

Arduino

int led = 6; // An Pin 6 ist eine LED mit Widerstand 220 Ohm angeschlossen.
int richtung = 1; // richtung gibt an, ob die LED heller oder dunkler werden soll
int i; // zum Hoch- und Runterzaehlen in der for-Schleife

void setup() {
  // Den Pin zur Ausgabe festlegen.
  pinMode(led, OUTPUT);

  // Ausgabe-Werte im Serial Monitor ermöglichen
  Serial.begin(9600);
}

void loop() {

  for (i = 0; i <= 255; i++) {

    analogWrite(led, i * richtung); // die LED wird langsam heller bzw. dunkler

    // Ausgabe der Werte im Serial-Monitor
    Serial.print(i);  // i als Wert im Serial-Monitor ausgeben
    Serial.print(", richtung: ");
    Serial.println(richtung);

    delay(10);  // 10 Milisekunden Verzögerung
  }

  // an den äußeren Rändern der Schleife ändert sich die Richtung
  if ((i >= 255) || (i <= 0)) {
    richtung = -richtung;
    i = 0;
  }
}

Verwendet hierfür einen 10kΩ Widerstand

Arduino

int fotozelle = A0; // Pin Zuweisung bei A0; Widerstand 10 kOhm

void setup() {
  pinMode(fotozelle, INPUT);
  Serial.begin(9600);
}

void loop() {
  int hell = analogRead(fotozelle); // Wert, den Fotozelle ausgibt, wird gelesen

  Serial.print("Helligkeitswertes der Foto-Zelle: ");
  Serial.println(hell); // Ausgabe des Helligkeitswertes der Foto-Zelle

  delay(100);
}

Serial Monitor

Öffnet den Serial Monitor und schaut, welche Werte ausgegeben werden, wenn Ihr z.B. die Fotozelle mit der Hand abdeckt oder mit einen Taschenlampe draufleuchtet.

Theoretisch sollten die Werte zwischen 0 und 1023 liegen…

Serial Plotter

Schließt den Serial Monitor und öffent den Serial Plotter (Menüleiste>Tools>Serial Plotter).

Dort erhaltet Ihr den dazugehörigen Graphen, der laufend aktualisiert wird.

Verwendet einen 10kΩ Widerstand bei der Fotozelle und einen 220Ω Widerstand bei der LED

Arduino

int fotozelle = A0; // Pin Zuweisung bei A0; Widerstand 10 kOhm
int led = 6; // An Pin D6 ist eine LED mit Widerstand 220 Ohm angeschlossen.

void setup() {
  pinMode(fotozelle, INPUT);
  pinMode(led, OUTPUT);
  Serial.begin(9600);
}

void loop() {

  int hell = analogRead(fotozelle); // Wert, den Fotozelle ausgibt, wird gelesen

  Serial.println(hell); // Ausgabe des Helligkeitswertes der Foto-Zelle

  // hell ist ein Wert zwischen 0 und 1023
  // die LED verträgt aber nur Wert zwischen 0 und 255
  // deswegen teile ich hell durch 4; (probiert auch mal 3 aus, weil Fotozelle real nicht bis 1024 geht…
  // 255 - hell/4 bewirkt, dass die LED umso dunkler wird, desto heller das Umgebungslicht ist
  analogWrite(led, 255 - hell / 4);

  delay(100);
}

Verwendet einen 10kΩ Widerstand bei der Fotozelle und einen 220Ω Widerstand bei der LED

Arduino

int fotozelle = A0; // Pin Zuweisung bei A0; Widerstand 10 kOhm
int led = 6; // An Pin D6 ist eine LED mit Widerstand 220 Ohm angeschlossen.

void setup() {
  pinMode(fotozelle, INPUT);
  pinMode(led, OUTPUT);
  Serial.begin(9600);
}

void loop() {

  int hell = analogRead(fotozelle); // Wert, den Fotozelle ausgibt, wird gelesen

  Serial.println(hell); // Ausgabe des Helligkeitswertes der Foto-Zelle

  // hell ist ein Wert zwischen 0 und 1023
  // die LED verträgt aber nur Wert zwischen 0 und 255
  // deswegen teile ich hell durch 4; (probiert auch mal 3 aus, weil Fotozelle real nicht bis 1024 geht…
  // 255 - hell/4 bewirkt, dass die LED umso dunkler wird, desto heller das Umgebungslicht ist
  analogWrite(led, 255 - hell / 4);

  delay(100);
}

Verwendet einen 10kΩ Widerstand bei der Fotozelle und einen 220Ω Widerstand bei der LED.

Das Piezo-Element braucht keinen Widerstand und es spielt auch keine Rolle, wierum Ihr es auf das Breadboard steckt.

Arduino

int fotozelle = A0; // Pin Zuweisung bei A0; Widerstand 10 kOhm
int led = 6; // An Pin D6 ist eine LED mit Widerstand 220 Ohm angeschlossen.
int piezo = 3; // Piezo bei D3 angeschlossen

void setup() {
  pinMode(fotozelle, INPUT);
  pinMode(led, OUTPUT);
  pinMode(piezo, OUTPUT);
  Serial.begin(9600);
}

void loop() {

  int hell = analogRead(fotozelle); // Wert, den Fotozelle ausgibt, wird gelesen

  Serial.print("Helligkeitswertes der Foto-Zelle: ");
  Serial.println(hell); // Ausgabe des Helligkeitswertes der Foto-Zelle

  analogWrite(led, 255 - hell / 4);

  // wenn es zu dunkel wird, geht der Alarm an
  if (hell < 550) {
    playTone(300, 160); // externe Funktion, siehe unten!
  }

  delay(300);
}

// 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);
  }
}

Foto Hardware-Aufbau

Da kommt einiges zusammen!

Arduino

int fotozelle = A0; // Pin Zuweisung bei A0; Widerstand 10 kOhm
int led = 6; // An Pin D6 ist eine LED mit Widerstand 220 Ohm angeschlossen.
int piezo = 3; // Piezo bei D3 angeschlossen

void setup() {
  pinMode(fotozelle, INPUT);
  pinMode(led, OUTPUT);
  pinMode(piezo, OUTPUT);
  Serial.begin(9600);
}

void loop() {

  int hell = analogRead(fotozelle); // Wert, den Fotozelle ausgibt, wird gelesen

  Serial.print("Helligkeitswertes der Foto-Zelle: ");
  Serial.println(hell); // Ausgabe des Helligkeitswertes der Foto-Zelle

  analogWrite(led, 255 - hell / 4);

  // wenn es zu dunkel wird, geht der Alarm an
  if (hell < 550) {
    playTone(300, 160); // externe Funktion, siehe unten!
  }

  delay(300);
}

// 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);
  }
}

Verwendet einen 10kΩ Widerstand bei der Fotozelle.

Das Piezo-Element braucht keinen Widerstand und es spielt auch keine Rolle, wierum Ihr es auf das Breadboard steckt.

Arduino

// Aus dem „Arduino Projects Book“, S. 71ff

int sensorValue;
int sensorLow = 1023;
int sensorHigh = 0;

// const = unveränderbarer Wert
const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, HIGH);

  // Kalibriert die Fotozelle
  // in diesem Zeitraum die Hand über die Zelle so bewegen
  // dass die gewünschten Max- und Min-Werte eingestellt werden können
  while (millis() < 5000) {
    sensorValue = analogRead(A0);

    if (sensorValue > sensorHigh) {
      sensorHigh = sensorValue;
    }

    if (sensorValue < sensorLow) {
      sensorLow = sensorValue;
    }
  }

  // wenn die LED ausgeht, ist das Kalibrieren fertig
  digitalWrite(ledPin, LOW);
}

void loop() {
  sensorValue = analogRead(A0);

  // 50 - 4000 = Range of Frequency of Piezo
  // map überträgt die Sensor-Werte auf die Range der Frequency
  int pitch = map(sensorValue, sensorLow, sensorHigh, 50, 4000);

  // Ton an Pin8, 20 Millisekunden Länge
  tone(8, pitch, 20);

  // LED an, wenn pitch sehr niedrig ist
  if (pitch < 300){
    digitalWrite(ledPin, HIGH);
  } else {
   digitalWrite(ledPin, LOW);
  }

  delay(10);
}

Spielt mal mit den Werten der Frequenz und auch der Tonlänge…

Hardware-Aufbau

Bitte achtet darauf, dass auf dem Sensor tatsächlich „Temp“ steht und dass Ihr diesen richtigherum (flache Seite Richtung Arduino) eingebaut habt!

Arduino

// Arduino Project Book, Seite 43ff

// Analoger Eingang 0
int sensorPin = A0;

// Widerstand hier wieder 220Ω
int ledPin = 2;

// Grenzwert-Temperatur, wenn LED an/ausgehen soll
float grenzwert = 24.0;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {

  // roher Sensor-Wert
  int sensorVal = analogRead(sensorPin);

  Serial.print("Sensor Wert roh: ");
  Serial.println(sensorVal);

  // Umrechung in Volt (muss zwischen 0V und 5V liegen!)
  float voltage = (sensorVal / 1024.0) * 5.0;

  Serial.print("Volt: ");
  Serial.println(voltage);

  // Temperatur in Celsius
  float temperature = (voltage - 0.5) * 100;

  Serial.print("Temperatur: ");
  Serial.print(temperature);
  Serial.println(" C\n"); // \n erzwingt eine Leerzeile

  // Wenn die Temperatur unter einen bestimmten Wert fällt
  // soll die LED angehen
  if (temperature < grenzwert){
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }

  // Messung alle 0.5 sek
  delay(500);
}

Erweitert den Temperatur-Sensor-Sketch um folgende Funktion:

Es gibt eine weitere LED; die erste geht an, wenn die Temperatur unter einen bestimmten Wert fällt; die zweite LED geht an, wenn die Temperatur über diesen Wert geht. (Die erste LED ist dann aus). Verwendet dazu nach Möglichkeit unterschiedliche LED-Farben

Königsaufgabe

Wer schafft es, 3 LEDs anzusteuern?

1. LED unterhalb eines bestimmten Wertes
2. LED oberhalb des Wertes, aber unterhalb eines weiteren Wertes
3. LED oberhalb des weiteren Wertes

Mögliche Abstufungen: 1. Grenzwert: 24° C, 2. Grenzwert: 27°C

Arduino

// Code-Schnipsel für die Bedingungen

if (temperature < grenzwert_1) { // unterer Bereich

// Bereich zwischen den Grenzwerten, durch 2 Bedingungen bestimmt!
// deswegen das &&
} else if (temperature > grenzwert_1 && temperature < grenzwert_2) { 

} else { // oberer Bereich

}