Digitales Prototyping: Arduino Grundlagen / 2022-03-17 / Matthias Edler-Golla, CC BY-SA 4.0



Hallo!

Schön, Euch alle mal wieder (live!) zu sehen!


Unterricht „Interaction Design“

Innerhalb der ersten 4 Semester habt Ihr vier aufeinander aufbauende Module, die alle direkt oder indirekt mit Interaction Design zu tun haben:

  1. Semester: Interaktion Grundlagen
  2. Semester: Interface Design
  3. Semester: Webdesign
  4. Semester: Digitales Prototyping

Website zum Kurs

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

Wie immer findet Ihr dort auch meine Scripte und – falls nötig – den Link zu meinem Zoom-Raum!


Physical Computing

Arduino Uno mit Ultraschall-Sensor, LCD-Display und Piezo-Modul

Physical Computing bedeutet im weitesten Sinne, interaktive, physische Systeme durch die Verwendung von Hardware und Software zu erstellen. Diese Systeme reagieren auf Ereignisse in der realen, analogen Welt und/oder wirken auf sie ein.

Wikipedia

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

Bitte schaut Euch diese noch mal:


Was lernt Ihr in diesem Kurs?

Bild von matthew venn

Im Kurs schauen wir uns sowohl Microcontroller (Arduino) als auch Einplatinencomputer (Raspberry Pi) genauer an – und kombinieren deren unterschiedlichen Fähigkeiten.

Am Ende des Kurses könnt Ihr folgendes realisieren:

Arduino

  • diverse Sensor-Daten mit Hilfe des Arduino auslesen
  • diverse Actoren mit Arduino ansteuern
  • Werte von Sensoren wirken sich direkt auf die Aktoren aus

Raspberry Pi

  • mit dem Raspi via SSH kommunizieren
  • div. CLI-Programme ausführen
  • den Raspi als Webserver nutzen
  • die Raspi-Kamera dazu nützen, Fotos und Videos zu erstellen
  • Sensor-Daten des Arduino auf dem Raspi einlesen und als Daten-Grafiken (p5.js) ausgeben

Gemeinsames Abschlussprojekt

FK12-Entdecker: Neue Perspektiven

gemeinsame Aufgabenstellung für die Kurse 403.2 Technisches Design (Prof. Florian Petri) und 403.1 Dig. Prototyping (Prof. Matthias Edler-Golla)

Wendet das in den beiden Kursen erlernte Wissen zu analogem und digitalem Prototyping an, um funktionale Prototypen zu erstellen – baut „FK12-Entdecker“! Die umgesetzten Prototypen ermöglichen es neue Blicke auf die Außen- und Innenräume unserer Fakultät zu werfen und dem Gebäude so manches bisher unentdeckte zu entlocken. Die erzeugten Artefakte können stationär sein, sich aber auch kriechend, fahrend, fliegend (…) fortbewegen. Sie sollen selbstständig Filme, Fotos, Geräusche oder andere Sensor-Daten aufzeichnen, so dass diese nachträglich betrachtet, angehört oder visuell (z.B. als Info-Grafiken) ausgewertet werden können.

Spielregeln

  • Zu konzipieren und umzusetzen sind physische Prototypen der „FK12-Entdecker.“
  • Die funktionalen Prototypen sind in der Lage selbstständig Filme, Fotos, Geräusche oder andere Sensor-Daten im oder rund um das Fakultätsgebäude aufzuzeichnen.
  • Die Prototypen bestehen ausschließlich aus digital zu fertigenden Bauteilen (3D-Druck, CNC-Fräsen, Laser-Cutten) sowie den benötigten elektronischen Bauteilen (Arduinos, Raspberry Pis und Sensoren).
  • Die verwendeten Arduinos, Raspberry Pis und Sensoren müssen so verbaut sein, dass diese wieder schadlos ausgebaut werden können.
  • Alle digital gefertigten Bauteile müssen austauschbar und die Objekte somit reparierbar sein.
  • Teams von max. 3 Leuten.

Am Ende abzugeben

  • HTML-Dokumentation, die es anderen ermöglicht, die gezeigten Projekte nachzubauen
  • Verwendeter Code zum Kopieren
  • Dateien zur digitalen Fertigung der Prototypen (z.B. STL-Dateien) auf 3D-Drucker, CNC-Fräse oder Lasercutter
  • Fotos der Objekte
  • Fotos aus der Entwicklungs- und Testphase
  • entstandene Filme, Datenaufzeichnungen etc.

Arduino-Kits

Wir haben unterschiedliche Kits – es kann sein, dass Eure Verpackung anders aussieht…

Jede(r) von Euch bekommt ein eigenes Arduino-Kit. Ihr könnt diese bis zum Ende des Kurses behalten und auch gerne weiter damit experimentieren…

Bitte schaut, dass Ihr es dann wieder sortiert und vollständig zurück gebt!


Themen heute

  • Das Arduino Board

  • Verbinden von Computer und Arduino

  • Code auf den Arduino laden

  • Ansteuern einer LED

  • die Arduino IDE

  • Wiederholung wichtiger „Programmier-Bausteine“ (Variablen, Loops, if/then-Strukturen)

  • Auslesen von Werten einer Fotozelle (incl. Serial Monitor und Serial Plotter)

  • Piezo-Element zum Ausgeben von Geräuschen

  • Temperatur-Sensor


Arduino

Bild von Wikipedia

Arduino ist eine aus Soft- und Hardware bestehende Physical-Computing-Plattform. Beide Komponenten sind im Sinne von Open Source quelloffen. Die Hardware besteht aus einem einfachen E/A-Board mit einem Mikrocontroller und analogen und digitalen Ein- und Ausgängen. Die Entwicklungsumgebung basiert auf Processing (p5.js) und soll auch technisch weniger Versierten den Zugang zur Programmierung und zu Mikrocontrollern erleichtern.

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.


Massimo Banzi: Arduino verleiht Open Source Flügel

Massimo Banzi half beim Erfinden von Arduino, diesem kleinen, einfach anzuwendenden Open-Source-Mikrocontroller, der tausende Menschen auf dem Globus dazu inspiriert hat, coole Sachen zu fabrizieren -- von Spielzeug bis hin zu Satelliten. Denn wie er sagt: „Man braucht von niemandem die Erlaubnis, um etwas Großartiges zu erschaffen.“


Software installiert?

https://www.arduino.cc/en/Main/Software

Habt Ihr die Arduino-Sachen ausgepackt und die Software installiert?

https://www.arduino.cc/en/Main/Software


Arduino-Board UNO

http://fritzing.org

  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!


Ardunio Blinking LED (Hardware)

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!


Ardunio Blinking LED (Software)

https://www.arduino.cc/en/Main/Software

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…


Nachschlage-Werk (Reference)

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…


Arduino Code-Beispiele

direkt in der Arduino IDE enthalten


Verbinden von Computer und Arduino

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

Verbindung an einem Windows-Rechner

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


eingebaute Arduino LED

Die Arduino-Boards haben neben PIN 13 eine eingebaute LED, die immer dann blinkt, wenn Ihr PIN 13 im Code ansprecht. Das ist sehr praktisch, weil ihr dann nicht immer LEDs anschließen müsst, um kurz etwas auszuprobieren…

Arduino

void setup() {
  // eingebaute LED auf 13 ansprechen
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);   
  delay(1000);              
  digitalWrite(13, LOW);    
  delay(1000);            
}

Arduino Variablen

Bei Arduino müßt Ihr genau angeben, welche Art von Variable Ihr verwenden möchtet – bei Javascript/p5.js ist das nicht nötig!

  • Die Variablen-Namen könnt Ihr selbst wählen – sie müssen jedoch mit einem Buchstaben anfangen.
  • Vermeidet Sonderzeichen ("äöüß…")!
  • Namen kurz halten aber auch verständlich! ("kp234" ist unverständlich, "hellStufe" selbsterklärend)

Es gibt verschiedene Arten von Variablen, die geläufigsten sind:

Arduino

// boolean kann nur "true" oder "false" sein
// wie ein Lichtschalter…
boolean lichtAn = false;
boolean RadioLaeuft = true;

// ganze Zahlen
int s = 15;
int meineTemperatur = -12;

// Zahlen mit Kommastelle – Punkt verwenden!
float durchschnitt = 3.456;
float b = - 1.435;

// einzelne Buchstaben – müssen mit 'Singlequotes' angegeben werden
char meinBuchstabe = 'A';

// mehrere Buchstaben müssen als ein Array '[]' gespeichert werden
char meinString[] = "This is the first line";

Im Gegensatz dazu wird bei p5.js und Javascript nicht unterschieden, um welche Art von Variable es sich handelt

Javascript (p5.js)

var lichtAn = false;
var RadioLaeuft = true;

var s = 15;
var meineTemperatur = -12;

var durchschnitt = 3.456;
var b = - 1.435;

var meinBuchstabe = 'A';

var meinString[] = "This is the first line";

Das könnt Ihr in Arduino aber nicht verwenden!


Arduino Bare Minimum

Auch hier wird die Ähnlichkeit zu p5.js sichtbar – nur die Begrifflichkeiten sind anders!

Bei p5.js haben wir die "draw"-Function genutzt, um z.B. Animationen zu machen…

p5.js

function setup() {
    // hier die Sachen einfügen, die beim Start des Programms 
    // einmalig gemacht werden sollen
}

function draw(){
    // hier die Sachen einfügen, die immer wieder ablaufen sollen
}

loop

bei Arduino wird "loop" benutzt, um z.B. die LED immer wieder an- oder auszuschalten…

Arduino

void setup() {
    // hier die Sachen einfügen, die beim Start des Programms 
    // einmalig gemacht werden sollen
}

void loop() {
    // hier die Sachen einfügen, die immer wieder ablaufen sollen
}

konkretes Beispiel

… das Ihr vorhin schon verwendet habt, um die LED blinken zu lassen …

Arduino

// Einstellungen am Start des Programmes
void setup() {
  pinMode(13, OUTPUT);
}

// diese Schleife läuft endlos, bzw. bis Ihr den Stecker zieht
void loop() {
  digitalWrite(13, HIGH);
  delay(1000); 
  digitalWrite(13, LOW);
  delay(1000);
}

For-Loops

For-Loops nutzen, um z.B. mehrere Sachen gleichzeitig ein- oder auszuschalten…

Statt jede LED einzeln anzusprechen, werden alle 5 LEDs (PIN 8 bis 13) gleichzeitig als OUTPUT definiert und dann ein-/ausgeschaltet…

Arduino

void setup() {
  // alle Pins, an denen LEDs stecken, sollen als OUTPUT geschaltet werden
  for (int i = 8; i <= 13; i++) {
    pinMode(i, OUTPUT);
  }
}

void loop() {
  // alle Pins, an denen LEDs stecken, sollen GLEICHZEITIG an-ausgeschaltet werden
  for (int i = 8; i <= 13; i++) {
    digitalWrite(i, HIGH);    // anschalten
    delay(300);               // warten = LEDs leuchten für 300ms
    digitalWrite(i, LOW);     // ausschalten
    delay(500);               // warten = LEDs bleiben für 500ms aus
  }
}

Um den oben gezeigten Code auszuprobieren, müsst Ihr 5 LEDs an den Arduino anschließen. Dazu braucht Ihr ein Breadboard – das entsprechende Beispiel folgt etwas weiter hinten!


if-else-Strukturen

if/else verwenden, um Bedingungen abfragen und dann entsprechend Anweisungen verändern…

Nur wenn die Variable "anzahl" kleiner 8 ist, soll die LED, die bei PIN 13 angeschlossen ist, schnell blinken. Danach soll sie langsam blinken…

Arduino

int ledPin = 13;                    // an welchem Pin ist die LED angeschlossen?
int anzahl = 8;                     // Anzahl der Wiederholungen
int i = 0;                          // Variable zum Zählen
int schnell = 200;                  // in Milisekunden
int langsam = 1000;                 // 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(schnell);
    digitalWrite(ledPin, LOW);      // LED aus
    delay(schnell);

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

  } else {  // wenn die Zahl >= anzahl ist…
    digitalWrite(ledPin, HIGH);     // LED an
    delay(langsam);
    digitalWrite(ledPin, LOW);      // LED aus
    delay(langsam);
  }

}

Hinweis

Die Arduino-Boards haben neben PIN 13 eine eingebaute LED, die immer dann blinkt, wenn Ihr PIN 13 im Code ansprecht. Das ist sehr praktisch, weil ihr dann nicht immer LEDs anschließen müsst…


Übung 1: anders blinken

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


Übung 2: Länger leuchten

Wie müsst Ihr den Code ändern, dass die LED bei jeder Wiederholung um eine halbe Sekunde länger leuchtet, die Pausen jedoch immer eine halbe Sekunde lang bleiben? Nach dem 10 Leuchten soll sie dann ganz aufhören zu leuchten.

Ä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 = 200;                       // Verzögerung in Milisekunden

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

Elektrische Widerstände

Jedes elektronische Bauelement hat einen spezifischen Widerstand. Normaler Weise ist dieser relativ klein, d.h. dass der Strom schnell das Bauteil durchströmen kann, da er kaum behindert wird. Das ist für viele Bauteile aber kritisch, da sie durch zu hohe Ströme zerstört werden können.

Eine LED verträgt nur sehr wenig Strom und eine geringe Spannung. Um sie zu schützen, schaltet man die LED mit einem Widerstand in Reihe. Der Widerstand begrenzt den Stromfluss und schützt somit die LED.


Farbcode der Widerstände (4 Band)

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


Welcher Widerstand ist das?

für Lösung runterscrollen…

Lösung

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


Widerstand messen mit dem Multimeter

https://learn.adafruit.com/multimeters/


Breadboards

Eine Steckplatine (englisch breadboard), auch „Steckbrett“, „Steckboard“ oder „Protoboard“, dient der mechanischen Befestigung und der elektrischen Verbindung von elektronischen Bauteilen für Versuchsschaltungen und Experimente.

Im Gegensatz zu Leiterplatten werden bei Steckplatinen die Bauteile nicht gelötet, sondern in Federkontakte gesteckt. Dadurch kann die Schaltung durch einfaches Umstecken geändert werden. Steckplatinen werden häufig im Hobbybereich und teilweise auch in Schulen/Ausbildung verwendet, da der Aufbau schnell vonstatten geht und kein Löten erforderlich ist.

Sie sind deswegen ideal, um schnell Prototypen aufzubauen!


Funktionsweise Breadboard

Am Breadboard sind an den äußeren Rändern die Bahnen + und – waagrecht miteinander verbunden.

Im inneren Bereich sind die Bahnen senkrecht verbunden…

Achtung

Der gezeigte Aufbau soll nur die Funktionsweise erklären.

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


Breadboard & AnalogWrite

Baut die abgebildete Konstellation bitte genau nach! Der Widerstand muß ca. 200Ω haben, sonst brennt die LED durch! Achtet auch darauf, dass das längere Beinchen der LED mit PIN 6 verbunden ist – sonst geht es nicht.

Beachtet das Symbol "~" neben der Zahl "6" auf dem Arduino. Dies zeigt an, dass diese PIN auch als analoge PIN genutzt werden kann. An einer PIN ohne dieses Zeichen könntet Ihr diesen Sketch nicht erfolgreich machen – dort gibt es nur "Ein" oder "Aus", weil es eben eine digitale PIN ist…

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…


LED leuchtet animiert

gleicher Aufbau wie beim vorherigen Sketch!

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() {
  pinMode(led, OUTPUT);
}

void loop() {
  for (i = 0; i <= 255; i++) {
    if (richtung == 1) {
      analogWrite(led, i);          // die LED wird langsam heller
    } else {
      analogWrite(led, 255 - i);    // die LED wird langsam dunkler
    }
    delay(20);                      // 20 Milisekunden Verzögerung
  }

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

Ausgabe von Werten via Serial Monitor

gleicher Aufbau wie beim vorherigen Sketch!

Der Serial Monitor gibt Werte aus, die vom Arduino via des Kabels an den Mac/PC geschickt werden. Das ist extrem praktisch, um z.B. beim Debugging herauszubekommen, was gerade auf dem Arduino los ist…

Der Code ist identisch mit dem vorherigen Sketch – es sind nur die Anweisungen eingefügt, die die Kommunikation mit dem Serial Monitor ermöglicht.

Arduino

int led = 6;
int richtung = 1; 
int i;
int h;                                   // "h" für Helligkeit

void setup() {
  pinMode(led, OUTPUT);

  // Ausgabe-Werte im Serial Monitor ermöglichen
  // Achtet auf den Wert "9600"
  // der gleiche Wert muss beim Serial Monitor bei der Baud-Rate eingestellt sein!
  Serial.begin(9600);           
}

void loop() {
  for (i = 0; i <= 255; i++) {
    if (richtung == 1) {
      analogWrite(led, i);               // die LED wird langsam heller
      h = i;
    } else {
      analogWrite(led, 255 - i);         // die LED wird langsam dunkler
      h = 255 - i;
    }
    delay(20);                           // 20 Milisekunden Verzögerung

    // diverse Ausgaben der Werte im Serial-Monitor
    Serial.print("i-Wert: ");
    Serial.print(i);
    Serial.print(", Helligkeitswert: ");
    Serial.print(h);                     // h als Wert im Serial-Monitor ausgeben
    Serial.print(", richtung: ");
    Serial.print(richtung);   

    // "println" erzeugt einen Zeilenumbruch
    if (richtung == 1){
      Serial.println(", LED wird heller");
    } else {
      Serial.println(", LED wird dunkler");
    }

    delay(10);
  }

  if ((i >= 255) || (i <= 0)) {
    richtung = -richtung;
    i = 0;
  }
}

Serial Monitor

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

Ausgabe auf dem Serial Monitor


Übung 3: Zwei LEDs leuchten animiert

Baut den Versuchsaufbau und den Sketch so aus, dass 2 LEDs animiert leuchten! Ändert den Code so, dass die eine LED am hellsten leuchtet, wenn die andere am dunkelsten ist.

ähnlicher Aufbau wie beim vorherigen Sketch – nur mit 2 LEDs und 2 Widerständen…

Nutzt Variablen und den Serial Monitor, um Euch die Werte für die beiden LEDs anzeigen zu lassen! Was müsst Ihr dafür am Code ändern?

Arduino

int led = 6;
int richtung = 1; 
int i;
int h;                                   // "h" für Helligkeit

void setup() {
  pinMode(led, OUTPUT);

  Serial.begin(9600);           
}

void loop() {
  for (i = 0; i <= 255; i++) {
    if (richtung == 1) {
      analogWrite(led, i);               // die LED wird langsam heller
      h = i;
    } else {
      analogWrite(led, 255 - i);         // die LED wird langsam dunkler
      h = 255 - i;
    }
    delay(20);                           // 20 Milisekunden Verzögerung

    // diverse Ausgaben der Werte im Serial-Monitor
    Serial.print("i-Wert: ");
    Serial.print(i);
    Serial.print(", Helligkeitswert: ");
    Serial.print(h);                     // h als Wert im Serial-Monitor ausgeben
    Serial.print(", richtung: ");
    Serial.print(richtung);   

    // "println" erzeugt einen Zeilenumbruch
    if (richtung == 1){
      Serial.println(", LED wird heller");
    } else {
      Serial.println(", LED wird dunkler");
    }

    delay(10);
  }

  if ((i >= 255) || (i <= 0)) {
    richtung = -richtung;
    i = 0;
  }
}

Sensoren

Google Suche nach Arduino Sensoren

Ein Sensor (von lateinisch sentire, dt. „fühlen“ oder „empfinden“), auch als Detektor, (Messgrößen- oder Mess-)Aufnehmer oder (Mess-)Fühler bezeichnet, ist ein technisches Bauteil, das bestimmte physikalische oder chemische Eigenschaften (physikalisch z. B. Wärmemenge, Temperatur, Feuchtigkeit, Druck, Schallfeldgrößen, Helligkeit, Beschleunigung oder chemisch z. B. pH-Wert, Ionenstärke, elektrochemisches Potential) und/oder die stoffliche Beschaffenheit seiner Umgebung qualitativ oder als Messgröße quantitativ erfassen kann. Diese Größen werden mittels physikalischer, chemischer oder biologischer Effekte erfasst und in ein weiterverarbeitbares elektrisches Signal umgeformt.


Fotozelle zum Messen der Helligkeit

Fotozelle bei eBay

Mit einer Fotozelle kann die Intensität von Licht mit geeigneter Wellenlänge gemessen werden. Sie besteht aus zwei Elektroden in einem evakuierten Glaskolben und wird in weiterem Sinn zu den Elektronenröhren gezählt. Durch das einfallende Licht werden aufgrund des äußeren photoelektrischen Effekts Elektronen aus der Photokathode herausbeschleunigt. Falls diese Elektronen die Anode treffen, werden sie abgeleitet und sind als Photostrom messbar. Andernfalls werden sie von der Kathode wieder angezogen.

Wie Ihr bei der Abbildung oben sehen könnt, sind Fotozellen sehr günstig zu haben…


Photo-Resistor (Fotozelle): Serial Monitor & Serial Plotter

Verwendet hierfür einen 10kΩ Widerstand. Bei der Fotozelle ist es egal, wie Ihr diese in das Breadboard steckt…

Arduino

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

void setup() {
  // das ist hier anders als bei den bisherigen Beispielen, weil hier Werte eingelesen werden!
  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.


Photo-Resistor & LED

Die LED wird dunkler, wenn mehr Licht auf die Fotozelle fällt – sie reagiert somit auf den Sensorwert!

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

Übung 4: Photo-Resistor & LED synchron

Wie müsst Ihr den Code ändern, dass die LED umso heller wird, desto heller das Umgebungslicht 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);
}

Speichert die Übung als photoResistorLED auf Eurem Rechner


Photo-Resistor & LED & Piezo

Ein Piezoelement ist ein Bauteil, das den Piezoeffekt ausnutzt, um entweder durch Anlegen einer elektrischen Spannung eine mechanische Bewegung auszuführen (Piezoaktor, verwendet den sogenannten inversen Piezoeffekt), oder bei Einwirkung einer mechanischen Kraft eine elektrische Spannung zu produzieren.

Wir nutzen das Piezo-Element, um damit Töne zu erzeugen…

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!*

Übung 5: Photo-Resistor & LED & Piezo

  1. Ändert den Code so, dass der Alarm angeht, wenn das Umgebungslicht sehr hell wird
  2. Ändert den Code so, dass der Alarm angeht, wenn das Umgebungslicht entweder sehr hell oder sehr dunkel wird – der Alarm also nur aus ist, wenn das Umgebungslicht „mittelhell“ ist…

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

Speichert den Sketch als helligkeit_led_piezo auf Eurem Rechner


Light Theremin – ein schauriges Musikinstrument

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.

Beachtet, wie in dem Arduino-Code das setup genutzt wird, um die Fotozelle zu kalibrieren – raffiniert!

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


Melodie abspielen

Sketch spielt beim Start eine Melodie ab…

Der Aufbau ist wie bei den vorherigem Beispielen, das Piezo-Element ist jedoch an PIN 8 angeschlossen…

Aus den von Arduino mitgelieferten Beispielen

In der ausgelagerten Datei "pitches.h" befinden sich die Definitionen für die einzelnen Noten. Diese Datei ist ebenfalls in der Arduino IDE einsehbar und befindet sich im gleichen Ordner wie der Sketch "toneMelody.ino"

Baut doch das Beispiel nach und spielt mit der Ausgabe von Melodien…


Library einfügen

Einfügen einer existierenden Library

Viele Sketches benötigen Libraries, die entweder schon installiert sind oder aber noch aus dem Internet geladen werden müssen. Um diese zu verwalten in der Menüleiste auf Sketch > Include Ligrary klicken.

Exist. Library einfügen

siehe Screenshot oben!

Die ausgewählten Libraries fügen sich dann oben im Sketch ein:

Arduino

// hier 3 eingefüge Libraries
#include <NewPing.h> 
#include <Wire.h> // Wire Bibliothek einbinden
#include <LiquidCrystal_I2C.h>

…

void setup() {
  …
}

neue Library hinzufügen

dazu wieder in der Menüleiste auf Sketch > Include Library klicken und dort Manage Libraries auswählen.

Die gesuchte Library wird dann aus dem Internet geladen und bei den existierenden Libraries eingefügt.


Eigener Leitfähigkeitssensor

an das Ende des braunen Kabels könnt Ihr alles mögliche Leitfähiges hängen und somit selber Buttons und Interface-Elemente erstellen – probiert mal was aus.

Super geht z.B. Alufolie oder auch eine Thermoskanne aus Metall…

Library CapacitiveSensor

Die Library CapacitiveSensor bitte herunterladen und bei Arduino installieren – sonst geht der Sketch nicht!

Die so heruntergeladene Library lässt sich am einfachsten in Arduino einfügen, wenn man diese als Zip-Datei hinzufügt:

Widerstand 1MΩ // ACHTUNG: Dieser Widerstand ist nicht in jedem Arduino-Kit! Sucht einen Widerstand, der dem Wert 1MΩ möglichst nah kommt.

Arduino

// z.b. Alu-Folie an Kabel 2 und 4
// dazwischen Widerstand 1MΩ

#include <CapacitiveSensor.h>

CapacitiveSensor capSensor = CapacitiveSensor(4, 2);

// den Wert testen (Serial.print), hängt stark davon ab, welchen Widerstand man verwendet!
int threshold = 200; 

int ledPin = 13; // LED, längerer Fuss in 13, kurzer in Ground

int piezo = 8; // Anschluss des Piezo-Elements

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

void loop() {
  long sensorValue = capSensor.capacitiveSensor(30);

  Serial.print("Leitfaehigkeit: ");
  Serial.print(sensorValue);
  Serial.println(";");

  if (sensorValue > threshold) {
    digitalWrite(ledPin, HIGH);

    // variabler Ton
    tone(piezo, sensorValue, 100);

  } else {
    digitalWrite(ledPin, LOW);
  }

  // sehr kurze Verzögerung
  delay(100);
}

Electric Paint

leitende Farbe: bareconductive.com/shop/electric-paint-10ml

Bleistift-Buttons

umso weicher der Bleistift, desto besser geht es…


Übung 7: 2 LEDs mit Bleistiftbuttons

Passt den gerade vorgestellten Code so an, dass Ihr 2 „Bleistift-Buttons“ habt, die jeweils eine LED ein-/ausschalten.

… gerade diese Library macht es ziemlich einfach möglich, Hardware-Prototypen zu erstellen, bei denen z.B. Lichter eingeschaltet werden oder Motoren anfangen zu laufen, sobald man eine Fläche berührt.

Häufig braucht Ihr dazu noch ein Relais, das wir beim nächsten Mal besprechen werden.


Fritzing

Fritzing ist eine freie Software, welche es ermöglicht, elektronische Schaltungen an einem Computer zu entwerfen. Ziel der Software ist es, Entwickler dabei zu unterstützen, ihre Projektideen in die Tat umzusetzen. Die Software wurde von Angehörigen der Fachhochschule Potsdam erstellt.

Mit der Fritzing App habe ich alle hier gezeigten Aufbauten gezeichnet – die App kann aber noch deutlich mehr!

Ihr könnt die Software hier herunterladen – sie kostet alllerdings € 8.-


Buchempfehlung (kostenlos als PDF)

https://hackspace.raspberrypi.org/articles/get-started-with-arduino-book

We've been featuring great Arduino content since issue 1, and we've gathered up our favourite Arduino articles and compiled them together in this book. It includes our series on learning Arduino programming to get you started, a great range of projects to help you hone your skills, and our pick of the best projects from the makersphere to inspire you.

Das Buch „Get Started with Arduino“ könnt Ihr kostenlos als PDF herunterladen!


Danke

Zoom-Aufzeichnungen

vom Kurs „Digitales Prototyping“ (SoSe21) gibt es Zoom-Aufzeichnungen, die Ihr Euch gerne ansehen könnt!

Achtung: Wir sehen uns erst am 31.3. wieder – nächste Wochen finden die Probevorlesungen für die Professur „UX und Digitales Servicedesign“ statt!

Alle Scripte durchsuchen

Weitere Vorträge: