Design Thinking

Un artista audiovisual ha pedido un encargo.

Necesita crear una pieza que simule un Theremin y que a la vez esté adaptado para que personas sordas. Para ello, a la vez que va cambiando la frecuencia de sonidos, también afectará a los colores de un led RGB.

Se le plantea crear un Theremin digital con entradas analógicas. Para ello se realiza la siguiente idea:

Un sensor fototransmisor capatará la cantidad de luz que le llega y como consecuencia, cuando pasemos la mano alrededor del sensor la cantidad de luz que le llegará se irá modificando. Dependiendo de los datos que devuelva el fototransmisor se le pasarán unos datos a un Piezo y emitirá diferentes sonidos.

Se propone la realización de un prototipo con Arduino, conectado por puerto USB a un ordenador que le dará una potencia máxima 5V. Con este simulador se podrá plantear una idea mucho más desarrollada y perfecionada.

Producto desarrollado

Componentes

Nos encontramos con diferentes  acciones que actúan sobre diferentes controles:

Iluminación (leds)

Tenemos dos leds, uno sencillo rojo y otro RGB.
El primero, el led rojo,  lo usamos para indicarnos que se están calibrando los fototransmisores. Cuando se apaga ya podemos iniciar el juego de luces y sonidos.

El Led RGB se usa para mostrar la versión audio en colores. Estos sensores tienen, a parte del cátodo que va a tierra, tres pines. Depende de la tensión que salen de los pines se modula el color del LED.

Audio

Se utiliza un elemento denominado Piezo que lo que hace es vibrar cuando recibe una señal. En nuestro caso la señal la recibimos mapeada desde uno de los  fototransistores, más concretamente el que le da la seña de rojo al pin del Led RGB.

Acción del usuario o entorno

El  entorno envía la acción a través de los fototransistores. Hay tres que envían la señal al Led RGB (rojo, verde y azul).

El usuario interactúa con los tres fototransistores aunque sólo uno de ellos, el mismo que envía la señal al pin rojo, es el que envía la señal a Piezo. El resto hace que la luz se modifique también cuando pasamos la mano a su alrededor. Por lo tanto se modifican el resto de colores.

Desarrollo

En las conexiones de los diferentes sensores y elementos se han tenido en cuenta  conectar los cátodos o emisores a tierra y los ánodos o colectores a difrentes pines.

En concreto destacar que hay 6 pines digitales en la placa de Arduino, marcados con ~ (~3, ~5, ~6, ~9, ~10, ~11). El LED RGB conecta sus diferentes pines en tres de estos pines digitales (en concreto el 9, 10, 11).

A estos pines digitales se les ha enviado información analógica (la luz ambiental a través de los fototransmisores, que están conectados a la placa de Arduino a los pines analógico (A0, A1, A2).

Hay que destacar un error que me he encontrado en el libro. La resistencia del pin rojo debería ser diferente a las del verde y el azul. Esto es debido a que necesita menos tensión para funcionar.

Para ello lo que se ha realizado es un cambio de resistencia en fototransmisor que envía la señal al rojo. En vez de 10Kilo ohmios le pasamos 1 Kilo ohmio y esto hace que llegue menos tensión.

Hay un red Rojo que conectado a tierra y al pin 13 que lo que hace es apagarse cuando en el se han calibrado los sensores a través del código recogido en el setup()

El bizer está conectado el pin 8 y envía una frecuencia según los valores recogidos por el fotsensor.

// FOTOTRANSISTOR
// ----------------
// Los fototransistores emiten un corriente proporcional a la cantidad de luz que absorven.
// Creamos las varibles constantes que nos indicarán donde están conectados Fototransistores o sensores de luz en la placa de Arduino
// Están conectados a los Pines de ENTRADAS ANALÓGICAS de la placa de Arduino
// cada Fototransistor le pasará un dato a un pin del LED RGB
const int redSensorPin = A0;
const int greenSensorPin = A1;
const int blueSensorPin = A2;

// LED RGB (emitirá una luz según la iluminación que le lleguen a los 3 fototransmisores
// ----------------
// Declaramos las variables que afectarán al sensor RGB
// Conectamos los tres terminales del sensor a tres de los 6 pines de arduino PWM ~ (9, 10, 11) identificados conn ~
// Hacemos constantes porque son variables que no se modifican, son fijas
const int greenLEDPin = 9;
const int blueLEDPin = 10;
const int redLEDPin = 11;

//FOTOTRANSISTOR para el Theremín
// ----------------
//Creamos variables enteras para uno de los fototransistores que será el que
//modifique el sonido emitido por el PIEZO

//_ Valores iniciales
int sensorValue;//variable que leerá el valor leído con la función analogRead(). En concreto el A0
int sensorLow; //el valor incial es de 1023
int sensorHigh = 0; //el valor inical es 00

// El fototransitor se tiene que calibrar. Cuando se calibra la luz del Pin se apaga y significa que
// el piezo comienza a funcionar porque los sensores de luz o fototransitores ya están calibrados
// Constante que indica que el sensor conectado a A0 ha terminado la calibración.
// Está conectado al pin 13
const int ledPin = 13;

// LED RGB
// ----------------
//_ Valores iniciales de los terminales del LED RGB que se usarán para modular el LED
// Valores de entrada
int redValue= 0;
int greenValue= 0;
int blueValue= 0;
// Valores de salida
int redSensorValue= 0;
int greenSensorValue= 0;
int blueSensorValue= 0;

void setup() {
// Establecemos la conexión entre la placa de Arduino y el ordenador
// para poder ver los valores de la entrada analógica en la pantalla del ordenador
// El argumento 9600bit/seg es la velocidad con la Que Arduino se comunicará
// usando el puerto serie IDE para ver la información que se envía desde el microcontrolador
// en este caso también veremos los valores mapeados con el método map()
Serial.begin(9600); //configuramos la comunicación serie a 9600 bps

//definimos los diferentes pin del LED RGB
pinMode(greenLEDPin, OUTPUT);
pinMode(redLEDPin, OUTPUT);
pinMode(blueLEDPin, OUTPUT);

//definimos el pin del LED rojo
pinMode(ledPin, OUTPUT);

//digitalWrite() es la función que permite enviar 5V o 0V a un pin de salida usando los
//dos argumentos posibles HIGH o LOW
//encendemos el LED rojo
digitalWrite(ledPin, HIGH);

//Hacemos un bucle para calibrar los valores máximos y mínimos del sensor conectado al pin A0
//que en nustro caso es el redSensorPin (el primero a la izda)
while(millis() < 5000){ sensorValue = analogRead(redSensorPin); // guardamos el valor recogido por el sensor, // en la variable creada al inicio if (sensorValue > sensorHigh){ //si ese valor que recoge es mayor que 0 es que recibe señal
sensorHigh = sensorValue; // cambiamos el valor del sensorHigh
// que al inicio era 0 con el valor que recoge el redSensorPin
// que recordamos es el que está conectado al A0
}
if (sensorValue < sensorLow){ //si el sensorValue es menor que 1023 que es l valor incial,
// es decir, no se pasa de rango
// le asignamos su valor a sensor low

sensorLow = sensorValue;
}
// como es un bucle estos valores van cambiando hasta que deje de ser cierta la condición
// en ese momento se mantien un valor de sensorHigh y otro de sensorLow y
// nos indica que ya está calibrado y se apaga la luz del LED rojo
}
digitalWrite(ledPin, LOW); //apagamos el led Rojo

}
void loop() {
// Theremin
// =========

sensorValue = analogRead(redSensorPin);//leemos el redSensorPin A0 y lo guardamos en la variable
//esta lectura la hace constantemente por el loop por lo que el tono cambiará si modificamos
//la luz que recibe el fotoTransistor conectado a A0

// El método map() crea un nuevo array con los resultados de la llamada a la
// función indicada aplicados a cada uno de sus elementos.argumentos de map()
// map(valor, fromLow, fromHigh, toLow, toHigh)

// mapeamos el valor que recibimos en el sensorValue poniendo como como
// límite de valores de entrada sesorLow y sensorHigh
// así le asignamos un valor proporcional que esté entre 50 y 40000 (que es el intervalod e
// frecuencia que genera Arduino)

int pitch = map(sensorValue, sensorLow, sensorHigh, 50, 40000);

// llamamos a la función tone() para reproducir sonido
// recoge tres agumentos:
// 1.- el pin que reproduce el sonido, en nuestro caso el 8 que es donde está conectado el PIEZO
// 2.- la frecuencia que está recogida en la variable entera pitch que ha mapeado los datos del sensor
//. para transformala en una frecuencia leible por el PIEZO
// 3.- delay que es el tiempo que reproduce dicha nota
tone(8, pitch, 20);
delay(10); //añadimos un delay de 10 milisegundos para dar tiempo a la reporducción del sonido
//

// Cambio de iluminación. El LED RGB
// Usamos la función analogWrite para cambiar el brillo del LED a través de los pines PWM

// Necesita dos argumento. El pin en el que escribe (redLEDPin = 11, blueLEDPin = 10, greenLEDPin =9)
// y el valor de 0 a 255

redSensorValue = analogRead(redSensorPin);
delay(5);
greenSensorValue = analogRead(greenSensorPin);
delay(5);
blueSensorValue = analogRead(blueSensorPin);
delay(5);

// Como el valor de lectura es entre 0 y 1023 que es el valor que viene del sensor
// lo que hacemos es dividirlo entre 4.
// Otro posible sistema sería mapearlo
redValue =redSensorValue/4;
greenValue = greenSensorValue/4;
blueValue = blueSensorValue/4;

//Visualizamos los datos mapeados en el ordenador
Serial.print(«Datos Mapeados \t Rojo: «);
Serial.print(redValue);
Serial.print(«\t Verde: «);
Serial.print(greenValue);
Serial.print(«\t Azul: «);
Serial.println(blueValue);

//Le pasamos los dos argumentos a analogWrite para que genere menos luz cada pin
analogWrite(redLEDPin, redValue);
analogWrite(greenLEDPin, greenValue);
analogWrite(blueLEDPin, blueValue);

}