Proiector Mood (Philips Hue Light cu GSR piratat) TfCD: 7 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:46

De Laura Ahsmann și Maaike Weber

Scop: Stările de spirit scăzute și stresul sunt o parte importantă a vieții moderne cu ritm rapid. Este, de asemenea, ceva invizibil pentru exterior. Ce se întâmplă dacă am fi în măsură să proiectăm atât vizual cât și acustic nivelul nostru de stres cu un produs, pentru a putea arăta cum te simți. Ar facilita comunicarea despre aceste probleme. Propria dvs. reacție ar putea fi, de asemenea, mai adecvată momentului în care primiți feedback cu privire la nivelurile de stres.

GSR sau rezistența galvanică a pielii, o măsurătoare luată la îndemâna utilizatorului, se dovedește a fi un predictor foarte bun al stresului. Întrucât țâțâile de sudoare din mână reacționează în mare parte la stres (nu numai exercițiul fizic), nivelurile crescute de stres generează o conductanță mai mare. Această variabilă este utilizată în acest proiect.

Ideea: Ce se întâmplă dacă am putea detecta rapid stresul sau starea de spirit și să-l reprezentăm cu lumină colorată și muzică? Un sistem GSR ar putea face ca acest lucru să se întâmple. În acest Instructable, vom crea un sistem bazat pe Arduino pentru a face acest lucru! Operat atât de software Arduino, cât și de software de procesare, acesta va traduce valorile conductanței pielii într-o anumită lumină de culoare și într-un anumit tip de muzică.

De ce ai nevoie?

• Arduino Uno
• Fire
• Lumina Philips Hue (culori vii)
• Trei rezistențe de 100 Ohm (pentru LED-ul RGB)
• Un rezistor de 100 KOhm (pentru senzorul GSR)
• Ceva care să acționeze ca senzori de conductanță, cum ar fi folia de aluminiu
• Software Arduino
• Software de procesare (am folosit v2.2.1, cele mai noi tind să se blocheze)
• SolidWorks, pentru proiectarea carcasei (opțional)
• Acces la o moară CNC (opțional)
• Spumă de modelare verde (EPS)
• Breadboard (opțional, s-ar putea și lipi)

Pasul 1: Eliminați lumina Hue

Acest pas este ușor, doar folosiți o forță (sau o șurubelniță), lăsați să piardă și să deschidă lumina. Unele conexiuni snap țin produsul laolalt, deci este ușor de demontat.

Acum, lumina din partea de sus poate fi înșurubată și deconectată de la restul componentelor electronice. Vom avea nevoie doar de lumină și de partea superioară a carcasei. Salvează sau aruncă restul, depinde de tine!

Pasul 2: Pregătirea hardware-ului

Pentru acest proiect, am folosit o lampă Philips Hue, pentru a face ca întruparea să fie mai frumoasă și mai rapidă. Cu toate acestea, puteți utiliza și un LED RGB obișnuit, așa cum se arată în imagine cu panoul de verificare.

Pentru a utiliza LED-ul RGB, conectați pinii la trei porturi PWM diferite ale Arduino (indicat ba a ~). Folosiți rezistențele de 100 Ohm pentru această conexiune. Conectați cel mai lung pin la ieșirea de 5V a Arduino. Pentru a vedea care pin corespunde cărei culori, consultați ultima imagine a acestui pas.

Pentru Lumina Hue, aceiași pași merg. LED-ul este ușor conectat la Arduino prin lipirea firelor la sloturile desemnate, a se vedea a treia imagine din acest pas. Sloturile au un R, un G și un B, indicând ce fir trebuie să meargă unde. Are, de asemenea, un slot + și un - pentru a fi conectat la 5V al Arduino și, respectiv, la solul Arduino. După ce ați conectat LED-ul, puteți înșuruba înapoi în carcasă.

Pentru a conecta senzorii GSR, realizați din folie de aluminiu (sau utilizați acele recipiente de aluminiu cu lumini de lumină, care arată puțin mai frumos), lipiți-le sau lipiți-le de un fir și conectați unul la 5V. Conectați-l pe celălalt la rezistorul de 100KOhm și un condensator de 0, 1mF (paralel), care ar trebui apoi conectat la pământ și la slotul A1 de pe Arduino. Acest lucru va da ieșirea nivelului de stres, care va fi apoi folosit ca intrare pentru culoarea luminii și muzică. Am lipit senzorii de lampă, astfel încât devine un produs frumos de luat în timp ce vă măsurați stresul. Aveți grijă totuși ca senzorii să nu se atingă!

Ultima imagine arată cum se poate face fără o placă de calcul.

Pasul 3: Măsurarea nivelului de stres

Măsurarea nivelului de stres doar cu acești senzori de casă nu va oferi cu siguranță măsurători precise cu privire la cât de stresat ești exact. Cu toate acestea, atunci când este calibrat corect, poate oferi o aproximare.

Pentru a măsura nivelurile GSR, vom folosi următoarea bucată de cod, în mediul Arduino. Pentru a avea o măsurare mai puțin fluctuantă, se ia o medie la fiecare 10 citiri.

const int numCitiri = 10; citiri int [numCitiri]; // intrare din A1 int index = 0; // indicele citirii curente int total = 0; // media lungă totală nesemnificată lungă = 0; // media

int inputPin = A1;

void setupGSR ()

{// setați toate citirile la 0:

pentru (int i = 0; i <numReadings; i ++) lecturi = 0; }

nesemnat pe termen lungGSR () {

total = total - citiri [index]; // citit din citirile senzorului GSR [index] = analogRead (inputPin); // adăugați lectură nouă la total total = total + citiri [index]; // următoarea poziție a indexului matricei = index + 1;

// testează sfârșitul matricei

if (index> = numReadings) // și începe din nou index = 0;

// ce este media

medie = total / numCitiri; // trimiteți-l la computer, deoarece cifrele ASCII returnează media;

}

Într-o altă filă (pentru a menține lucrurile organizate), vom face codul pentru a reacționa la măsurători, a se vedea pasul următor!

Pasul 4: Gestionarea luminilor

Pentru a gestiona luminile, trebuie mai întâi să calibrăm măsurătorile. Verificați care este limita superioară pentru măsurătorile dvs. deschizând monitorul serial. Pentru noi măsurătorile au fost ceva între 150 (când am încercat cu adevărat să ne relaxăm) și 300 (când am încercat din greu să devenim stresați).

Apoi, decideți ce culoare ar trebui să reprezinte ce nivel de stres. Am făcut-o astfel încât:

1. Nivel de stres scăzut: lumină albă, care se transformă în lumină verde odată cu creșterea stresului

2. Nivel mediu de stres: lumină verde, care se transformă în lumină albastră odată cu creșterea stresului

3. Nivel ridicat de stres: lumină albastră, care se schimbă în roșu odată cu creșterea stresului

Următorul cod a fost utilizat pentru a procesa măsurătorile și a le transforma în valori pe care să le trimiteți la LED:

// MASTER #define DEBUG 0

// GSR = A1

int gsrVal = 0; // Variabil pentru stocarea intrării de la senzori

// După cum sa menționat, utilizați pinii de modulare a lățimii pulsului (PWM)

int redPin = 9; // LED roșu, conectat la pinul digital 9 int grnPin = 9; // LED verde, conectat la pinul digital 10 int bluPin = 5; // LED albastru, conectat la pinul digital 11

// Variabile de program

int redVal = 0; // Variabile pentru a stoca valorile de trimis pinilor int grnVal = 0; int bluVal = 0;

gsr lung nesemnat = 0;

configurare nulă ()

{pinMode (bluPin, OUTPUT); pinMode (grnPin, OUTPUT); pinMode (redPin, OUTPUT); pinMode (A1, INPUT);

Serial.begin (9600);

setupGSR (); }

bucla nulă ()

{gsrVal = gsr; if (gsrVal <150) // Cea mai mică treime din gama gsr (0-149) {gsr = (gsrVal / 10) * 17; // Normalizează la 0-255 redVal = gsrVal; // off la plin grnVal = gsrVal; // Verde de la off la bluVal complet = gsrVal; // Albastru pe deplinString SoundA = "A"; Serial.println (SoundA); // pentru utilizare ulterioară în operarea muzicii} else if (gsrVal <250) // Treimea mijlocie a intervalului gsr (150-249) {gsrVal = ((gsrVal-250) / 10) * 17; // Normalizează la 0-255 roșuVal = 1; // Red off grnVal = gsrVal; // Verde de la complet la oprit bluVal = 256 - gsrVal; // Albastru de la oprit la șir complet de sunet B = "B"; Serial.println (SoundB); } else // Treimea superioară a intervalului gsr (250-300) {gsrVal = ((gsrVal-301) / 10) * 17; // Normalizează la 0-255 redVal = gsrVal; // Roșu de la oprit la plin grnVal = 1; // Green off to full bluVal = 256 - gsrVal; // Albastru de la plin la oprit String SoundC = "C"; Serial.println (SoundC); }

analogWrite (redPin, redVal); // Scrieți valori pe pinii LED analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal); gsr = runGSR (); întârziere (100); }

Deci, acum LED-ul reacționează la nivelul dvs. de stres, să adăugăm niște muzică pentru a vă reprezenta starea de spirit, în pasul următor.

Pasul 5: Gestionarea muzicii

Am ales să reprezentăm cele 3 niveluri de stres cu următoarea muzică:

1. Nivel scăzut (A): boluri cântătoare și ciripit de păsări, un sunet foarte ușor

2. Nivel mediu (B): un pian melancolic, un sunet puțin mai greu

3. Nivel ridicat de stres (C): o furtună cu tunete, un sunet întunecat (deși destul de relaxant)

Codul este scris în Processing, un software care oferă partea de feedback software Arduino:

import processing.serial. *; import ddf.minim. *;

Minim minim;

Playere AudioPlayer ;

int lf = 10; // Linefeed în ASCII

String myString = nul; Serial myPort; // Portul serial int sensorValue = 0;

configurare nulă () {

// Listează toate porturile seriale disponibile printArray (Serial.list ()); // Deschideți portul pe care îl utilizați la aceeași viteză ca Arduino myPort = Serial nou (acesta, Serial.list () [2], 9600); myPort.clear (); // ștergeți măsurătorile myString = myPort.readStringUntil (lf); myString = nul; // trecem acest lucru către Minim astfel încât să poată încărca fișiere minim = new Minim (acesta); jucători = nou AudioPlayer [3]; // Schimbați numele fișierului audio aici și adăugați-l la playerele bibliotecilor [0] = minim.loadFile ("Singing-bowls-and-birds-chirping-sleep-music.mp3"); jucători [1] = minim.loadFile ("Melancholic-piano-music.mp3"); jucători [2] = minim.loadFile ("Storm-sound.mp3"); }

draw nul () {

// verificați dacă există o valoare nouă în timp ce (myPort.available ()> 0) {// stocați datele în myString myString = myPort.readString (); // verifică dacă avem ceva cu adevărat dacă (myString! = null) {myString = myString.trim (); // verificați dacă există ceva dacă (myString.length ()> 0) {println (myString); încercați {sensorValue = Integer.parseInt (myString); } catch (Exception e) {} if (myString.equals ("A")) // vedeți ce nivel de stres măsoară {jucătorii [0].play (); // redare după muzică} else {playere [0].pause (); // dacă nu măsoară nivelul de stres scăzut, nu redați melodia corespunzătoare} if (myString.equals ("B")) {players [1].play (); } else {jucători [1].pause (); } if (myString.equals ("C")) {players [2].play (); } else {jucători [2].pause (); }}}}}

Acest cod ar trebui să redea muzica în funcție de nivelul de stres de pe difuzoarele noastre pentru laptop.

Pasul 6: Proiectați întruchiparea

Am folosit partea superioară a becului Philips Hue Light, dar am realizat un fund verde. SolidWorksfile este aici, dar ar putea fi, de asemenea, distractiv să măsurați singură lampa și să proiectați ceva după gustul dvs.!

Am folosit o fotografie cu partea superioară a lămpii ca substrat în SW, pentru a ne asigura că forma de jos urmează curba de sus (a se vedea prima fotografie).

Pentru ca modelul să fie controlat, salvați-l ca fișier STL și găsiți aparatul de măcinat local (de exemplu la uni).

Pasul 7: Surse

Dacă doriți mai multe informații despre acest subiect sau vedeți coduri mai extinse pentru măsurarea stresului, consultați următoarele site-uri web și proiecte:

• Mai multe explicații despre declanșarea audiofilelor în procesare (pe care le-am folosit)
• Frumos manual despre GSR
• O abordare diferită a proiectării stării de spirit
• Detector de stres foarte rece cu mai mulți senzori (mare inspirație pentru acest proiect)
• Proiector de sunet (în loc de stres) cu LED RGB
• Bun articol despre GSR