Interaktionstoolkit How To

Interaktionstoolkit How To Raspberry Pi 3 Um einen Raspberry Pi zum ersten Mal zu starten, müssen einige Schritte durchführt werden. Diese werden im Folgenden näher erläutert: Zuerst muss ein Betriebssystem auf die SD Karte gespielt werden. Hierfür wird eine mindestens 2GB, besser 4GB und größere SD Karte benötigt. Diese muss zunächst an den PC angeschlossen und formatiert werden (z.b. mit SDFormatter). Anschließend wird das Image des gewünschten Betriebssystems übertragen, (Hier eine Auswahl an Betriebssystemen für den Raspberry Pi). Hierfür wird der Win32DiskImager gestartet, das zuvor heruntergeladene Image des Betriebssystems und das passende Laufwerk ausgewählt. Wenn der Schreibvorgang fertig ist, kann die SD aus dem PC entfernt und im Raspberry Pi einsetzt werden. Wird der Raspberry Pi an eine Stromquelle angeschlossen (beispielsweise mit einen microusb Kabel über ein Netzteil), sollten die LEDs blinken und der Pi starten. Sobald der Pi mit einem Bildschirm verbunden ist, kann mit ihm wie mit einem ganz normalen PC gearbeitet werden. Quelle: http://tutorials- raspberrypi.de/raspberry- pi- einstieg- wie- starte- ich/ Arduino- Boards Zum Starten eines ArduinoBoard muss zunächst die neuste Arduino Software (IDE) installiert werden, hierbei sollte man auch den Treibern die Installation erlauben. Anschließend muss das Board mit einem PC verbunden werden. Dadurch wird das Board auch mit Strom versorgt und eine grüne Power- LED leuchtet. Nun startet man die Arduino- Software über die, von der Installation erzeugten, exe. Danach kann als Beispiel das blink - Beispiel über File - > Examples - > 01.Basics - > Blink geöffnet werden. Hiernach muss nur noch das eigene Board über Tools - > Board ausgewählt werden und über Tools - > Serial Port den Port, über den das Board angeschlossen ist, angeben (meist COM3 oder höher). Falls man den Port nicht kennt, kann das Arduino- Board disconnectet werden und anschließend wieder verbunden werden. Dabei verschwindet und erscheint ein Eintrag in der Liste. Dies sollte der richtige Port sein. Zuletzt klickt man nur noch auf Upload und wartet kurz. Dabei sollten die RX und TX LEDs blinken. Wenn der Upload abgeschlossen ist, erscheint die Meldung Done uploading und kurz darauf blinkt die pin13(l)led in orange. Dies ist die Installation unter Windows, diese und ein Guide für die Installation unter Max OS X und Linux finden Sie unter https://www.arduino.cc/en/guide/homepage Quelle: https://www.arduino.cc/en/guide/windows

Arduino Pro Mini Der Arduino Mini lässt sich, durch seine Anschlüsse, nur über eine andere Einheit, z.b. den Arduino Mega programmieren. Ein kurzes Video wie ein Arduino Pro Mini an ein anderes ArduinoBoard angeschlossen programmiert werden kann: https://www.youtube.com/watch?v=qbsqpxaenw4 LilyPad Um das LilyPad zu programmieren wird zusätzlich ein USB Kabel und ein FTDI- Board benötigt. Wie beim Arduino- Board wird nun die Arduino Software heruntergeladen. Hier wird nun das zip file extrahiert und anschließend arduino 1.0.x ausgeführt. Abschließend wird das FTDI- Board mit dem LilyPad wie folgt verbunden: Abbildung 1: Arduino LilyPad Und das USB- Ende mit dem PC verbunden. Anschließend installiert man die Treiber des FTDI, nach dem Download extrahiert man wieder die.zip Datei und folgt dem Guide dieser Website. Hat man dies geschafft startet man seinen PC neu. Wie beim ArduinoBoard folgt nun der Rest: Zuerst wird die arduino.exe ausgeführt. Dann über File - > Examples - > 1.Basics - > Blink das

Blink- Beispiel ausgewählt und über Tools - > Board sein Board ausgewählt (für LilyPads die aktueller sind als 2011 LilyPad Arduino w/ ATmega328 ). Wie auch zuvor wird nun unter Tools - > Serial Port der angeschlossenen Port ausgewählt. Der letzte Schritt ist auch hier der Upload des Programms, indem auf den Upload Button gedrückt wird. Quelle: https://www.arduino.cc/en/guide/lilypadwindows LilyPad LEDs Dies sind einfache LEDs für das LilyPad. Sie lassen sich also einfach und simpel mit diesem ansteuern. Abbildung 2: LilyPad LEDs Quelle: http://www.exp- tech.de/lilypad- led- gruen- 5pcs Beispiel Hier ein kurzes Beispiel wie das LilyPad mit mehreren LEDs benutzt werden kann. Voraussetzung hierfür ist die oben beschriebene Installation und Nutzung des FTDI und der Arduino- Software. Nun betrachten wir das LilyPad: Es hat 13 Anschlüsse um andere Geräte mit ihm zu verbinden (1-13). Anschließend wird z.b. die Pin 5 mit dem positiven Ende einer LED verbunden. Dann von Pin 6 zu einem positiven Ende einer anderen LED usw., je nachdem wie viele LEDs benötigt werden. Daraufhin wird die negative Polung (- ) des LilyPads mit der negativen Polung der ersten LED verbunden. Die negative Polung der ersten LED wird mit der negativen Polung der zweiten LED verbunden, bis man bei der letzten angekommen ist.somit wird eine Parallelschaltung erzeugt. Zuletzt muss das LilyPad nur noch mit dem FTDI verbunden werden und dieses am Computer angeschlossen werden. Danach kommt der Programmier- Part: Es wird die Software von Arduino geöffnet, das passende Board (LilyPad Arduino w/ ATmega328) gewählt und der richtigen Port ausgewählt. Folgender Code führt zum Erfolg:

//Ordnet jede LED ihrem Steckplatz zu #define LED1 5 #define LED2 6 #define LED3 9 #define LED4 10 #define LED5 11 #define LED6 16 #define LED7 17 #define LED8 18 #define LED9 19 //Intervalle in denen die LEDs leuchten #define interval 11000 #define dead_time 1000 //Initialisierung der benötigten Variablen unsigned long PWM_counter = 0; int offset = 0; int step_size = 200; unsigned long on_time = 0; unsigned long cycle_start = 0; char dir = 1; int offset2 = 0; int step_size2 = 200; unsigned long on_time2 = 0; unsigned long cycle_start2 = 0; char dir2 = 1; byte LED_tracker1 = 1; byte LED_tracker2 = 1; //Definiert die PINs als Output void setup() { Serial.begin(57600); pinmode(led1, OUTPUT); pinmode(led2, OUTPUT); pinmode(led3, OUTPUT); pinmode(led4, OUTPUT); pinmode(led5, OUTPUT); pinmode(led6, OUTPUT); pinmode(led7, OUTPUT); pinmode(led8, OUTPUT); pinmode(led9, OUTPUT); offset = random(2500,7500); offset2 = random(2500,7500); Zuletzt den Code kompilieren und hochladen. Quelle: https://www.sparkfun.com/tutorials/312

LilyPad Licht Sensor Dies ist ein einfacher Lichtsensor. Dieser gibt zwischen 0 und 5V weiter, je nach Lichtverhältnissen. D. h. Bei Tageslicht wird er 5V weitergeben, bei vollkommener Dunkelheit (wenn er z.b. mit der Hand abgedeckt wird) 0V und bei normalen Lichtverhältnissen in einem Gebäude ca. 1-2V. Abbildung 3: LilyPad Lichtsensor Quelle: http://www.exp- tech.de/lilypad- light- sensor- dev- 08464? SID=U Beispiel Angeschlossen wird der Sensor indem die negative Polung an die negative Polung des LilyPads anschlossen wird. Nun noch die positive Polung des Sensors an A0 vom LilyPad und S an A5 stecken. Um den Test zu vereinfachen, verbinden wir zusätzlich eine LED mit dem LilyPad (negative Polung an negative Polung und die positive Polung der LED an Pin 13 vom LilyPad) Jetzt nur noch folgenden Code in die Software von Arduino kopieren:

/* * LilyPad tutorial: sensing (sensors) * * Liest Daten aus dem LilyPad Lichtsensor * und sendet diese anschließend an den PC * sodass man sie lesen kann */ int ledpin = 13; // LED ist mit digitalpin 13 verbunden int sensorpin = 0; // Lichtsensor ist mit analogpin 0 verbunden int sensorvalue; // Variable um die Werte des Sensors zu speichern void setup() { pinmode(ledpin, OUTPUT); // Setzt die LEDPin als Output Serial.begin(9600); //Initialisiert den SerialPort digitalwrite(ledpin, HIGH); // Schaltet die LED ein void loop() { Sensors Computer sensorvalue = analogread(sensorpin); // Liest den Wert des Serial.println(sensorValue); // Sendet diesen Wert an den delay(100); // Verzögerung von 0,1 Sekunden Wird die LED an den Lichtsensor herangeführt, sollten sich die ausgegebenen Werte ändern. (Ansicht in der Software von Arduino rechts oben auf der Lupe) Quelle: http://web.media.mit.edu/~leah/lilypad/08_sensor_code.html

LilyPad Beschleunigungssensor Dies ist ein dreiachsiger Beschleunigungssensor für das LilyPad. Basierend auf dem ADXL335 MEMS von Analog Devices kann der Sensor Bewegungen, Neigungen und Vibrationen erkennen. Dabei hat das Modul einen Output zwischen 0 und 3V an jeder der X, Y und Z Achsen. Dieser Output muss erst noch umgerechnet werden, damit man den wirklichen Winkel bekommt. Abbildung 4: LilyPad Beschleunigungssensor Quelle: http://www.exp- tech.de/lilypad- adxl335- beschleunigungssensor Beispiel Zuerst muss der Beschleunigungssensor mit dem LilyPad verbunden werden. Hierfür wird die negative Polung des Sensors mit Pin A4 des LilyPads, die positive Polung mit Pin A5, Z mit Pin A1, Y mit Pin A2 und X mit Pin A3 verbunden. Ist das LilyPad erfolgreich mit dem Computer verbunden, muss der folgenden Code hochgeladen werden:

/* ADXL3xx Liest die Ausgaben des LilyPad Beschleunigungssensors und sendet diese an den PC. Die Verbindungen: analog 0: accelerometer self test analog 1: z-axis analog 2: y-axis analog 3: x-axis analog 4: ground analog 5: vcc */ // ordnet die oben genannten Anschlüsse zu const int groundpin = 18; // analog input pin 4 -- ground const int powerpin = 19; // analog input pin 5 -- voltage const int xpin = A3; // x-axis des sensors const int ypin = A2; // y-axis const int zpin = A1; // z-axis void setup() { // Initialisiere die serielle Kommunikation Serial.begin(9600); void loop() { // Gibt die Werte des Sensors aus Serial.print(analogRead(xpin)); Serial.print("\t"); Serial.print(analogRead(ypin)); Serial.print("\t"); Serial.print(analogRead(zpin)); Serial.println(); // Verzögerung zum nächsten Durchlauf delay(100); Quelle: https://www.arduino.cc/en/tutorial/adxl3xx

LilyPad Lautsprecher Der LilyPad Buzzer ist ein kleiner Lautsprecher, man kann ihn einfach an zwei I/O Ports des Liypads hängen. Um verschiedene Töne zu erzeugen muss man nur die Pins tooglen. Da der Buzzer eine Induktive Last ist, wird empfohlen beide I/O Pins auf Low zu legen, wenn der Buzzer nicht genutzt wird. Abbildung 5: LilyPad Lautsprecher Quelle: http://www.watterott.com/de/lilypad- Lautsprecher Beispiel Das Anschließen des Lautsprechers ist vergleichsweise einfach: Die negative Polung wird an die negative Polung vom LilyPad angeschlossen, die positive Polung an ein beliebigen Pin, in diesem Beispiel an Pin 5. Nun wird folgenden Code in die Entwicklungsumgebung des Arduino kopiert und diese hochgeladen:

// Verbindung vom Lautsprecher zum Pin int buzzerpin = 5; // Verzögerung in Millisekunden int delaytime = 500; //Noten und ihre Frequenz const int C = 1046; const int D = 1175; const int E = 1319; const int F = 1397; const int G = 1568; const int A = 1760; const int B = 1976; const int C1 = 2093; const int D1 = 2349; void setup() { // Setzt den LautsprecherPin als Output pinmode(buzzerpin, OUTPUT); void loop() { // Nutzt die tone() Funktion, um die einzelnen Noten zu spielen tone(buzzerpin, C); delay(delaytime); tone(buzzerpin, D); delay(delaytime); tone(buzzerpin, E); delay(delaytime); tone(buzzerpin, F); delay(delaytime); tone(buzzerpin, G); delay(delaytime);

Quelle: https://learn.sparkfun.com/tutorials/lilypad- buzzer- hookup- guide Neopixel Um die Neopixel zu steuern, gibt es extra eine von Arduino bereitgestellte Bibliothek. Der erste Schritt ist also der Download und die Installation der Bibliothek. Mit neueren Versionen der Arduino IDE (1.6.2 oder neuer) sind Installationen von Bibliotheken nicht schwer: Über das Library Manager Interface geht man vom Sketch Menü über Include Library - > Manage Libraries. Anschließend wird NeoPixel in die FilterBox eingegeben und installiert von hier aus die Adafruit Library. Bei älteren Versionen der IDE kann nach dem Link gefolgt werden und die zip- Datei entpackt werden. Danach sollte der Ordner mit den.cpp und.h files zu Adafruit_Neopixel um genannt und dieser in /Documents/Arduino/Libraries platziert wer- den. Ein erstes einfaches Programm läuft ähnlich wie bei den ArduinoBoards: Unter File - > Sketchbook - > Libraries - > Adafruit_NeoPixel - > strandtest kann das Programm gestartet werden. Anschließend wird das Board unter dem Tools Menü und uploaded es zum Board. Wenn alles richtig funktioniert sollte eine kleine Lichtshow erscheinen. Quelle: https://learn.adafruit.com/adafruit- neopixel- uberguide/arduino- library- installation Abbildung 6: Neopixel LED Strip Quelle: http://www.exp- tech.de/adafruit- neopixel- led- strip- starter- pack- white Beispiel Zuerst werden wie folgt die LEDs angeschlossen: GND der LEDs (schwarz) an GND des Arduino MEGA, 5V (rot) an 5V und Din (weiß) an einen freien Pin, in diesem Beispiel Pin 52. Anschließend wird der Beispielcode in die Entwicklungs- umgebung von Arduino kopiert. In diesem Fall muss noch die verwendete Bibliothek heruntergeladen werden. Dies kann un- ter Sketch - > Bibliothek einbinden - > Bibliotheken verwalten - > Suchwort Neopixel gefun- den und herunterladen werden. Zuletzt den Code kompilieren und hochladen. Quelle: http://www.mathias- wilhelm.de/arduino/beginner/schritt- 5- jetzt- wird- es- bunt/

//Extra integrierte Bibliothek wird eingebunden #include <Adafruit_NeoPixel.h> //PIN 52 wird genutzt #define PIN 52 //Anzahl der genutzten LEDs #define NUM_LEDS (60 * 4) //Neopixel wird initialisiert Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB NEO_KHZ800); int k = 0; int d = 1; void setup() { //Beginn der seriellen Kommunikation Serial.begin(9600); strip.begin(); //Alle LEDs beginnen mit off strip.show(); void loop() { //Wenn der Strip durchlaufen wurde, geht es vom Ende noch einmal zum Start if(k==num_leds){ d = -1; if(k==0){ d=1; k+=d; clearstrip(); //Lässt einzelne LEDs aufleuchten strip.setpixelcolor(k, strip.color(2, 200, 50)); strip.show(); //Schaltet alle LEDs aus void clearstrip(){ Quelle: http://code.toily.mx/arduino- mega- 2560- neopixel- strip- 4m/