Arduino Weather Lab by iD-neuwerk

Arduino Weather Lab Workshop mit Max von Elverfeldt Im Projekt: Vom Naturph채nomen zum Artefakt Design-Strategien zu Witterung, Wetter, Klima Komplexes Gestalten / Entwurf, Studiengang Industriedesign, Burg Giebichenstein Kunsthochschule Halle, Sommersemester 2016

Arduino Weather Lab

Fantastologisches Labor Arduino Workshop

Liebe TeilnehmerInnen, am Montag startet unser fantastologisches Labor rund um das Thema Arduino, Elektronik und Physical Computing. In der nächsten Woche lernen wir gemeinsam Elektronik zu programmieren, zu hacken und werden eigene kleine Installationen erstellen. Hier noch die wichtigsten Infos vorab, damit wir mehr Zeit zum Basteln haben. Wir treffen uns Montag 10:00 in Eurem Projektraum. Bitte bringt dann einen Computer mit und installiert vorher die Arduino und die Teensy Software – in der Reihenfolge. 1 – Arduino Software https://www.arduino.cc/en/Main/Software 2 – Teensy Software https://www.pjrc.com/teensy/loader.html Wer einen Lötkolben besitzt, darf diesen gerne mitbringen. Kleine Aufgabe zu Montag: Viele Musikprogramme können mit der Tastatur gesteuert werden. Einige Beispiele dafür finden sich hier. http://www.hongkiat.com/blog/virtual-instrument-web-browser/ Jeder bringt bitte ein eigenes Beispiel für ein solches Musikprogramm mit. Soweit so gut. Ich freu mich sehr auf die Woche. Liebe Grüße, Max

Workshop im Projekt „Zum Wetter …” Komplexes Gestalten / Entwurf, Studiengang Industriedesign, Industrial Design Burg Giebichenstein Kunsthochschule Halle, Sommersemester 2016 Workshop Max von Elverfeldt Teilnehmer_innen Tom Bade, Lara Bousch, Heinrich Ehnert, Shu Ting Fang, Ida Flik, Amelie Ikas, Wanhyun Ko, Alan Moreno, Clemens Schebiella, Benjamin Schief, Veronika Schneider, Konrad Schoch, Marcus Schwalm, Moritz Wussow Moderation Prof. Guido Englich, Fynn Freyschmidt

Arduino Weather Lab

Liebe Hacker, hier noch mal eine kurze Zusammenfassung der Aufgaben für Mittwoch: //INPUT SENSOREN Bitte setzt Euch jeder mit einem Sensor auseinander. Diejenigen, welche einen „neuen“ von mir mitgenommen haben, versuchen ihn zum Laufen zu bringen und demonstrieren das Ganze dann am Mittwoch. (Was kann der Sensor, wie funktioniert er in etwa und wofür könnte man ihn noch (miss)brauchen. Alle anderen überlegen sich, wie man das Phänomen Wetter u.ä. mit den bereits vertrauten Sensoren abgreifen könnte? Seid kreativ und bringt einen kleinen! Prototypen oder eine Skizze Eurer Idee mit.

Arduino Weather Lab

JUMP‘N‘RUN Jeder sucht sich bitte ein Spiel, welches mit Tastatur befehlen gesteuert werden kann und baut einen kleinen „Controller“ für dieses. Wichtig ist, dass die drei wesentlichen Funktionen „touchRead()“, „analogRead()“ und „digitalRead()“ darin vorkommen.

Capi

Experiment von Alan Moreno und Konrad Schoch

Arduino Weather Lab

Programmcode zu Capi --------------------------int InPin = A9; // int InPinState = 0; int ServoPin = 0; //Digitaler Pin fĂźr den Servo int val; // Variable, um mit den Werten aus dem Analogsensor arbeiten zu kĂśnnen void setup() { pinMode(InPin, INPUT); //Definieren des InPins als lesenden Pin. pinMode(ServoPin, OUTPUT); meinServo.attach(ServoPin); // Pin des Servos definieren Serial.begin(9600); } void loop() { InPinState = analogRead(InPin); val = map(InPinState, 0, 1023, 0, 180); Serial.println(InPinState); meinServo.write(val); delay(25); }

// Gibt dem Wervo etwas Zeit.

Capi Experiment von Alan Moreno und Konrad Schoch

Ausgangspunkt ist eine Cap. Die Idee ist einen zweiten „Schirm“ unter den „Hauptschirm“ zu installieren. Dieser soll automatisch auf Helligkeit reagieren: Ist es dunkel, bleibt der Schirm hochgeklappt. Bewegt man sich zur Sonne und oder helle Umgebungen, fährt der Schirm langsam nach unten und schützt die Augen.

Nach vielen weiteren Übungen geht es um das Planen und Umsetzen unseres eigenen „Apparates“. Ein Sensor soll zwischen einem Input (Wetter) und einem Output (Aktion) vermitteln. Alan und ich versuchen uns zu zweit mit der Thematik auseinander zu setzen. Nach intesiven Brainstormphasen und einigen schnellen Methoden kommen wir zu unserem Plan. Wir wollen einen Alltagsgegenstand, der den Menschen vor Wettereinflüssen schützt noch effektiver ausrüsten, also tunen.

Arduino Weather Lab

https://vimeo.com/166796888

Wir befestigen einen Helligkeitssensor auf der Aussenseite der Cap und platzieren die Steckplatine davor auf dem „Hauptschirm“. Dazu kommen Batterien, ein Servo und viele Kabel. Alan ist ein guter Partner, wir kommen schnell voran und kommen erfolgreich zu unserem Ergebnis - es ist ein funktionierender Prototyp - mission complete.

Virtuelles Wasser Experiment von Tom Bade und Marcus Schwalm

Arduino Weather Lab

Programmcode /* FANTASTOLOGISCHE WERKSTATT Stepper --------------------------*/ #include <Stepper.h> //Laden der Bibliothek int stepsPerRevolution = 300;// int TouchPin1 = A9; int TouchPin2 = A5; int TouchPin3 = A3; int TouchPin4 = A1;

Serial.print(Touchwert1); Serial.print(„\t“); Serial.print(Touchwert2); Serial.print(„\t“); Serial.print(Touchwert3); Serial.print(„\t“); Serial.println(Touchwert4); if(Touchwert1>4200){ Serial.println(„Schleife1“); delay(50); myStepper.step(-1700); delay(3000); myStepper.step(1700); delay(50); }

int Schritte = 0; int SchritteN = 0;

int Touchwert1 = 0; int Touchwert2 = 0; int Touchwert3 = 0; int Touchwert4 = 0;

if(Touchwert2>4200){ Serial.println(„Schleife2“); delay(50); myStepper.step(-600); delay(3000); myStepper.step(600); delay(50); }

Stepper myStepper(stepsPerRevolution, 0,1,2,3); void setup() { pinMode(TouchPin1, INPUT); //PinMode „Lesen“ pinMode(TouchPin2, INPUT); pinMode(TouchPin3, INPUT); //PinMode „Lesen“ pinMode(TouchPin4, INPUT);

Serial.begin(9600); myStepper.setSpeed(35);

} void loop() {

Touchwert1 = touchRead(TouchPin1); Touchwert2 = touchRead(TouchPin2); Touchwert3 = touchRead(TouchPin3); Touchwert4 = touchRead(TouchPin4);

if(Touchwert3>4200){ Serial.println(„Schleife3“); delay(50); myStepper.step(-220); delay(3000); myStepper.step(220); delay(50); } if(Touchwert4>4200){ Serial.println(„Schleife4“); delay(50); myStepper.step(-100); delay(3000); myStepper.step(100); delay(50); } }

Virtuelles Wasser Experiment von Markus Schwalm und Tom Bade Markus und Ich haben uns etwa einen halben Tag Zeit genommen, um ein geeignetes Konzept für den Workshop auszuarbeiten. Ziel war es, mit einer bestimmten Art von Sensor einen Stepper-Motor, anzusteuern. Wir wollten in einer Art Austellungsformat arbeiten um, einen noch nicht näher bestimmten Inhalt, zu kommunizieren. Im fertigen Modell wird über Touch-Schilder, eine Anzeige in Form eines Steigrohrs mit Skala, aktiviert. Das Modell zeigt anschaulich Unterschiede des Wasserverbrauchs, bei der Herstellung, ausgesuchter Lebensmittel.

VirtuellesWasser auch latentes Wasser genannt, ist diejenige Wassermenge, die insgesamt tatsächlich für die Herstellung eines Produkts anfällt. Jeder Deutsche verbraucht so etwa 4000Liter Wasser pro Tag. Der Einfluss der Industrie auf den natürlichen Wasserkreislauf ist ein spürbares Phänomen. Umso mehr eine Industrie lokale Wasserreserven ableitet und vebraucht, umso größer ist auch der Einfluss auf das lokale und auch das globale Klima. Durch bestimmte Anbaumethoden in der Landwirtschaft werden die negativen Einflüsse auf das Wetter besonders deutlich sichtbar.

Modell: verschiedene Lebensmittel, ihr Wasserverbrauch in je 1000 l/kg und ihre jeweils zugehörigen Spitzenexporteure.

Detail der Touch-Schilder (Verbesserung: austauschbare Schilder)

Arduino Weather Lab

Umsetzung Die Anzeige, in Form eines Steigrohres mit Schwimmer, funktioniert mithilfe einer kleinen Hydraulik. Der Bau der Hydraulik und die Ansteuerung des Motors, stellte eine der Herausforderungen des Versuchs dar. Nachdem Kauf einer 50ml Spritze, wurde diese so modifizeirt, dass der Motor diese ziehen oder drücken kann, jenachdem wie er angesteuert wird. Durch einen bipolaren Stepper-Motor kann die Steighöhe der Wassersäule präzise eingestellt werden. Dies wäre mit einem Gleich oder Wechselstrommotor nicht möglich.

Steppermotor mit adaptierter Spritze vom Tierarzt

Eine Arduino Installation zum Ber端hren

Arduino Weather Lab

Die Installation treibt eine Steppermotor an, welcher 端ber die Arduinoeinheit zu steuern ist. Verschiedene Touchsensoren lassen den Steppermotor unterschiedlich weit rotieren. Eine an den Steppermotor angeschlossene und mit Wasser gef端llte Spritze wird durch die Rotation des Steppermotors auf- beziehungsweise eingezogen.

Virtuelles Wasser – auch latentes Wasser genannt, ist diejenige Wassermenge, die insgesamt tatsächlich für die Herstellung eines Produktes anfällt. Jeder Deutsche verbraucht so etwa 4000Liter Wasser pro Tag. Der Einfluss der Industrie auf den natürlichen Wasserkreislauf ist ein spürbares Phänomen. Umso

mehr eine Industrie lokale Wasserreserven ableitet und verbraucht, umso größer ist auch der Einfluss auf das lokale und auch das globale Klima. Durch bestimmte Anbaumethoden in der Landwirtschaft werden negative Einflüsse auf das Wetter besonders deutlich sichtbar.

Arduino Weather Lab

Wearable Weather Veronika Schneider, Lara Bousch

Arduino Weather Lab

Programmcode #include <DHT.h> #include „DHT.h“ //Library wird hinzugef¸gt. #define DHTPIN 2 // Der Datenpin. #define DHTTYPE DHT11 // Name des Sensors DHT Sensor(DHTPIN, DHTTYPE); int Pin1 = 5; int Pin2 = 9; int Pin3 = 7; int Pin4 = 11; int Pin5 = 6; int Pin6 = 4; int Pin7 = 10; int Pin8 = 12; int Pin9 = 8; int Pin10 = 3; int zeitabstand = 15; //Abstand zw. den Messungen in Min. int startzeit = 0; int temperatur[96]; int temp_zeiger = 0; int PotiPin = A0; int PotiPinState = 0; void setup() { Serial.begin(9600); Sensor.begin(); pinMode(Pin1, OUTPUT); pinMode(Pin2, OUTPUT); pinMode(Pin3, OUTPUT); pinMode(Pin4, OUTPUT); pinMode(Pin5, OUTPUT); pinMode(Pin6, OUTPUT); pinMode(Pin7, OUTPUT); pinMode(Pin8, OUTPUT); pinMode(Pin9, OUTPUT); pinMode(Pin10, OUTPUT); pinMode(PotiPin, INPUT); zeitabstand = zeitabstand * 60 * 1000; startzeit = millis(); for (int i = 0; i <= 95; i++) { temperatur[i] = random(15, 25);} //ButtonPinState = digitalRead(ButtonPin);} void loop() { if ((millis() - startzeit) > zeitabstand) { float t = Sensor.readTemperature(); Serial.print(„Temperature: „); Serial.print(t); Serial.println(„ *C „); startzeit = millis(); temperatur[temp_zeiger] = t; Serial.println(temperatur[temp_zeiger]);

}

if (temp_zeiger < 95) { temp_zeiger++; } PotiPinState = analogRead(PotiPin);

while (PotiPinState > 512) { Serial.println(„Schreibvorgang startet“); for (int i = 0; i <= 95; i++) { PotiPinState = analogRead(PotiPin);//IF BEDINGUNG TASTE Serial.print(„Temp = „); Serial.print(temperatur[i]); if (temperatur[i] > -10 && temperatur[i] <= -5) { Serial.println(„ Schreiber 1“); schreiber(1); } if (temperatur[i] > -5 && temperatur[i] <= 0) { Serial.println(„ Schreiber 2“); schreiber(2);} if (temperatur[i] > 0 && temperatur[i] <= 5) { Serial.println(„ Schreiber 3“); schreiber(3); } if (temperatur[i] > 5 && temperatur[i] <= 10) { Serial.println(„ Schreiber 4“); schreiber(4);} if (temperatur[i] > 10 && temperatur[i] <= 15) { Serial.println(„ Schreiber 5“); schreiber(5);} if (temperatur[i] > 15 && temperatur[i] <= 20) { Serial.println(„ Schreiber 6“); schreiber(6);} if (temperatur[i] > 20 && temperatur[i] <= 25) { Serial.println(„ Schreiber 7“); schreiber(7);} if (temperatur[i] > 25 && temperatur[i] <= 30) { Serial.println(„ Schreiber 8“); schreiber(8);} if (temperatur[i] > 30 && temperatur[i] <= 35) { Serial.println(„ Schreiber 9“); schreiber(9); } if (temperatur[i] > 35) { Serial.println(„ Schreiber 10“); schreiber(10); }}}} void schreiber(int led_zahl) { if (led_zahl >= 1 ) { digitalWrite(Pin1, HIGH); } if (led_zahl >= 2 ) {digitalWrite(Pin2, HIGH); } if (led_zahl >= 3 ) {digitalWrite(Pin3, HIGH); } if (led_zahl >= 4 ) {digitalWrite(Pin4, HIGH); } if (led_zahl >= 5 ) {digitalWrite(Pin5, HIGH); } if (led_zahl >= 6 ) {digitalWrite(Pin6, HIGH);} if (led_zahl >= 7 ) {digitalWrite(Pin7, HIGH); } if (led_zahl >= 8 ) {digitalWrite(Pin8, HIGH);} if (led_zahl >= 9 ) { digitalWrite(Pin9, HIGH);} if (led_zahl >= 10 ) {digitalWrite(Pin10, HIGH); } delay(250); digitalWrite(Pin1, LOW); digitalWrite(Pin2, LOW); digitalWrite(Pin3, LOW); digitalWrite(Pin4, LOW); digitalWrite(Pin5, LOW); digitalWrite(Pin6, LOW); digitalWrite(Pin7, LOW); digitalWrite(Pin8, LOW); digitalWrite(Pin9, LOW); digitalWrite(Pin10, LOW); }

Wearable Weather Experiment von Lara Bousch und Veronika Schneider

Wearable Weather ist ein Prototyp einer tragbaren Wetterstation, der in einem Workshop zum Thema Arduino und Physical Computing entstanden ist.

Wearable Weather ist ein Prototyp einer tragbaren Wetterstation, der in einem Workshop zum Thema Arduino und Physical Computing entstanden ist. Angetan vom Thema Wetter und Gesundheit dachten Lara und ich, dass es interessant sei, eine Wetterstation bei sich zu tragen. Diese misst das Wetter dort wo man sich aufhält, Abends schlieﬂt man den tragbaren Teil an eine Dockingstation an, schaut sich die Daten an und kann sie mit seinem Befinden in Beziehung setzen, bzw. über einen längeren Zeitraum Muster erkennen. Unser Prototyp eines Wearables misst im Abstand von 15 Minuten die Temperatur, angeschlossen an die Docking station, wechselt er in den Ausgabemodus. Die Platte dreht sich in 24 Sekunden einmal herum und in dieser Zeit leuchten LEDs je nach Temperatur in den letzten 24 Stunden. Je wärmer es war, desto mehr LEDs leuchten und auf der fluoreszierenden Platte entsteht ein individuelles Muster.

Arduino Weather Lab

Wir haben zun채chst einen Sensor angeschlossen, der die Temperatur und die Luftfeuchtigkeit misst, uns dann aber, um den Code auf eine f체r uns 체berschaubare Komplexit채t zu reduzieren, nur mit der Temperatur befasst.

Wir nutzten „Arrays“, eine Liste, auf der 96 gesammelte Daten gespeichert sind (alle 15 Minuten über 24 Stunden). Um vom „Datensammelmodus“ in den „Lichtausgabe modus“ zu wechseln gibt es einen Drehschalter, den man betätigt sobald das tragbare Teil an die Station angeschlossen ist. Die LEDs zeigen in 5°C Schritten einen Temperaturbereich von -10°C bis + 35°C an – ein Bereich, der uns hierzulande realistisch erschien. Bei unseren Tests gab es allerdings nur leichte Schwankungen im Bereich um 20°C – es wäre zu überlegen, den Code so zu verändern, dass die LEDs eine feinere „Auflösung“ anzeigen. Das ist ebenso möglich, wie die Messabstände anzupassen um über einen kürzeren Zeitraum mehr, oder über einen längeren Zeitraum seltenere Messwerte zu sammeln. Die Speicherzahl ist auf 96 begrenzt.

Arduino Weather Lab

Translate the wind Experiment von ShuTing Fang, Wanhyun Ko

Arduino Weather Lab

Programmcode #include <Servo.h> Servo OneServo; int ServoPin = 0; int Led = 9; int val; int echoPin =23; int trigPin=22; long messung = 0; int ergebnis = 0; void setup() { Serial.begin(9600); pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(Led,OUTPUT); OneServo.attach(ServoPin); } void loop() { digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW);

int distance = pulseIn(echoPin, HIGH); distance= distance/58; Serial.println(distance); delay(50);

int windpower = map(distance, 0,30, 1, 4); int lichtpower = map(distance, 0,30, 255, 0); if (distance>=30){ OneServo.write(LOW); analogWrite(Led,0); } if (distance<30 && distance >0){ for (int i = 15; i < 170; i++){ OneServo.write(i); delay(windpower); analogWrite(Led,lichtpower); } for (int i = 170; i >15; i--){ OneServo.write(i); delay(windpower); analogWrite(Led,lichtpower); } } }

Translate the wind Experiment von ShuTing Fang, WanHyun Ko

Mit dieser Installation wird der ausgesperrte Wind wieder in den geschlossenen Raum gebracht. Mit Hilfe von Aduino wurde die Windstärke mit Hilfe eines Abstand-Sensors gemessen und in eine Mechanik übersetzt, die je nach Stärke intensiver oder schwächer wird. Durch diese Technik wird eine Fläche hin und her bewegt, wodurch die daran hängenden Fäden in einem fliessenden Rhythmus Wellen schlagen. Zusätzlich wird die Installation mit LED Licht in Szene gesetzt. Von oben nach unten ergibt das Licht einen Hell-Dunkel-Verlauf, der an den flüchtigen Moment einer Brise erinnert. Das Licht passt sich genau wie die Bewegung der Windstärke an. So entsteht eine organische Bewegung in einem statischen Konstrukt. So wie der Wind im vom Mensch konstruierten Raum. Auch wenn wir im windstillen, geometrischen Raum sitzen, kann „Translate the Wind“ uns das Gefühl vom Wind sichtbar machen. So wie der Wind die Baumkronen zum wanken und die Wolken zum wandern bringen kann. Ende der Chat-Unterhaltung http://7-themes.com/6895574-abstract-wind-wallpaper. html, 17.05.2016

Arduino Weather Lab

40째 im Schatten Experiment von Moritz Wussow

Arduino Weather Lab

Programmcode #include <DHT.h> #define DHTPIN 2 // Der Datenpin. #define DHTTYPE DHT11 // Name des Sensors DHT Sensor(DHTPIN, DHTTYPE); int fadePin = A9; int rpm = 0; float h; float t; boolean vLufter = false; void setup() { pinMode(fadePin, OUTPUT); Sensor.begin(); Serial.begin(9600); } void loop() { //Ein bisschen Warten vor jedem messen. delay(100); //Lesen der Luftfeuchtigkeit h = Sensor.readHumidity(); //Lesen der Temperatur t = Sensor.readTemperature(); Serial.print(„Humidity: „); Serial.print(h); Serial.print(„ %\t“); Serial.print(„Temperature: „); Serial.print(t); Serial.println(„ *C „); if(t >= 33){ vLufter = true; } if(t <= 30){ vLufter = false; } if (vLufter == true && rpm <= 255 ) { rpm += 1; } if (vLufter == false && rpm >= 0 ) { rpm -= 3; } analogWrite(fadePin, rpm) ; }

40° im Schatten Experiment von Moritz Wussow

In der Installation soll aufgezeigt werden welche Power die Sonne besitzt. Durch einen Sensor wird unter der Folie die Temperatur gemessen ab einem festgelegten Wert startet der Lüfter. Der Lüfter kühler das Innere der Folie runter und pustet dabei den Körper auf. Ab einem bestimmtem Wert schaltet er sich ab und die Folie fällt wieder zusammen. Das Schauspiel kann von vorne los gehen.

Arduino Weather Lab

Wetterhoroskop Experiment von Heinrich Ehnert & Ida Flik

Arduino Weather Lab

Programmcode #include „DHT.h“ //Luftsensor Library wird hinzugefügt. #define DHTPIN A1 // Datenpin Luftsensor. #define DHTTYPE DHT11 // Name des Sensors DHT Sensor(DHTPIN, DHTTYPE); #include <Servo.h> //Laden der Bibliothek „Servo“ Servo Servo1a; Servo Servo1b; Servo Servo2a; Servo Servo2b; Servo Servo3a; Servo Servo3b; int Sternzeichen = A9; //Pin Nummer des AnalogPins int ServoPin1a = 0; int ServoPin1b = 1; int ServoPin2a = 2; int ServoPin2b = 3; int ServoPin3a = 4; int ServoPin3b = 5; int lichtPin = A0; int val; int SZNR; int SZNR1; int Winkel1a; int Winkel2a; int Winkel3a; int Winkel1b; int lichtWert; //messwert helligkeit int lichtNR; float feucht; //messwert feuchtigkeit int feuchtNR; float temp; //messwert temperatur int tempNR; int zeit; int abstand; void setup(){ Servo1a.attach(ServoPin1a); Servo1b.attach(ServoPin1b); Servo2a.attach(ServoPin2a); Servo2b.attach(ServoPin2b); Servo3a.attach(ServoPin3a); Servo3b.attach(ServoPin3b); pinMode(lichtPin,INPUT); pinMode(Sternzeichen, INPUT); //Definieren des InPins als lepressen Pin. Serial.begin(9600); Sensor.begin(); // Luftsensor zeit = millis(); abstand = 1*20*1000; } void loop(){ // Serial.println(val); Serial.println(temp); Serial.println(Winkel2a); Serial.println(SZNR); //Sternzeichengenerale!

val = analogRead(Sternzeichen); SZNR = map(val, 20, 1000, 1, 12); //SZNR Sternzeichennummer if (SZNR <= 6){ SZNR1=SZNR; } else { SZNR1 = SZNR-6;} Winkel1b = map(SZNR1,1,6,45,135); Servo1b.write(Winkel1b); Servo2b.write(Winkel1b); Servo3b.write(Winkel1b); if ((millis()-zeit)> abstand){ //Lichtsensor lichtWert = analogRead(lichtPin); if (lichtWert <=25){ Winkel1a = 45; } if (lichtWert >25 && lichtWert <=80){ Winkel1a = 90; } if (lichtWert > 90){ Winkel1a = 135; } Servo1a.write(Winkel1a); //Serial.println(„lichtWert“); //Serial.print(lichtWert); //Serial.print („, „); //Serial.print(Winkel1a); //Serial.println (); //Temperatur temp = Sensor.readTemperature(); //temp = constrain(temp, 14, 35); if (temp <= 25){ Winkel2a = 45; } if (temp >25 && temp <=30){ Winkel2a = 90; } if (temp > 30){ Winkel2a = 135; } Servo2a.write(Winkel2a); //Feuchtigkeit feucht = Sensor.readHumidity(); if (feucht <= 40){ Winkel3a = 45; } if (feucht >40 && feucht <=50){ Winkel3a = 90; } if (feucht > 50){ Winkel3a = 135; } Servo3a.write(Winkel3a); zeit = millis(); } delay(200); }

Wetterhoroskop Experiment von Heinrich Ehnert & Ida Flik

Das Wetterhoroskop ist ein pseudo-wissenschaftliches Ger채t, das aus aktuellen Wettermesswerten und dem jeweiligen Sternzeichen das Horoskop errechnet. Dabei bestimmen die Messwerte die faktischen Zust채nde, das Sternzeichen die individuellen Auswirkungen des Zustandes.

Blick unter die Kulissen

Arduino Weather Lab

Ideenskizze

Prozess

Schablone f端r die Anzeigen

Arduino Weather Lab

Sobald sich Messwerte ändern, werden die Anzeigen geräuschvoll umgestellt. Es entsteht der Eindruck, als wäre ein lebendiges Wesen im Raum. Gemessen werden Temperatur, Luftfeuchtigkeit und Lichtinten sität. Das entsprechende Stern zeichen wird vom Benutzer selbst am Drehregler auf dem Gerät eingestellt.

Wintilator Clemens Schebiella & AmĂŠlie Ikas

Arduino Weather Lab

Programmcode

if (distance >= 6 && distance <= 7) {

#include <Servo.h>

delay(10); OneServo.write((90 / 8) * 1); delay(10); } if (distance >= 8 && distance <= 10) { delay(10); OneServo.write((90 / 8) * 2); delay(10); } if (distance >= 11 && distance <= 12) { delay(10); OneServo.write((90 / 8) * 3); delay(10); } if (distance >= 13 && distance <= 15) { delay(10); OneServo.write((90 / 8) * 4); delay(10); } if (distance >= 16 && distance <= 17) { delay(10); OneServo.write((90 / 8) * 5); delay(10); } if (distance >= 18 && distance <= 19) { delay(10); OneServo.write((90 / 8) * 6); delay(10); } if (distance >= 20 && distance <= 3000) { delay(10); OneServo.write((90 / 8) * 7); delay(10); } }

Servo OneServo; int fadePin = A9; int ServoPin = 1; int echoPin = 21; int trigPin = 22; long messung = 0; int ergebnis = 0; void setup() { Serial.begin(9600); pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); //L端fter pinMode(fadePin, OUTPUT); OneServo.attach(ServoPin); } void loop() { analogWrite(fadePin, 255); digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); int distance = pulseIn(echoPin, HIGH); distance = distance / 58; Serial.println(distance); delay(10); int minimum = 3; int maximum = 4000; int differenz = (maximum - minimum) / 8; if (distance >= 3 && distance <= 5) { delay(10); OneServo.write((90 / 8)*0); delay(10); }

Wintilator Clemens Schebiella & Amélie Ikas

Der Wintilator ist eine visuelle Dar stellung und Übertragung der äußeren Windrichtung in den Innenraum.

Wind ist nicht sichtbar. Wir spüren ihn, aber können ihm keine Form zuordnen. Er kann sich jederzeit verwandeln und unbestimmbar werden. Stellt man ein Fähnchen in den Wind, kann man zumindest seine Richtung bestimmen. Uns waren aber Pfeil, Anzeige, Zahl oder Buchstabe zu wenig, um dem Wind eine würdige Darstellung zu geben.

Arduino Weather Lab

Mit unserem Wintilator, wollten wir ein Stück Wetter, vor dem wir uns sonst immer abschirmen, nach Innen bringen. So zweckentfremdeten wir einen Ventilator der nun unseren Wind im Innenraum simulierte. Dieser sollte zudem noch die Windrichtung anzeigen aus der auch der Wind im Außenbereich wehte. Allerdings reichte es uns nicht einfach nur einen Ventilator zu haben, der sich in die Richtung dreht aus der der Wind kommt. Daher schauten wir, wo der Wind sichtbare Spuren hinterlässt, und blieben bei Gräsern und Ähren auf dem Feld hängen. Diese wehen in die Richtung, in die sie der Wind sanft drückt. Doch war es schwierig diesen Effekt nach zu empfinden, nicht nur weil wir uns in der Jahreszeit vertan hatten und gar keine Gräser wuchsen. Wir entschieden uns für aufblätternde Papierstreifen, die aufflattern, sobald der Ventilator sich in ihre Richtung dreht, und wieder zurück fallen, wenn dieser weiter dreht. Der Wind wird plötzlich räumlich und man entwickelt ein Interesse dafür, wohin er wohl als nächstes wehen wird.

Wintilator Clemens Schebiella & Amélie Ikas

Unser Modell ist in zwei Bestandteile aufgeteilt. Einmal in den des Außen bereichs, das Fähnchen und den Sensor. Und in den Innenbereich, dem Ventilator und der Visualisierung.

Das Fähnchen, welches sich nach dem Winde dreht, gibt mit seiner, weiter unten angebrachten, schneckenförmigen Apparatur dem Sensor die Himmelsrichtung an, welcher diese dann, über den teensy an den Servomotor und Ventilator im Innenraum übermittelt.

Arduino Weather Lab

Der Sensor ist ein Abstandsmesser, was die Schnecke erklärt, denn diese ist nötig damit jede Himmelsrichtung mit einem individuellen Abstand definiert ist, und es keine Himmelsrichtung doppelt gibt. Die Schnecke ist in Arduino in 8 Stellungen unterteilt. So kommt der Wind, z.B bei einem Abstand der Schnecke von 3–5cm zum Sensor, aus Norden.

Bei der Visualisierung, ist in der Mitte der Scheibe ein Ventilator angebracht, der durch einen Servomotor und eine Übersetzung von Zahnrädern angesteuert wird. Der Ventilator bläst stetig in die Himmelsrichtung, aus der der Wind im Außenbereich kommt.

Impressum

Arduino Weather Lab Fantastologisches Labor Workshop

Max von Elverfeldt Komplexes Gestalten / Entwurf Studiengang Industriedesign / Industrial Design an der Burg Giebichenstein Kunsthochschule Halle Layout

Projektteilnehmer Texte, Fotos, Grafiken

Projektteilnehmer Projektbetreuung

Prof. Guido Englich Dipl. Des. Fynn Freyschmidt Studierende

Tom Bade, Lara Bousch, Heinrich Ehnert, Shu Ting Fang, Ida Flik, Amelie Ikas, Wanhyun Ko, Alan Moreno, Clemens Schebiella, Veronika Schneider, Konrad Schoch, Marcus Schwalm, Moritz Wussow Herausgeber

ID-Neuwerk / Design Education Research Burg Giebichenstein Kunsthochschule Halle Neuwerk 7, D-06108 Halle (Saale), Prof. Guido Englich, 2016

ID-Neuwerk Design Education Research Burg Giebichenstein Kunsthochschule Halle