Mood Projector (Hacked Philips Hue Light met GSR) TfCD - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:19

Door Laura Ahsmann & Maaike Weber

Doel: Een slecht humeur en stress maken een groot deel uit van het moderne snelle leven. Het is ook iets dat voor de buitenwereld onzichtbaar is. Wat als we ons stressniveau zowel visueel als akoestisch konden projecteren met een product, om te kunnen laten zien hoe je je voelt. Het zou het makkelijker maken om over deze problemen te communiceren. Je eigen reactie kan ook beter aansluiten bij het moment waarop je feedback krijgt over je stressniveaus.

GSR, of galvanische huidweerstand, een meting binnen de vingertoppen van een gebruiker, blijkt een zeer goede voorspeller van stress te zijn. Omdat de zweetklieren in de hand vooral reageren op stress (niet alleen fysieke inspanning), genereren verhoogde stressniveaus een hogere geleiding. Deze variabele wordt in dit project gebruikt.

Idee: wat als we stress of stemming snel zouden kunnen detecteren en weergeven met gekleurd licht en muziek? Een GSR-systeem kan dat mogelijk maken. In deze Instructable zullen we een op Arduino gebaseerd systeem maken om dat te doen! Het wordt beheerd door zowel Arduino-software als verwerkingssoftware en vertaalt de huidgeleidingswaarden in een bepaald kleurlicht en een bepaald soort muziek.

Wat heb je nodig?

• Arduino Uno
• Draden
• Philips Hue licht (Living Colors)
• Drie 100 Ohm weerstanden (voor de RGB LED)
• Eén weerstand van 100 KOhm (voor de GSR-sensor)
• Iets om als geleidingssensoren te fungeren, zoals aluminiumfolie
• Arduino-software
• Verwerkingssoftware (we gebruikten v2.2.1, nieuwere hebben de neiging om te crashen)
• SolidWorks, om de behuizing te ontwerpen (optioneel)
• Toegang tot een CNC-frees (optioneel)
• Groen modelleerschuim (EPS)
• Breadboard (optioneel, kan ook solderen)

Stap 1: Haal het Hue Light uit elkaar

Deze stap is eenvoudig, gebruik gewoon wat kracht (of een schroevendraaier) laat los en barst het licht open. Sommige klikverbindingen houden het product bij elkaar, dus het is gemakkelijk uit elkaar te halen.

Nu kan het licht in de bovenkant eraf worden geschroefd en losgekoppeld van de rest van de elektronica. We hebben alleen het licht en de bovenkant van de behuizing nodig. Bewaar of gooi de rest, het is aan jou!

Stap 2: De hardware voorbereiden

Voor dit project hebben we een Philips Hue-lamp gebruikt om de belichaming mooier en sneller te maken. U kunt echter ook een gewone RGB-led gebruiken, zoals op de afbeelding met het breadboard te zien is.

Om de RGB-LED te bedienen, sluit u de pinnen aan op drie verschillende PWM-poorten van de Arduino (aangegeven met ba a ~). Gebruik voor deze aansluiting de 100 Ohm weerstanden. Sluit de langste pin aan op de 5V-uitgang van de Arduino. Om te zien welke pin bij welke kleur hoort, zie de laatste afbeelding van deze stap.

Voor de Hue Light gelden dezelfde stappen. De LED is eenvoudig aan te sluiten op de Arduino door draden in de daarvoor bestemde sleuven te solderen, zie de derde afbeelding in deze stap. De sleuven hebben een R, een G en een B die aangeven welke draad waar moet komen. Het heeft ook een + en een - slot, om respectievelijk aan te sluiten op de 5V van de Arduino en de aarde van de Arduino. Nadat je de LED hebt aangesloten, kun je hem weer in de behuizing schroeven.

Om de GSR-sensoren, gemaakt van aluminiumfolie, aan te sluiten (of gebruik die alumium bakjes met theelichtjes, die zien er net wat mooier uit), soldeer of plak ze aan een draad en sluit er een aan op de 5V. Sluit de andere aan op de weerstand van 100 KOhm en een condensator van 0, 1mF (parallel), die dan moet worden aangesloten op de grond en het A1-slot op de Arduino. Dit geeft de output van het stressniveau, dat vervolgens gebruikt wordt als input voor de lichtkleur en muziek. We hebben de sensoren op de lamp geplakt, zodat het een mooi product wordt om vast te pakken tijdens het meten van je stress. Let er echter op dat de sensoren elkaar niet raken!

De laatste foto laat zien hoe het kan zonder een breadboard.

Stap 3: Het stressniveau meten

Het meten van het stressniveau met alleen deze zelfgemaakte sensoren zal zeker geen nauwkeurige metingen geven van hoe gestrest je precies bent. Als het echter goed is gekalibreerd, kan het een benadering geven.

Om de GSR-niveaus te meten, gebruiken we het volgende stukje code in de Arduino-omgeving. Om een minder fluctuerende meting te hebben, wordt elke 10 metingen een gemiddelde genomen.

const int numReadings = 10; int lezingen [numReadings]; // invoer van A1 int index = 0; // de index van de huidige meting int totaal = 0; // het lopende totaal zonder teken lang gemiddelde = 0; // de gemiddelde

int invoerPin = A1;

ongeldige setupGSR()

{ // zet alle metingen op 0:

voor (int i = 0; i < numReadings; i++) metingen = 0; }

niet-ondertekende lange termijnGSR() {

totaal = totaal - metingen [index]; // lees van GSR-sensormetingen [index] = analogRead (inputPin); // voeg nieuwe meetwaarde toe aan totaal totaal = totaal + meetwaarden [index]; // volgende positie van array index = index + 1;

// test einde van array

if (index >= numReadings) // en opnieuw beginnen index = 0;

// wat is het gemiddelde

gemiddelde = totaal / aantal Aflezingen; // stuur het naar de computer als ASCII-cijfers het gemiddelde retourneren;

}

In een ander tabblad (om de zaken overzichtelijk te houden), zullen we de code maken om op de metingen te reageren, zie de volgende stap!

Stap 4: De lichten beheren

Om de lichten te beheren, moeten we eerst de metingen kalibreren. Controleer wat de bovengrens van uw metingen is door de seriële monitor te openen. Voor ons waren de metingen iets tussen de 150 (wanneer we echt probeerden te ontspannen) en de 300 (toen we heel hard probeerden om gestrest te raken).

Bepaal vervolgens welke kleur welk stressniveau moet vertegenwoordigen. We hebben het zo gemaakt dat:

1. Laag stressniveau: wit licht, verandert in groen licht bij toenemende stress

2. Gemiddeld stressniveau: groen licht, verandert in blauw licht bij toenemende stress

3. Hoog stressniveau: blauw licht, verandert in rood bij toenemende stress

De volgende code is gebruikt om de metingen te verwerken en om te zetten in waarden om naar de LED te sturen:

//MASTER #define DEBUG 0

// GSR = A1

int gsrVal = 0; // Variabele om de invoer van de sensoren op te slaan

// Zoals vermeld, gebruik de Pulsbreedte Modulatie (PWM) pinnen

int redPin = 9; // Rode LED, aangesloten op digitale pin 9 int grnPin = 9; // Groene LED, aangesloten op digitale pin 10 int bluPin = 5; // Blauwe LED, aangesloten op digitale pin 11

// Programmavariabelen

int redVal = 0; // Variabelen om de waarden op te slaan die naar de pinnen moeten worden verzonden int grnVal = 0; int blauwVal = 0;

niet-ondertekende lange gsr = 0;

ongeldige setup()

{ pinMode (bluPin, UITGANG); pinMode (grnPin, UITGANG); pinMode (redPin, UITGANG); pinMode (A1, INGANG);

Serieel.begin(9600);

setupGSR(); }

lege lus()

{ gsrVal=gsr; if (gsrVal < 150) // Laagste derde van het gsr-bereik (0-149) { gsr = (gsrVal /10) * 17; // Normaliseren naar 0-255 redVal = gsrVal; // uit naar volledige grnVal = gsrVal; // Groen van uit tot volledig bluVal = gsrVal; // Blauw uit naar volSnaargeluidA = "A"; Serial.println(SoundA); // voor later gebruik bij het bedienen van muziek } else if (gsrVal < 250) // Middelste derde van gsr-bereik (150-249) { gsrVal = ((gsrVal-250) /10) * 17; // Normaliseren naar 0-255 redVal = 1; // Rood uit grnVal = gsrVal; // Groen van vol tot uit bluVal = 256 - gsrVal; // Blauw van uit naar volledig String SoundB = "B"; Serieel.println(SoundB); } else // Bovenste derde van gsr-bereik (250-300) { gsrVal = ((gsrVal-301) /10) * 17; // Normaliseren naar 0-255 redVal = gsrVal; // Rood van uit tot volledig grnVal = 1; // Groen uit tot volledig bluVal = 256 - gsrVal; // Blauw van vol naar uit String SoundC = "C"; Seriële.println(SoundC); }

analogWrite(redPin, redVal); // Schrijf waarden naar LED-pinnen analogWrite (grnPin, grnVal); analogWrite(bluPin, bluVal); gsr = runGSR(); vertraging (100); }

Dus nu reageert de LED op je stressniveau, laten we in de volgende stap wat muziek toevoegen om je stemming weer te geven.

Stap 5: De muziek beheren

We hebben ervoor gekozen om de 3 stressniveaus weer te geven met de volgende muziek:

1. Laag niveau (A): klankschalen en fluitende vogels, een heel licht geluid

2. Gemiddeld niveau (B): een melancholische piano, een wat zwaarder geluid

3. Hoog stressniveau (C): een onweersbui, een donker geluid (hoewel vrij ontspannend)

De code is geschreven in Processing, een software om het software-feedbackgedeelte van Arduino te leveren:

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

Minimaal minimaal;

AudioPlayer spelers;

int lf = 10; // Regelinvoer in ASCII

String mijnString = null; Seriële myPort; // De seriële poort int sensorValue = 0;

ongeldige setup() {

// Lijst van alle beschikbare seriële poorten printArray (Serial.list ()); // Open de poort die u gebruikt met dezelfde snelheid als Arduino myPort = new Serial(this, Serial.list()[2], 9600); mijnPort.clear(); // wis metingen myString = myPort.readStringUntil(lf); mijnString = null; // we geven dit door aan Minim zodat het bestanden kan laden minim = new Minim(this); spelers = nieuwe AudioPlayer[3]; // Verander hier de naam van het audiobestand en voeg het toe aan de bibliotheken players[0] = minim.loadFile("Singing-bowls-and-birds-chirping-sleep-music.mp3"); spelers[1] = minim.loadFile("Melancholische-piano-muziek.mp3"); spelers[2] = minim.loadFile("Storm-sound.mp3"); }

nietig tekenen() {

// controleer of er een nieuwe waarde is while (myPort.available ()> 0) { // sla de gegevens op in myString myString = myPort.readString(); // controleer of we echt iets hebben if (myString != null) { myString = myString.trim(); // controleer of er iets is if (myString.length() > 0) { println(myString); probeer {sensorValue = Integer.parseInt(myString); } catch(Uitzondering e) { } if (myString.equals("A")) // kijk welk stressniveau het meet {players[0].play(); // speel volgens muziek } else { players [0].pause(); // als het geen laag stressniveau meet, speel dan niet het bijbehorende nummer } if (myString.equals("B")) { players[1].play(); } else { spelers[1].pauze(); } if (myString.equals("C")) { spelers[2].play(); } else { spelers[2].pauze(); } } } } }

Deze code moet de muziek afspelen volgens het stressniveau op onze laptopspeakers.

Stap 6: Ontwerp de uitvoering

We gebruikten het bovenste deel van de Philips Hue Light, maar cnc'd een greenfoam onderkant. De SolidWorksfile is er, maar het kan ook leuk zijn om de lamp zelf op te meten en iets naar jouw smaak te ontwerpen!

We gebruikten een foto van de bovenkant van de lamp als onderlaag in SW, om er zeker van te zijn dat de vorm van de onderkant de ronding van de bovenkant volgt (zie eerste foto).

Om het model te laten cnc'en, sla het op als een STL-bestand en zoek je lokale molenaar (bij uni bijvoorbeeld).

Stap 7: Bronnen

Wil je meer informatie over dit onderwerp, of uitgebreidere codes voor het meten van stress, kijk dan op de volgende websites en projecten:

• Meer uitleg over het activeren van audiobestanden in Processing (die we gebruikten)
• Mooi handboek over GSR
• Coole andere benadering van stemmingsprojectie
• Echt coole stressdetector met meerdere sensoren (grote inspiratie voor dit project)
• Geluidsprojector (in plaats van stress) met RGB LED
• Goed artikel over GSR