Proyector Mood (Philips Hue Light pirateado con GSR) TfCD: 7 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

Por Laura Ahsmann y Maaike Weber

Propósito: Los estados de ánimo bajos y el estrés son una gran parte de la vida moderna y acelerada. También es algo invisible para el exterior. ¿Y si pudiéramos proyectar tanto visual como acústicamente nuestro nivel de estrés con un producto, para poder mostrar cómo te sientes? Facilitaría la comunicación sobre estos problemas. Su propia reacción también podría ser más adecuada al momento en que reciba retroalimentación sobre sus niveles de estrés.

Se ha demostrado que GSR, o resistencia galvánica de la piel, una medida que se toma en la punta de los dedos de un usuario, es un muy buen predictor del estrés. Dado que las glándulas sudoríparas de la mano reaccionan principalmente al estrés (no solo al ejercicio físico), el aumento de los niveles de estrés genera una mayor conductancia. Esta variable se utiliza en este proyecto.

Idea: ¿Qué pasaría si pudiéramos detectar rápidamente el estrés o el estado de ánimo y representarlo con luz de colores y música? Un sistema GSR podría hacer que eso suceda. ¡En este Instructable, crearemos un sistema basado en Arduino para hacer eso! Operado tanto por el software Arduino como por el software de procesamiento, traducirá los valores de conductancia de la piel en un cierto color de luz y un cierto tipo de música.

¿Que necesitas?

• Arduino Uno
• Alambres
• Luz Philips Hue (colores vivos)
• Tres resistencias de 100 ohmios (para el LED RGB)
• Una resistencia de 100 KOhmios (para el sensor GSR)
• Algo que actúe como sensores de conductancia, como papel de aluminio.
• Software Arduino
• Software de procesamiento (usamos v2.2.1, los más nuevos tienden a fallar)
• SolidWorks, para diseñar la carcasa (opcional)
• Acceso a una fresadora CNC (opcional)
• Espuma de modelado verde (EPS)
• Placa de pruebas (opcional, también se puede soldar)

Paso 1: desmonte la luz de tono

Este paso es fácil, solo use un poco de fuerza (o un destornillador), suelte y abra la luz. Algunas conexiones a presión mantienen el producto unido, por lo que es fácil de desmontar.

Ahora, la luz en la parte superior se puede atornillar y desconectar del resto de la electrónica. Solo necesitaremos la luz y la parte superior de la carcasa. Guarda o tira el resto, ¡tú decides!

Paso 2: preparación del hardware

Para este proyecto, usamos una luz Philips Hue, para hacer que la encarnación sea más bonita y rápida. Sin embargo, también puede usar un LED RGB normal, como se muestra en la imagen con la placa de pruebas.

Para operar el LED RGB, conecte los pines a tres puertos PWM diferentes del Arduino (indicado ba a ~). Utilice las resistencias de 100 ohmios para esta conexión. Conecte el pin más largo a la salida de 5V del Arduino. Para ver qué pin corresponde a qué color, vea la última imagen de este paso.

Para el Hue Light, se siguen los mismos pasos. El LED se conecta fácilmente al Arduino soldando cables en las ranuras designadas, vea la tercera imagen en este paso. Las ranuras tienen una R, una G y una B, lo que indica qué cable debe ir a dónde. También tiene una ranura + y a -, para conectarse a los 5V del Arduino y a la tierra del Arduino, respectivamente. Una vez que haya conectado el LED, puede volver a atornillarlo en la carcasa.

Para conectar los sensores GSR, hechos de papel de aluminio (o use esos recipientes de aluminio de velas de té, que se ven un poco más bonitos), suéltelos o péguelos con cinta adhesiva a un cable y conecte uno a los 5V. Conecta el otro a la resistencia de 100KOhm y un condensador de 0, 1mF (paralelo), que luego debe conectarse a tierra y a la ranura A1 del Arduino. Esto dará la salida del nivel de estrés, que luego se utilizará como entrada para el color de la luz y la música. Pegamos los sensores a la lámpara, por lo que se convierte en un producto agradable para agarrar mientras mide su estrés. Sin embargo, tenga cuidado de que los sensores no se toquen.

La última imagen muestra cómo se puede hacer sin una placa de pruebas.

Paso 3: medir el nivel de estrés

Medir el nivel de estrés con solo estos sensores caseros definitivamente no proporcionará mediciones precisas de cuán estresado está exactamente. Sin embargo, cuando se calibra correctamente, puede dar una aproximación.

Para medir los niveles de GSR, usaremos el siguiente fragmento de código, en el entorno Arduino. Para tener una medición menos fluctuante, se toma un promedio cada 10 lecturas.

const int numReadings = 10; int lecturas [numReadings]; // entrada de A1 int index = 0; // el índice de la lectura actual int total = 0; // el promedio largo sin firmar total acumulado = 0; // el promedio

int inputPin = A1;

configuración vacía GSR ()

{// establece todas las lecturas en 0:

para (int i = 0; i <numReadings; i ++) lecturas = 0; }

unsigned long runGSR () {

total = total - lecturas [índice]; // leer de las lecturas del sensor GSR [índice] = analogRead (inputPin); // agregar una nueva lectura al total total = total + lecturas [índice]; // siguiente posición de la matriz index = index + 1;

// prueba el final de la matriz

if (index> = numReadings) // y empezar de nuevo index = 0;

// cual es el promedio

promedio = total / numReadings; // enviarlo a la computadora como promedio de retorno de dígitos ASCII;

}

En otra pestaña (para mantener las cosas organizadas), haremos que el código reaccione a las medidas, ¡mira el siguiente paso!

Paso 4: Manejo de las luces

Para gestionar las luces, primero tenemos que calibrar las medidas. Compruebe cuál es el límite superior de sus medidas abriendo el monitor en serie. Para nosotros, las medidas estaban entre 150 (cuando realmente intentamos relajarnos) y 300 (cuando nos esforzamos mucho por estresarnos).

Luego, decida qué color debe representar qué nivel de estrés. Lo hicimos para que:

1. Nivel de estrés bajo: luz blanca que se convierte en luz verde al aumentar el estrés

2. Nivel de estrés medio: luz verde, que cambia a luz azul al aumentar el estrés

3. Alto nivel de estrés: luz azul, que cambia a rojo al aumentar el estrés

El siguiente código se utilizó para procesar las medidas y convertirlas en valores para enviar al LED:

// MASTER #define DEBUG 0

// GSR = A1

int gsrVal = 0; // Variable para almacenar la entrada de los sensores

// Como se mencionó, use los pines de Modulación de ancho de pulso (PWM)

int redPin = 9; // LED rojo, conectado al pin digital 9 int grnPin = 9; // LED verde, conectado al pin digital 10 int bluPin = 5; // LED azul, conectado al pin digital 11

// Variables de programa

int redVal = 0; // Variables para almacenar los valores a enviar a los pines int grnVal = 0; int bluVal = 0;

unsigned long gsr = 0;

configuración vacía ()

{pinMode (bluPin, SALIDA); pinMode (grnPin, SALIDA); pinMode (redPin, SALIDA); pinMode (A1, ENTRADA);

Serial.begin (9600);

setupGSR (); }

bucle vacío ()

{gsrVal = gsr; if (gsrVal <150) // Tercio más bajo del rango de gsr (0-149) {gsr = (gsrVal / 10) * 17; // Normalizar a 0-255 redVal = gsrVal; // desactivado al máximo grnVal = gsrVal; // Verde de apagado a completo bluVal = gsrVal; // Azul apagado al máximoString SoundA = "A"; Serial.println (SoundA); // para uso posterior en música operativa} else if (gsrVal <250) // Tercio medio del rango gsr (150-249) {gsrVal = ((gsrVal-250) / 10) * 17; // Normalizar a 0-255 redVal = 1; // Rojo apagado grnVal = gsrVal; // Verde de completo a apagado bluVal = 256 - gsrVal; // Azul de apagado a completo String SoundB = "B"; Serial.println (SoundB); } else // Tercio superior del rango gsr (250-300) {gsrVal = ((gsrVal-301) / 10) * 17; // Normalizar a 0-255 redVal = gsrVal; // Rojo de apagado a completo grnVal = 1; // Verde apagado a bluVal completo = 256 - gsrVal; // Azul de completo a apagado String SoundC = "C"; Serial.println (SoundC); }

analogWrite (redPin, redVal); // Escribir valores en los pines LED analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal); gsr = runGSR (); retraso (100); }

Entonces, ahora que el LED está reaccionando a su nivel de estrés, agreguemos algo de música para representar su estado de ánimo, en el siguiente paso.

Paso 5: administrar la música

Elegimos representar los 3 niveles de estrés con la siguiente música:

1. Nivel bajo (A): cuencos cantores y pájaros cantando, un sonido muy ligero

2. Nivel medio (B): un piano melancólico, un sonido un poco más pesado

3. Alto nivel de estrés (C): una tormenta, un sonido oscuro (aunque bastante relajante)

El código está escrito en Processing, un software para proporcionar la parte de retroalimentación del software de Arduino:

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

Minim minim;

Reproductores AudioPlayer ;

int lf = 10; // Salto de línea en ASCII

String myString = null; Serial myPort; // El puerto serie int sensorValue = 0;

configuración vacía () {

// Lista todos los puertos serie disponibles printArray (Serial.list ()); // Abre el puerto que estás usando a la misma velocidad que Arduino myPort = new Serial (this, Serial.list () [2], 9600); myPort.clear (); // borrar medidas myString = myPort.readStringUntil (lf); myString = null; // pasamos esto a Minim para que pueda cargar archivos minim = new Minim (this); reproductores = nuevo AudioPlayer [3]; // Cambie el nombre del archivo de audio aquí y agréguelo a las bibliotecas reproductores [0] = minim.loadFile ("Cuencos-cantantes-y-pájaros-chirridos-dormir-música.mp3"); reproductores [1] = minim.loadFile ("Melancholic-piano-music.mp3"); jugadores [2] = minim.loadFile ("Storm-sound.mp3"); }

vacío dibujar () {

// verifica si hay un nuevo valor while (myPort.available ()> 0) {// almacena los datos en myString myString = myPort.readString (); // verificamos si realmente tenemos algo if (myString! = null) {myString = myString.trim (); // verifica si hay algo if (myString.length ()> 0) {println (myString); intente {sensorValue = Integer.parseInt (myString); } catch (Exception e) {} if (myString.equals ("A")) // ver qué nivel de estrés está midiendo {players [0].play (); // reproducir de acuerdo con la música} else {reproductores [0].pause (); // si no mide un nivel de estrés bajo, no reproduzca la canción correspondiente} if (myString.equals ("B")) {players [1].play (); } else {jugadores [1].pause (); } if (myString.equals ("C")) {jugadores [2].play (); } else {jugadores [2].pause (); }}}}}

Este código debería reproducir la música de acuerdo con el nivel de estrés en los altavoces de nuestra computadora portátil.

Paso 6: diseñar la encarnación

Usamos la parte superior de Philips Hue Light, pero construimos una parte inferior de espuma verde. El archivo SolidWorks está aquí, pero también podría ser divertido medir la lámpara usted mismo y diseñar algo a su gusto.

Usamos una foto de la parte superior de la lámpara como capa inferior en SW, para asegurarnos de que la forma de la parte inferior sigue la curva de la parte superior (ver la primera foto).

Para tener el modelo cnc, guárdelo como un archivo STL y busque su molinero local (en uni, por ejemplo).

Paso 7: Fuentes

Si desea obtener más información sobre este tema o ver códigos más extensos para medir el estrés, consulte los siguientes sitios web y proyectos:

• Más explicación sobre la activación de archivos de audio en Processing (que usamos)
• Buen manual sobre RSG
• Enfoque diferente y genial para proyectar el estado de ánimo
• Detector de estrés realmente genial con múltiples sensores (gran inspiración para este proyecto)
• Proyector de sonido (en lugar de estrés) con LED RGB
• Buen artículo sobre GSR