FastLed

Modelo WS2812

Hace bastante tiempo que no escribía en este, mi blog, y hoy me he decidido a hacerlo para hablaros de nuevo sobre Arduino y LEDs. Hace unos meses descubrí por circunstancias e intereses personales un tipo de LEDs, llamados "addressables" que me han cambiado la vida. ¿Qué tienen de espacial estos LEDs? Pues que, al contrario que los típicos LEDs RGB con los que puedes controlar el color de todos los leds de una tira, en los "addressables" puedes controlar el color de cada LED por separado. Gracias a que cada LED tiene un minúsculo driver en su interior, mediante una sola señal digital de la placa Arduino, puedes hacer todo tipo de animaciones con tiras de tantos LEDs como quieras, incluso crearte tu propia pantalla LED.

Tiras de LEDs WS2812B

La librería para Arduino que en este momento mejores opciones da al amante del código con la IDE de Arduino es la magnífica librería FastLed, creada por Mark Kriegsman y desarrollada por varios flipados de los LEDs que día a día van aumentando las posibilidades creativas de esta librería. Yo ya he empezado a hacer mis pinitos y, poco a poco, voy aprendiendo a hacer cosas más complejas que, como era de esperar, se van introduciendo en mis obras artísticas. Lo alucinante de esta nueva tecnología es que abre un universo de posibilidades casi infinito para aquellos que amamos el pintar con luz... A continuación os dejo los enlaces a la librería y su magnífico repositorio lleno de curiosidades, la wiki y algunos vídeos de mis últimas obras trabajando con Arduino y FastLed...

WEB de la librería FastLed

WIKI de la librería FastLed

Led Strip Driver

Hola a todos/as. Hace tiempo que tengo el blog abandonado debido a mis múltiples ocupaciones que últimamente no me dejan un momento. Hace tiempo pedí por DX.com unas plaquitas PCB que se vendían como drivers para tiras de LED RGB de la marca Catalex . Básicamente lo que hacían era simplificar lo que uno ya podía hacer comprando los componentes (mosfets, resistencias, etc...) creando una PCB que ya tenía todas las salidas y entradas para simplemente conectar a Arduino y a la fuente de alimentación de 12V. Lo interesante de estas plaquitas es que te permiten conectar varias en cascada y controlar un numero indeterminado de tiras LED RGB usando sólo dos pines digitales de la Arduino. Para ello es necesario descargarse la librería que hace funcionar las placas y que es bastante simple, llamada LED Strip Driver. Viene con sólo dos ejemplos con idea de que el usuario se busque la vida para sacarle el máximo partido usando su ingenio. He hecho un primer intento de utilización de los mismos en uno de mis proyectos de luces y el resultado ha quedado bastante bien. Controlo 4 tiras RGB completamente con sólo 4 pines PWM. Ya veremos cómo funciona cuando quiera meterle un sensor de sonido... A continuación el video de la pieza. Espero que os guste.

VPT7

Hola a todos/as. Bienvenidos a esta nueva entrada de mi blog dedicado a la utilización de hardware y software libre para proyectos artísticos. Hace poco me entraron ganas de probar la última versión del fantástico software para videomapping VPT7, creado por el inefable y generosísimo HC Gilje y basado en MAX. He seguido los tutoriales que aparecen en su página web y en poco tiempo me he puesto a crear geometrías caleidoscópicas que han hecho las delicias de mis retinas, ávidas de formas simétricas y en movimiento. Para ello he construido un modelo de cartulina diseñado previamente con Google Sketchup, para luego, haciendo uso del plugin Flattery, crear el desarrollo de cada pieza del entramado de caras triangulares del modelo. Me he pegado una pechada de recortar, doblar y pegar. Lo interesante de este software, aparte de ser gratis y de fácil utilización para los no iniciados, es que puede conectarse a arduino y que viene aderezado con varios complementos que lo hacen muy versátil a la hora de crear videos que reaccionen al sonido, que actúen según datos controlados por arduino o vía OSC que proyecten videos o animaciones interactivas creadas con PROCESSING, Quartz Composer y otros programas de creación de visuales. En este último caso es necesario el uso de una pequeña aplicación llamada Syphon, muy útil para compartir imágenes que salgan de PROCESSING y que se proyecten en VPT7. A continuación os dejo el resultado del prototipo que reacciona al sonido de la música gracias al programita Soundtrigger. Espero que os guste...

Motores paso a paso...

Pues sí amigos, ya estamos aquí de nuevo con una entrega más sobre arduino y sus aplicaciones en el ámbito del arte cinético. En esta ocasión hemos estado investigando sobre motores paso a paso (stepper motors en inglés). Se trata de un tipo de motores eléctricos que permiten un control muy preciso de la rotación del eje. Son muy comunes en aparatos tan domésticos como una impresora, la máquina de aire acondicionado, etc. Busqué por internet algún tutorial que me facilitara entender cómo funcionan y cuál sería la mejor librería de arduino para sacarles el máximo partido a su movilidad. Encontré esta página web, de un ingeniero norteamericano llamado Terry King, que me pareció estupenda y que te explica fácilmente cómo utilizar los motores paso a paso más baratos que se puedan encontrar en internet, los 28YBJ-48. Yo me compré nueve en ebay, al increible precio de 2,85 € cada uno con su driver correspondiente.

Stepper + Driver

Puesto que para mover todos los motores al mismo tiempo necesitaba bastante amperaje, fui a SONICOLOR, en Sevilla, y compré una fuente de alimentación a 5V y 10AmP, muy baratita.

Mi idea era crear un cuadro en el que nueve piezas de forma cuadrada se movieran acelerando y decelerando de forma sincronizada. El movimiento de todas ellas crearía diferentes patrones en blanco y negro que jugarían con los ángulos rectos y los de 45º. Gracias a la librería para Arduino AccelStepper, creada por Mike McCauley, es posible mover varios motores paso a paso de forma que se pueda controlar la aceleración y deceleración de una manera más o menos fácil. 

Sensor casero con led + LDR

El problema que se planteaba, una vez resuelta la cuestión de crear un parche para arduino que controlara todos los movimientos de forma sincronizada, fue lograr que pudiéramos apagar toda la instalación justo en el lugar de comienzo de toda la rutina. Como al apagar, arduino no memoriza la posición de inicio, tuve que idear un tipo de sensor de paso casero mediante un led de 3mm y un sensor LDR. Si quieres apagar la instalación, lo único que tienes que hacer es presionar un pulsador y esperar a que los motores se pongan en su posición inicial, lo cual hace que actúe el sensor y de inmediato se para todo gracias a un relé.

Interruptor y pulsador

En el proceso de creación de la pieza, descubrí los pros y contras de los motores 28YBJ-48. Su principal virtud es que son super baratos, que funcionan a 5V y que aparentemente no se calientan como la mayoría de los motores paso a paso y sus drivers. Lo malo es que, debido a que sus mecanismos internos son de plástico, tiene cierta holgura (5º+/-), lo que hace que la precisión absoluta sea imposible.

A continuación os dejo un vídeo explicativo de todo el proyecto y el resultado final. Sin dejar de gustarme, he de confesar que en el futuro, empezaré a trabajar con motores más precisos, tipo Nema 17, con Easydriver 4.4. Éstos sí que permiten precisión al milímetro y coordinación total. Tendré que rascarme los bolsillos o acudir a un punto limpio a reciclar motores de impresoras rotas (Por cierto, si alguien va a tirar su vieja impresora que me llame antes).

PD.: La pieza es un homenaje al artista eslovaco Viktor Hulík. Acudid a su web y lo vais a flipar.

Homenaje a Peter Vogel

Hace poco, a través de la web de Kinetica, descubrí al que es ahora uno de mis artistas contemporáneos favoritos, Peter Vogel. En un modesto intento de emularle he creado un pequeño experimento sonoro-lumínico parecido a los artilugios del artista alemán. He utilizado una placa arduino nano 3.0, luces led de 3 mm, resistencias, dos LDR,  altavoces sacados de una TV encontrada en la basura y alambres. Aquí os dejo un video que muestra cómo funciona.

Leds RGB

Pues sí amigos, continuamos navegando y experimentando en el proceloso a la par que ameno océano de arduino y sus posibilidades creativas. Hace un tiempo compré 5 metros de tira de leds RGB con su controlador y su fuente de alimentación. Como deseaba poder controlarlos por mí mismo, creando mis propios programas de cambio de color y ritmos de tiempo, decidí buscar información en la web para poder hacer el montaje con vistas a poder incluirlo en alguno de mis cuadros pintados sobre metacrilatos. En este blog de un tal Jerome Bernard (gracias Jerome), se explica de forma sencillita cómo se han de hacer las conexiones y el tipo de componentes electrónicos indispensables.

La forma de programar las tiras de led es mucho más simple que el código que sale en su página puesto que cada color Rojo (R), Verde (G) y Azul (B) se puede controlar con un pin digital de arduino mediante el fade de 0 a 255, o lo que es lo mismo, de 0 voltios a 5 voltios (máximo de intensidad). Es necesario tener una fuente de alimentación a 12V (hay que fijarse en la cantidad de leds a usar para saber el amperaje idóneo) y poco más. Ahí os dejo algunas fotos del trabajo. Como podéis apreciar, puesto que cada plancha de metacrilato tiene diferentes colores, al ser iluminados por diferentes tonos de luz cambian totalmente los matices, lo cual aumenta las posibilidades cromáticas respecto a proyectos míos anteriores en los que sólo usaba leds de color blanco. Espero que os guste y os sea de utilidad.

Arduino + Processing + Kinect

Pues sí amigos, aquí estamos de nuevo para compartir experiencias con tecnología abierta. Hace tiempo me compré una cámara Kinect de segunda mano y tenía ganas de experimentar con ella. Para quien no sepa qué es una Kinect, aquí tenéis un enlace. Sabía que era posible conectarla a Processing y que, a través de Processing era posible también comunicarse con Arduino. Así que me puse a bichear por internet y encontré decenas de páginas con recursos y tutoriales que me permitieron lograr hacer mi primer experimento. Básicamente consiste en una estructura de bombillas, sacada de un trabajo anterior, que se conecta a Arduino mediante una placa de relés. Los relés encienden y apagan las luces mediante las órdenes que lanza Arduino que, a su vez, está siendo controlado por un programa muy simple hecho en Processing. Mediante la librería OpenKinect para Processing, ideada por Daniel Shiffman, he hecho un patch que reconoce el movimiento de lo que se ponga delante de la cámara Kinect a una cierta distancia. Existen 4 zonas de influencia (sólo porque no tenía una placa con más de 4 relés) y cada una hace que se encienda un juego diferente de luces a través de la controladora Arduino. He utilizado para la comunicación serie la librería Firmata de Arduino. Para empezar, no está mal. He de seguir investigando...

Proyecto #8

Último trabajo utilizando filas de leds de 3mm. Parecido en lo técnico a proyectos anteriores, aunque más complejo en su realización, sobre todo por el cambio de formato. En breve añadiré un video para que lo veáis en movimiento. La verdad es que ha quedado muy vistoso.

PD.: Hasta que me di cuenta de que debía usar los pines digitales PWM para encender los leds y controlar el fade. Cosas de novato... Por cierto, la arduino nano V3.0 sólo funciona correctamente con fuente de alimentación a 14V.

Proyecto #7

Continuando con el tema del control de luces mediante Arduino, me decidí a crear una de mis cajas de luz de forma que cada placa de metacrilato pintado pudiera retroiluminarse separadamente y, así, poder crear una "animación", por decirlo de alguna manera. Lo siguiente será que la secuencia de iluminación pueda cambiar según la intensidad de la luz (mediante un LDR) o mediante la lectura del volumen de sonido circundante (mediante un mini-micrófono). Ahí os dejo el prototipo. Menudo tute de soldar leds (en total 100 bombillitas).

Proyecto #6

Después de tanto trasiego soldando diodos led y resistencias, decidí cambiar de tercio y volver a los motores. Tenía 9 servos que me funcionaban, de los que giran 180º, y me puse a probar cómo montarlos para crear algo que tuviera cierto efecto óptico. El prototipo resultante, sin dejar de ser muy simple, produce una sensación curiosa. Con ciertos ajustes y con un mayor número de servos (con Arduino Mega se pueden usar hasta 48 servos con alimentación externa) se podría hacer un montaje bastante interesante. Lo próximo será hacer que los servos reaccionen cuando alguien se mueva delante de la pieza, usando un sensor PIR que me encontré en la basura y que, después de probarlo, demostró estar a pleno rendimiento con una alimentación de 5V.

Proyecto #5

En la senda del anterior proyecto, en el que jugaba con la aleatoriedad del sonido generado gracias a la librería pitches.h de Arduino, he construido una caja de 81 leds que se iluminan de forma simétrica, conforme a la estructura de un cuadrado. Las luces se encienden aleatoriamente de 4 en 4 cada vez que algún ruido hace reaccionar el micrófono incorporado, creando una secuencia imprevisible, tanto de forma como de sonido. Aún no está terminado pues me gustaría añadir filtros de color a los leds, pero ahí os dejo el prototipo funcionando:

 

Proyecto #4

Llevo un tiempo trabajando en un nuevo proyecto en el que he querido aunar movimiento, sonido e interacción. Aprovechando un montón de ventiladores de refrigeración de ordenadores viejos que me ofreció un amigo, decidí aprovecharlos para crear algo con ellos y ARDUINO. El resultado es un cuadro cinético que interactúa con el espectador de una forma muy simple. Cuando alguien hace algún ruido que sobrepase cierto nivel de decibelios la pieza se pone en funcionamiento haciendo girar los motores en una secuencia de duración aleatoria (gracias al uso de una placa de 8 relés). Además, a cada motor en movimiento le acompaña una nota musical también aleatoria, originada gracias a la librería pitches.h para ARDUINO y a dos altavoces viejos que me encontré en un punto limpio colocados a derecha e izquierda de la estructura. El resultado es un prototipo que funciona y que puede servir para plantearme proyectos futuros de mayor envergadura.

  

Mecanismo interno

Esquema de la circuitería interior:

 

Programa de Arduino (incluye la librería pitches.h):

#include "pitches.h"

int sensorPin1 = A0;

int Knock1 = 52;

int Knock2 = 53;

int sensorValue1 = 0;

#define RELAY_ON 0

#define RELAY_OFF 1

#define Relay_1  2 

#define Relay_2  3

#define Relay_3  4

#define Relay_4  5

#define Relay_5  6

#define Relay_6  7

#define Relay_7  8

void setup()  

{

pinMode(Knock1, OUTPUT);

pinMode(Knock2, OUTPUT);

Serial.begin(9600);

 

  digitalWrite(Relay_1, RELAY_OFF);

  digitalWrite(Relay_2, RELAY_OFF);

  digitalWrite(Relay_3, RELAY_OFF);

  digitalWrite(Relay_4, RELAY_OFF);

  digitalWrite(Relay_5, RELAY_OFF);

  digitalWrite(Relay_6, RELAY_OFF);

  digitalWrite(Relay_7, RELAY_OFF); 

 

  pinMode(Relay_1, OUTPUT);  

  pinMode(Relay_2, OUTPUT); 

  pinMode(Relay_3, OUTPUT); 

  pinMode(Relay_4, OUTPUT);

  pinMode(Relay_5, OUTPUT); 

  pinMode(Relay_6, OUTPUT); 

  pinMode(Relay_7, OUTPUT); 

  delay(1000);

}

void loop() 

{

sensorValue1 = analogRead(sensorPin1);

Serial.println(sensorValue1);

 

   if (sensorValue1 > 500) {

     

  digitalWrite(Relay_1, RELAY_ON);

  tone(Knock1, random(5000), 200);

  delay(random(200, 800));  

       

  digitalWrite(Relay_1, RELAY_OFF);

  digitalWrite(Relay_2, RELAY_ON);

  tone(Knock2, random(5000), random(100, 200));

  delay(200); 

         

  digitalWrite(Relay_2, RELAY_OFF);

  digitalWrite(Relay_3, RELAY_ON);

  tone(Knock1, random(5000), random(100, 300));

  delay(300); 

           

  digitalWrite(Relay_3, RELAY_OFF);

  digitalWrite(Relay_4, RELAY_ON);

  tone(Knock2, random(4000), random(50, 100));

  delay(random(100, 800));

           

  digitalWrite(Relay_4, RELAY_OFF);

  digitalWrite(Relay_5, RELAY_ON);

  tone(Knock1, random(5000), random(100, 300));

  delay(300);  

          

  digitalWrite(Relay_5, RELAY_OFF);

  digitalWrite(Relay_6, RELAY_ON);

  tone(Knock2, random(5000), random(50, 100));

  delay(random(100, 1000));  

          

 digitalWrite(Relay_6, RELAY_OFF);

 digitalWrite(Relay_7, RELAY_ON);

 tone(Knock1, random(5000), random(100, 400));

 delay(400);  

           

 digitalWrite(Relay_7, RELAY_OFF);

  }

}

Proyecto #3. Jugando con sonido/2

Aquí seguimos investigando las posibilidades sonoras de los sensores LDR combinados con la funcion tone() y la librería pitches.h (notas en MIDI) creada por Tom Igoe para tocar tonos musicales con piezoeléctricos y bafles convencionales. En esta ocasión sólo trabajo con Arduino, conectado a 4 sensores LDR mediante resistencias de 10K que leen la intensidad de la luz de un disco perforado. Dichos sensores reconocen las diferencias de intensidad de la luz de manera que disparan una nota musical o varias, según el caso. Se pueden manipular las escalas mediante un potenciómetro (el cual se podría adaptar a cada uno de los sensores por separado). Seguiré investigando para poder crear algún tipo de armonía sonora que luego, mediante Processing, se pueda convertir también en alguna armonía "cromática".

A continuación el código para Arduino:

#include "pitches.h"

  int melody1[] = {

  NOTE_C4, NOTE_G3,NOTE_G3};

  int melody2[] = {

  NOTE_C5, NOTE_A7, NOTE_G2};

 

  int noteDurations[] = {

  8, 16, 8 };

  int sensorPin1 = A0;

  int sensorPin2 = A1;

  int sensorPin3 = A2;

  int sensorPin4 = A3;

  int potenciometroPin = A4;

    

  int Knock1 = 2;

  int Knock2 = 3;

  int Knock3 = 4;

  int Knock4 = 5;

  int sensorValue1 = 0;

  int sensorValue2 = 0;

  int sensorValue3 = 0;

  int sensorValue4 = 0;

  int potenciometro = 0;

void setup() {

  pinMode(Knock1, OUTPUT);

  pinMode(Knock2, OUTPUT);

  pinMode(Knock3, OUTPUT);

  pinMode(Knock4, OUTPUT);

 

  Serial.begin(9600);

 

}

void loop() {

  sensorValue1 = analogRead(sensorPin1);

  sensorValue2 = analogRead(sensorPin2);

  sensorValue3 = analogRead(sensorPin3);

  sensorValue4 = analogRead(sensorPin4);

 

  potenciometro = analogRead(potenciometroPin);

 

  Serial.println(potenciometro);

  delay(50);

 

  if (sensorValue3 > 900) {

      tone(Knock3, potenciometro , 70);

     // delay(50);

    }

  if (sensorValue4 > 900) {

      tone(Knock4, potenciometro*2 , 70);

     // delay(50);

}

   if (sensorValue1 > 900) {

   

      for (int thisNote = 0; thisNote < 3; thisNote++) {

      int noteDuration = 1000/noteDurations[thisNote];

      tone(Knock1, melody1[thisNote],noteDuration);

   

      int pauseBetweenNotes = noteDuration;

      delay(pauseBetweenNotes);

   

      noTone(Knock1);

  }

    }

   

    if (sensorValue2 > 900) {

      //tone(Knock2, random(31,potenciometro*2) , 100);

      //delay(50);

       for (int thisNote = 0; thisNote < 3; thisNote++) {

       int noteDuration = 1000/noteDurations[thisNote];

       tone(Knock2, melody2[thisNote],noteDuration);

   

       int pauseBetweenNotes = noteDuration;

       delay(pauseBetweenNotes);

   

       noTone(Knock2);

    }

    }

}

A continuación el tab que hay que incluir en el parche con el nombre pitches.h (cada número corresponde con una nota musical):

 /*************************************************
 * Public Constants
 *************************************************/

#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Proyecto #3. Jugando con sonido/1

Hace tiempo descubrí la web CreativeApplications.net en la que varios artistas envueltos en el uso de tecnología muestran sus proyectos y prototipos. De entre ellos llamó poderosamente mi atención el trabajo de dos grupos de artistas que trabajan con Arduino y Processing:

1) El colectivo www.the-product.org y su obra Soundmachines, y

2) Bartholomäus Traubeck y su obra Years.

Ambos proyectos buscan convertir en sonido códigos de imágenes. El primero, Soundmachines, utiliza algo así como discos perforados que al iluminarse permiten la lectura de códigos de luz que generan loops de sonido, de forma que podemos crear música de baile de forma fácil e intuitiva. El segundo es más poético. Se trata de un giradiscos capaz de leer las líneas de tiempo de un troco de árbol. Las diferencias de intensidad en las líneas generan una música al piano en apariencia caótica, incluso aleatoria. Al final se percibe cierta armonía.

Digamos que me quedé un tanto boquiabierto ante piezas tan sugerentes y, actualmente, estoy intentando emular técnicamente lo que tales artistas han logrado, para luego crear mis propias piezas en las que imagen y sonido interactúen. Mi idea inicial, parecida a la de Soundmachines, consistiría en crear un giradiscos en el que cualquiera pudiera insertar su propio disco dibujado, al modo de los discos perforados de los organillos antiguos. 

Dichos dibujos serían leídos mediante un cabezal que tuviera diferentes sensores LDR que fueran sensibles a los cambios de luminosidad y convirtieran dichos cambios en señales para hacer saltar notas musicales, un archivo sonoro, etc. A su vez, tales cambios de luminosidad podrían convertirse de nuevo en imágenes a través de Processing. A continuación os muestro mi primer intento de hacer esta idea realidad. He utilizado un motorcito de microondas para hacer girar el disco, 2 LDR conectados a una placa Arduino Mega mediante resistencias de 10K y una bombilla para iluminar el disco y aumentar el contraste de la lectura. En cuanto al software, he usado la librería Firmata(StandardFirmata) de Arduino para controlar la microcontroladora directamente desde Processing. En Processing he utilizado un programa que utiliza la librería SoundCipher que permite utilizar diferentes sonidos de forma muy fácil. A lo anterior he añadido un sencillo dibujo mediante curveVertex(). A medida que vaya avanzando iré descargando más información. Más abajo os dejo un video y el código de este primer prototipo que iré complicando y puliendo a medida que vaya trabajando. Por cierto, se admiten sugerencias.

Código para Processing:

//Importar libreria SoundCipher para controlar sonidos con Processing

import arb.soundcipher.*;

SoundCipher sc1 = new SoundCipher(this);

SoundCipher sc2 = new SoundCipher(this);

//Importar libreria Serie para conectar Arduino con Processing

//(Hay que tener previamente descargada en la microcontroladora la libreria Firmata)

import processing.serial.*;

import cc.arduino.*;

Arduino arduino;

//Pines analogicos de los sensores LDR

int potPin1=0;

int potPin2=1;

//Valores analogicos de los sensores LDR

int val1;

int val2;

//Declaramos los puntos del dibujo que variaran con los datos de los sensores LDR

float point_level_1, point_level_2, point_level_3;

void setup() {

 

size(400, 400);

//Elegimos puerto serie para la placa arduino

arduino = new Arduino(this, Arduino.list()[0], 57600);

smooth();

}

void draw() {

 

  background (255);

  noFill ();

 

//Reduce la lectura analogica de los ensores LDR a una cuarta parte

val1 = arduino.analogRead(potPin1)/4;

val2 = arduino.analogRead(potPin2)/4;

//Mapea los valores entrantes de los sensores LDR a valores adaptados a la ventana de Processing

float grey1= map(val1, 190, 240, 0, 400);

float grey2= map(val2, 190, 240, 0, 400);

//Escribe los valores de los sensores LDR que estan conectados a Arduino

println("val1");

println(val1);

println("val2");

println(val2);

 //Dibujo de la pantalla de Processing

 //1

  point_level_1=map(grey1, 0, width, 25, 50);

  fill (44, 215, 230, 255);

  curveTightness (map(grey1, 0, height, 20, -5));

  beginShape ();

  curveVertex (width/2-point_level_1, height/2+point_level_1);

  curveVertex (width/2+point_level_1, height/2+point_level_1);

  curveVertex (width/2+point_level_1, height/2-point_level_1);

  curveVertex (width/2-point_level_1, height/2-point_level_1);

  curveVertex (width/2-point_level_1, height/2+point_level_1);

  curveVertex (width/2+point_level_1, height/2+point_level_1);

  curveVertex (width/2+point_level_1, height/2-point_level_1);

  endShape ();

  //2

  point_level_2=map(grey2, 0, height, 30, 60);

  fill (255, 59, 142, 200);

  curveTightness (map(grey2, 0, width, -7, 25));

  beginShape ();

  curveVertex (width/2-point_level_2, height/2+point_level_2);

  curveVertex (width/2+point_level_2, height/2+point_level_2);

  curveVertex (width/2+point_level_2, height/2-point_level_2);

  curveVertex (width/2-point_level_2, height/2-point_level_2);

  curveVertex (width/2-point_level_2, height/2+point_level_2);

  curveVertex (width/2+point_level_2, height/2+point_level_2);

  curveVertex (width/2+point_level_2, height/2-point_level_2);

  endShape ();

  //3

  point_level_3=map(grey2, 0, height, -60, -10);

  fill (0, 0, 0, 20);

  curveTightness (map(grey2, 0, height, -5, 20) );

  beginShape ();

  curveVertex (width/2-point_level_3, height/2+point_level_3);

  curveVertex (width/2+point_level_3, height/2+point_level_3);

  curveVertex (width/2+point_level_3, height/2-point_level_3);

  curveVertex (width/2-point_level_3, height/2-point_level_3);

  curveVertex (width/2-point_level_3, height/2+point_level_3);

  curveVertex (width/2+point_level_3, height/2+point_level_3);

  curveVertex (width/2+point_level_3, height/2-point_level_3);

  endShape();

//A partir de un nivel de luz lanzar una nota musical

if(val1 > 230){

 

sc1.playNote(70, 500, 0.2);

delay(800);

}else if(val2 > 230){

sc2.playNote(40, 500, 0.2);

delay(600);

}

}

Proyecto #2

Seguimos trabajando con Arduino y luces. En este caso pasamos de utilizar relés con bombillas de 220V a usar bombillitas led de 3.3V. Este proyecto básicamente consiste en crear una obra de carácter cinético que consta de luces que se apagan y se encienden siguiendo una secuencia de tiempo descargada en la microcontroladora. El programa que vamos a cargar en la placa Arduino es una versión del código básico del famoso BLINK contenido en los ejemplos del IDE de Arduino. La placa está conectada a 12 luces led, utilizando resistencias de 220 Ohm para que no se fundan con los 5V que los pines digitales de la microcontroladora dan por defecto. A continuación se muestran los diferentes elementos que componen el cuadro, un video con el resultado final y el código que lo hace funcionar.

Materiales:

- 12 diodos led

- 12 resistencias de 220 Ohm

- Arduino Duemilanove

- 2 Regletas fluorescentes de 14V

- Adaptador de corriente 220V/9V

- Maderas

- Metacrilato

- Pintura acrílica y óleo

La estructura consta en su interior de dos tubos de luz fluorescente para iluminar la imagen frontal, realizada usando óleo sobre una plancha de metacrilato. La cara posterior es la que consta de una iluminación mediante leds controlados por la placa Arduino.

Vista frontal

Vista lateral

Interior del cuadro

Placa ARDUINO conectada a las luces led

A continuación el código para la placa Arduino. Es muy simple:

//Definimos los pines para cada led.

int ledPin1 = 1;

int ledPin2 = 2;

int ledPin3 = 3;

int ledPin4 = 4;

int ledPin5 = 5;

int ledPin6 = 6;

int ledPin7 = 8;

int ledPin8 = 9;

int ledPin9 = 10;

int ledPin10 = 11;

int ledPin11 = 12;

int ledPin12 = 13;

// El Setup () sólo se lee UNA vez (como en Processing).

void setup() {

pinMode(ledPin1, OUTPUT);

pinMode(ledPin2, OUTPUT);

pinMode(ledPin3, OUTPUT);

pinMode(ledPin4, OUTPUT);

pinMode(ledPin5, OUTPUT);

pinMode(ledPin6, OUTPUT);

pinMode(ledPin7, OUTPUT);

pinMode(ledPin8, OUTPUT);

pinMode(ledPin9, OUTPUT);

pinMode(ledPin10, OUTPUT);

pinMode(ledPin11, OUTPUT);

pinMode(ledPin12, OUTPUT);

}

// El Loop () se lee constantemente.

void loop() {

 

digitalWrite(ledPin1, HIGH);

digitalWrite(ledPin3, HIGH);

digitalWrite(ledPin5, HIGH);

digitalWrite(ledPin7, HIGH);

digitalWrite(ledPin9, HIGH);

digitalWrite(ledPin11, HIGH);

digitalWrite(ledPin2, LOW);

digitalWrite(ledPin4, LOW);

digitalWrite(ledPin6, LOW);

digitalWrite(ledPin8, LOW);

digitalWrite(ledPin10, LOW);

digitalWrite(ledPin12, LOW);

delay(1000);

// Esperamos 1000 milisegundos (1 seg)

digitalWrite(ledPin1, LOW);

digitalWrite(ledPin3, LOW);

digitalWrite(ledPin5, LOW);

digitalWrite(ledPin7, LOW);

digitalWrite(ledPin9, LOW);

digitalWrite(ledPin11, LOW);

digitalWrite(ledPin2, HIGH);

digitalWrite(ledPin4, HIGH);

digitalWrite(ledPin6, HIGH);

digitalWrite(ledPin8, HIGH);

digitalWrite(ledPin10, HIGH);

digitalWrite(ledPin12, HIGH);

delay(1000);

// Esperamos 1000 milisegundos (1 seg)

digitalWrite(ledPin2, HIGH);

digitalWrite(ledPin3, HIGH);

digitalWrite(ledPin5, HIGH);

digitalWrite(ledPin8, HIGH);

digitalWrite(ledPin10, HIGH);

digitalWrite(ledPin11, HIGH);

digitalWrite(ledPin4, LOW);

digitalWrite(ledPin6, LOW);

digitalWrite(ledPin12, LOW);

delay(1000);

digitalWrite(ledPin1, HIGH);

digitalWrite(ledPin4, HIGH);

digitalWrite(ledPin6, HIGH);

digitalWrite(ledPin7, HIGH);

digitalWrite(ledPin9, HIGH);

digitalWrite(ledPin12, HIGH);

digitalWrite(ledPin2, LOW);

digitalWrite(ledPin3, LOW);

digitalWrite(ledPin5, LOW);

digitalWrite(ledPin8, LOW);

digitalWrite(ledPin10, LOW);

digitalWrite(ledPin11, LOW);

delay(1000);

digitalWrite(ledPin1, HIGH);

digitalWrite(ledPin2, HIGH);

digitalWrite(ledPin3, HIGH);

digitalWrite(ledPin4, HIGH);

digitalWrite(ledPin6, HIGH);

digitalWrite(ledPin5, HIGH);

digitalWrite(ledPin7, HIGH);

digitalWrite(ledPin8, HIGH);

digitalWrite(ledPin9, HIGH);

digitalWrite(ledPin10, HIGH);

digitalWrite(ledPin11, HIGH);

digitalWrite(ledPin12, HIGH);

delay(1000);

digitalWrite(ledPin2, LOW);

digitalWrite(ledPin3, LOW);

digitalWrite(ledPin6, LOW);

digitalWrite(ledPin7, LOW);

digitalWrite(ledPin10, LOW);

digitalWrite(ledPin11, LOW);

delay(1000);

digitalWrite(ledPin1, LOW);

digitalWrite(ledPin2, HIGH);

digitalWrite(ledPin3, HIGH);

digitalWrite(ledPin4, LOW);

digitalWrite(ledPin5, LOW);

digitalWrite(ledPin6, HIGH);

digitalWrite(ledPin7, HIGH);

digitalWrite(ledPin8, LOW);

digitalWrite(ledPin9, LOW);

digitalWrite(ledPin10, HIGH);

digitalWrite(ledPin11, HIGH);

digitalWrite(ledPin12, LOW);

delay(1000);

digitalWrite(ledPin1, HIGH);

digitalWrite(ledPin2, LOW);

digitalWrite(ledPin3, LOW);

digitalWrite(ledPin6, LOW);

digitalWrite(ledPin7, LOW);

digitalWrite(ledPin10, LOW);

digitalWrite(ledPin11, LOW);

delay(500);

}

//Puedes cambiar las ordenes encendido/apagado como quieras.

Este es el resultado final: